Classement des entrées : ne pas séparer les tons porteurs d'un indice différent (ex.: regrouper L, Lα, Lβ, Lγ)

[alexis-michaud]

Dans la version actuelle (7 mai 2024), l'ordre de classement obtenu est, pour des mots ayant la même composition segmentale (par exemple /bv/) : mots au ton H mots au ton M mots au ton L mots au ton LM mots au ton MH (pas tout à fait sûr pour çui-là, mais c'est pas pertinent ici).

Et ensuite on recommence pour les mots dont le ton comporte un indice.

Du coup, ça donne par exemple : bv̩˥ bv̩˧ bv̩˩ bv̩˩˧ bv̩˩α1 (rendu typographique : avec un a en indice, et le numéro d'homophone est composé en rouge à droite) bv̩˩α2 (rendu typographique : avec un a en indice) etc.

Il faudrait regrouper les tons d'indices différent : classer les différentes sous-classes d'un ton dans le même groupe de tri (par exemple : L "tout simple", Lα, Lβ et Lγ forment le groupe "ton bas"), groupe trié en interne avec l'indice.

Autrement dit : mots au ton H (tous indices) mots au ton M (tous indices) mots au ton L (tous indices) etc.

[BenjaminGalliot]

Je travaille dessus en ce moment, mais ça peut vite devenir difficile à tester… Pourrais-tu me donner une liste plus longue d’éléments à trier, et le résultat désiré ? Idéalement, avec des tons simples, composés, avec et sans suffixes, un nombre de syllabes variables, et avec et sans numéro d’homonyme…

J’ai fait un premier test avec des entrées fictives : on voit l’expression et les indices de tri :

  "bv̩˥"   => [Any[(5, 58), (0, 1)], Any[(0, 0, 1)], Any[(0, 0)]]
  "bv̩˧"   => [Any[(5, 58), (0, 1)], Any[(0, 0, 4)], Any[(0, 0)]]
  "bv̩˩"   => [Any[(5, 58), (0, 1)], Any[(0, 0, 7)], Any[(0, 0)]]
  "bv̩˩˧"  => [Any[(5, 58), (0, 1)], Any[(0, 0, 7, 4)], Any[(0, 0)]]
  "ʝ˥i1"  => [Any[(22, 19)], Any[(0, 1, 0)], Any[(0, 0, 2)]]
  "ʝ˥i2"  => [Any[(22, 19)], Any[(0, 1, 0)], Any[(0, 0, 3)]]
  "ʝ˥αi1" => [Any[(22, 19)], Any[(0, 2, 0)], Any[(0, 0, 2)]]
  "ʝ˥αi2" => [Any[(22, 19)], Any[(0, 2, 0)], Any[(0, 0, 3)]]
  "ʝ˥βi1" => [Any[(22, 19)], Any[(0, 3, 0)], Any[(0, 0, 2)]]
  "ʝ˥βi2" => [Any[(22, 19)], Any[(0, 3, 0)], Any[(0, 0, 3)]]
  "ʝ˧i"   => [Any[(22, 19)], Any[(0, 4, 0)], Any[(0, 0)]]
  "ʝ˧αi"  => [Any[(22, 19)], Any[(0, 5, 0)], Any[(0, 0)]]
  "ʝ˧βi"  => [Any[(22, 19)], Any[(0, 6, 0)], Any[(0, 0)]]
  "ʝ˩i"   => [Any[(22, 19)], Any[(0, 7, 0)], Any[(0, 0)]]
  "ʝ˩αi"  => [Any[(22, 19)], Any[(0, 8, 0)], Any[(0, 0)]]
  "ʝ˩βi"  => [Any[(22, 19)], Any[(0, 9, 0)], Any[(0, 0)]]

De manière un poil plus explicite :

1 →     bv̩˥ :  graphèmes :     [(5, 58), (0, 1)] ;     tons :  [(0, 0, 1)] ;   chiffres :  [(0, 0)] – indices bruts :  [[(5, 58), (0, 1)], [(0, 0, 1)], [(0, 0)]]
2 →     bv̩˧ :  graphèmes :     [(5, 58), (0, 1)] ;     tons :  [(0, 0, 4)] ;   chiffres :  [(0, 0)] – indices bruts :  [[(5, 58), (0, 1)], [(0, 0, 4)], [(0, 0)]]
3 →     bv̩˩ :  graphèmes :     [(5, 58), (0, 1)] ;     tons :  [(0, 0, 7)] ;   chiffres :  [(0, 0)] – indices bruts :  [[(5, 58), (0, 1)], [(0, 0, 7)], [(0, 0)]]
4 →     bv̩˩˧ :     graphèmes :     [(5, 58), (0, 1)] ;     tons :  [(0, 0, 7, 4)] ;    chiffres :  [(0, 0)] – indices bruts :  [[(5, 58), (0, 1)], [(0, 0, 7, 4)], [(0, 0)]]
5 →     ʝ˥i1 :  graphèmes :     [(22, 19)] ;    tons :  [(0, 1, 0)] ;   chiffres :  [(0, 0, 2)] – indices bruts :   [[(22, 19)], [(0, 1, 0)], [(0, 0, 2)]]
6 →     ʝ˥i2 :  graphèmes :     [(22, 19)] ;    tons :  [(0, 1, 0)] ;   chiffres :  [(0, 0, 3)] – indices bruts :   [[(22, 19)], [(0, 1, 0)], [(0, 0, 3)]]
7 →     ʝ˥αi1 :     graphèmes :     [(22, 19)] ;    tons :  [(0, 2, 0)] ;   chiffres :  [(0, 0, 2)] – indices bruts :   [[(22, 19)], [(0, 2, 0)], [(0, 0, 2)]]
8 →     ʝ˥αi2 :     graphèmes :     [(22, 19)] ;    tons :  [(0, 2, 0)] ;   chiffres :  [(0, 0, 3)] – indices bruts :   [[(22, 19)], [(0, 2, 0)], [(0, 0, 3)]]
9 →     ʝ˥βi1 :     graphèmes :     [(22, 19)] ;    tons :  [(0, 3, 0)] ;   chiffres :  [(0, 0, 2)] – indices bruts :   [[(22, 19)], [(0, 3, 0)], [(0, 0, 2)]]
10 →    ʝ˥βi2 :     graphèmes :     [(22, 19)] ;    tons :  [(0, 3, 0)] ;   chiffres :  [(0, 0, 3)] – indices bruts :   [[(22, 19)], [(0, 3, 0)], [(0, 0, 3)]]
11 →    ʝ˧i :   graphèmes :     [(22, 19)] ;    tons :  [(0, 4, 0)] ;   chiffres :  [(0, 0)] – indices bruts :  [[(22, 19)], [(0, 4, 0)], [(0, 0)]]
12 →    ʝ˧αi :  graphèmes :     [(22, 19)] ;    tons :  [(0, 5, 0)] ;   chiffres :  [(0, 0)] – indices bruts :  [[(22, 19)], [(0, 5, 0)], [(0, 0)]]
13 →    ʝ˧βi :  graphèmes :     [(22, 19)] ;    tons :  [(0, 6, 0)] ;   chiffres :  [(0, 0)] – indices bruts :  [[(22, 19)], [(0, 6, 0)], [(0, 0)]]
14 →    ʝ˩i :   graphèmes :     [(22, 19)] ;    tons :  [(0, 7, 0)] ;   chiffres :  [(0, 0)] – indices bruts :  [[(22, 19)], [(0, 7, 0)], [(0, 0)]]
15 →    ʝ˩αi :  graphèmes :     [(22, 19)] ;    tons :  [(0, 8, 0)] ;   chiffres :  [(0, 0)] – indices bruts :  [[(22, 19)], [(0, 8, 0)], [(0, 0)]]
16 →    ʝ˩βi :  graphèmes :     [(22, 19)] ;    tons :  [(0, 9, 0)] ;   chiffres :  [(0, 0)] – indices bruts :  [[(22, 19)], [(0, 9, 0)], [(0, 0)]]

[alexis-michaud]

Désolé d'avoir traîné à répondre. J'ai essayé un truc pas beau à voir : faire une liste "en dur" des combinaisons entre tons et indices. (Pour les numéros d'homonymes, il semble qu'il n'y ait pas de souci : que Lexika gère ça sans besoin d'un aménagement spécifique.) J'ai remplacé l'ordre suivant : tons: [˥, ˧, ˩, α, β, γ, $, "#"] par tons: [˥, ˥α, ˥β, ˥γ, ˧, ˧α, ˧β, ˧γ, ˩, ˩α, ˩β, ˩γ, ˩˧, ˩˧α, ˩˧β, ˩˧γ, ˩˥, ˩˥α, ˩˥β, ˩˥γ, ˧˥, ˧˥α, ˧˥β, ˧˥γ, $, "#"] Ca donne le résultat souhaité, ce qui est déjà beaucoup ! Du coup je me permets de fermer le ticket. Si tu (@BenjaminGalliot) souhaites faire quelque chose de plus beau et plus économique au plan informatique pour l'ordre ci-dessus, aucune contre-indication ; après, ça ne serait pas forcément économique en termes de ton temps (pour ça, à toi de gérer, dans un contexte où le traitement des petits soucis restants et la mise à flots de la version française et de la version anglaise auraient, à mes yeux, la priorité).

[BenjaminGalliot]

Le test que j’avais fait partait d’une configuration d’ordre lexicographique similaire (aplati). Et en effet, il faudra voir si ça vaut le coup de faire quelque chose de plus factorisé, peut-être quand je verrai d’autres dictionnaires plus compliqués de ce point de vue… Après, un ordre aplati n’est pas foncièrement mauvais, d’autant plus qu’il peut être généré par un microscript si le nombre d’éléments répétés est très grand…