Bonjour

c'est certainement présomptueux de parler de "bug" au sujet d'un environnement (Allegro CL) que je découvre tout juste. Mais, de mon point de vue, c'est ainsi que je le perçois... et c'est pour cette raison que je me tourne vers vous pour avoir votre avis...

Pour vous situer mon contexte, j'ai réalisé des développements en AutoLisp pour ajouter des fonctions utiles aux besoins de mon bureau d'études. Et j'ai découvert Lisp à cette occasion.

J'ai trouvé ce langage si "différent" (dans le bon sens) que j'ai eu envie de le pratiquer en dehors d'AutoCad.

J'ai trouvé "Allegro CL 8.2 Free Express Edition"... je ne sais pas ce que ça vaut ni en quoi consistent les limitations, ni ce que permet les versions payantes.

Avant de m'embarquer dans des trucs et des machins, je fais des essais "brut d'installation", en écrivant des bouts de programme dans un fichier texte (par l'éditeur Allegro, mais c'est pas obligé) et en les chargeant et les exécutant dans la fenêtre Listener... et rien de plus

....


Et donc, je rencontre ce problème de "sort" et même de "stable-sort" qui donnent des résultats curieux...

voici un petit bout de code avec les tris :


Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
; ---------------------------------
(setq
  _program "analyse"
  _ver     "0-003"
  _auteur  "Lisptic"
  )
 
; On transmet un nombre quelconque "d'individus"
; Constitués d'une liste de nombres
 
; 1 - On détermine le nombre d'individus transmis
;  Pour chaque individu :
; 2 - on crée l'individu issu du tri de ses nombres
; 3 - On le compare à chaque autre individu
;     En notant le nombre de nombres qu'il ont en commun
; ---------------------------------
 
 
(defun analyse(&optional _data / _nbIndividu _IndividuS _IndividuS2 _i1 _i2 _nbComm _nombre)
  (if _data
    (progn
 
; 1 - Nombre d'individus transmis
      (setq _nbIndividu (length _data))
 
      (if (> _nbIndividu 1)
        (progn
          (setq
            _i1 0 ; compteur 1 à zéro
          );setq
 
          (loop for _Individu in _data do
 
; 2 - Création et impression de _IndividuS trié        
            (print (setq _i1(1+ _i1)))(prin1 (setq _IndividuS(stable-sort _Individu #'<)))
 
            (setq _i2 0) ; compteur 2 à zéro                                                    
            (loop for _Individu2 in _data do                             
 
; 3 - Comparaison des 2 individus 
              (setq _IndividuS2(stable-sort _Individu2 #'<))       
              (setq _nbComm 0) ; compteur de nombres communs à zéro   
 
              (loop for _nombre in _IndividuS do ; pour chaque nombre de Individu1
                (if (member _nombre _IndividuS2)(setq _nbComm(1+ _nbComm))) ; on regarde s'il appartient à Individu2    
              );loop nombre                     
 
              (print " ")(prin1 (setq _i2(1+ _i2)))(prin1 _IndividuS2)(Prin1 (format nil "   ~S commun(s)" _nbComm)) 
 
            );loop Individu2                          
 
          );loop Individu                  
 
        );progn 
        (progn ;sinon
          (print "Un seul individu ")(prin1 (stable-sort (car _data) #'<))
        );progn 
      );if
 
 
    );progn
    "Analyse attend une liste de nombres : (analyse (list n n n ...))"
  );if
);defun analyse

-------

On lui transmettant une liste de 4 listes de 6 nombres on obtient :

(analyse (list (list 3 45 6 21 7 5)(list 12 6 42 36 9 15)(list 8 28 27 14 6 9)(list 4 25 7 41 32 6)))

-->

1 (3 5 6 7 21 45)
" " 1(3 5 6 7 21 45)" 6 commun(s)"
" " 2(6 9 12 15 36 42)" 1 commun(s)"
" " 3(6 8 9 14 27 28)" 1 commun(s)"
" " 4(4 6 7 25 32 41)" 2 commun(s)"
2 (12 15 36 42)
" " 1(3 5 6 7 21 45)" 0 commun(s)"
" " 2(12 15 36 42)" 4 commun(s)"
" " 3(8 9 14 27 28)" 0 commun(s)"
" " 4(4 6 7 25 32 41)" 0 commun(s)"
3 (8 9 14 27 28)
" " 1(3 5 6 7 21 45)" 0 commun(s)"
" " 2(12 15 36 42)" 0 commun(s)"
" " 3(8 9 14 27 28)" 5 commun(s)"
" " 4(4 6 7 25 32 41)" 0 commun(s)"
4 (4 6 7 25 32 41)
" " 1(3 5 6 7 21 45)" 2 commun(s)"
" " 2(12 15 36 42)" 0 commun(s)"
" " 3(8 9 14 27 28)" 0 commun(s)"
" " 4(4 6 7 25 32 41)" 6 commun(s)"

Les résultats sont assez étonnants


-----------------------------------------

Le même sans les tris :



Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
; ---------------------------------
(setq
  _program "analyse"
  _ver     "0-004"
  _auteur  "Lisptic"
  )
 
; On transmet un nombre quelconque "d'individus"
; Constitués d'une liste de nombres
 
; 1 - On détermine le nombre d'individus transmis
;  Pour chaque individu :
; 2 - on imprime l'individu
; 3 - On le compare à chaque autre individu
;     En notant le nombre de nombres qu'il ont en commun
; ---------------------------------
 
 
(defun analyse(&optional _data / _nbIndividu _Individu2 _i1 _i2 _nbComm _nombre)
  (if _data
    (progn
 
; 1 - Nombre d'individus transmis
      (setq _nbIndividu (length _data))
 
      (if (> _nbIndividu 1)
        (progn
          (setq
            _i1 0 ; compteur 1 à zéro
            _data2 (copy-list _data) ; copie distincte de la liste transmise
          );setq
 
          (loop for _Individu in _data do
 
; 2 - impression de chaque individu      
            (print (setq _i1(1+ _i1)))(prin1 _Individu)                          
 
; 3 - Comparaison à chaque individu + impression du résultat 
            (setq _i2 0) ; compteur 2 à zéro                                                    
            (loop for _Individu2 in _data do  
              (setq _nbComm 0) ; compteur de nombres communs à zéro   
 
              (loop for _nombre in _Individu do ; pour chaque nombre de Individu1
                (if (member _nombre _Individu2)(setq _nbComm(1+ _nbComm))) ; on regarde s'il appartient à Individu2    
              );loop nombre                     
 
              (print " ")(prin1 (setq _i2(1+ _i2)))(prin1 _Individu2)(Prin1 (format nil "   ~S commun(s)" _nbComm)) 
 
            );loop Individu2                          
 
          );loop Individu                  
 
        );progn 
        (progn ;sinon
          (print "Un seul individu ")(prin1 (stable-sort (car _data) #'<))
        );progn 
      );if
 
 
    );progn
    "Analyse attend une liste de listes de nombres : (analyse (list (list n n n)(list n n n)(...)...))"
  );if
);defun analyse
-----------------------------------------

Et son utilisation :


(analyse (list (list 3 45 6 21 7 5)(list 12 6 42 36 9 15)(list 8 28 27 14 6 9)(list 4 25 7 41 32 6)))
-->
1 (3 45 6 21 7 5)
" " 1(3 45 6 21 7 5)" 6 commun(s)"
" " 2(12 6 42 36 9 15)" 1 commun(s)"
" " 3(8 28 27 14 6 9)" 1 commun(s)"
" " 4(4 25 7 41 32 6)" 2 commun(s)"
2 (12 6 42 36 9 15)
" " 1(3 45 6 21 7 5)" 1 commun(s)"
" " 2(12 6 42 36 9 15)" 6 commun(s)"
" " 3(8 28 27 14 6 9)" 2 commun(s)"
" " 4(4 25 7 41 32 6)" 1 commun(s)"
3 (8 28 27 14 6 9)
" " 1(3 45 6 21 7 5)" 1 commun(s)"
" " 2(12 6 42 36 9 15)" 2 commun(s)"
" " 3(8 28 27 14 6 9)" 6 commun(s)"
" " 4(4 25 7 41 32 6)" 1 commun(s)"
4 (4 25 7 41 32 6)
" " 1(3 45 6 21 7 5)" 2 commun(s)"
" " 2(12 6 42 36 9 15)" 1 commun(s)"
" " 3(8 28 27 14 6 9)" 1 commun(s)"
" " 4(4 25 7 41 32 6)" 6 commun(s)"

avec des résultats corrects !

-----------------------------------------

J'espère que ce comportement est normal et que c'est moi qui me plante quelque part !
Merci d'avance pour vos avis (et conseils pour la suite)