Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
8467 connectés 

 


 Mot :   Pseudo :  
 
 Page :   1  2  3  4  5  6  7  8  9  10  11  12  13  14  15
Auteur Sujet :

[Ada][Topic Unic][Open Source] Je fais péter mes codes.

n°2546575
lady ada
Posté le 22-10-2026 à 20:32:47  profilanswer
 

Reprise du message précédent :
Je suis sur debian.
 
J'ai trouvé la commande reptyr.
 
Cependant le key code de la touche enter est modifié de 10 en 13.
Et j'attends 10.


---------------
main is business suite for Ada projects. Web site : inconito.net
mood
Publicité
Posté le 22-10-2026 à 20:32:47  profilanswer
 

n°2546576
lady ada
Posté le 23-10-2026 à 02:10:44  profilanswer
 

Le problème n'en est pas réellement un.
 
Même si Get_Line est inutilisable après l'affectation du processus avec reptyr ; L'écriture d'une fonction utilisant Get_Immediate pour retourner une chaîne sera un jeu d'enfant ; Car Get_Immediate rempli sa tache malgrès tout.
En revanche Get_Line(File) fonctionne.


Message édité par lady ada le 23-10-2026 à 02:28:18

---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546577
lady ada
Posté le 22-10-2026 à 09:11:26  profilanswer
 

Bonjour,
 
J'ai écrit un système clien/serveur et je souhaiterais redemarrer le serveur en une commande.
 
Pour faire celà, j'utilise simplement OS_Lib.Spawn pour rappeller le programme.
 
Malheureusement, bien qu'ayant stopé le serveur auparavant ; Je reste coincé sur l'instruction bind dans la nouvelle instance.
 
Je viens voir quelle est la solution s'il vous plait ?
 
Merci.


Message édité par lady ada le 22-10-2026 à 18:33:33

---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546578
lady ada
Posté le 22-10-2026 à 18:31:09  profilanswer
 

Et bien ; En ajoutant Close_Socket(Srv_Socket) à la fin du serveur ; Ca redémarre.  :whistle:


---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546579
lady ada
Posté le 04-11-2026 à 18:28:22  profilanswer
 

Tout simplement.
Bonjour !
Merci pour votre participation ;-)


Message édité par lady ada le 04-11-2026 à 18:53:16

---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546580
lady ada
Posté le 07-11-2026 à 05:21:34  profilanswer
 

Bonjour ;
 
Le système d'exploitation est GNU/Linux Debian Trixie et le compilateur indique 14.2.0 Free Software Fondation.
 
Le compilateur indique une erreur à l'appel de gnatmake :
 

error: nested array aggregate expected


 
La ligne concernée est la suivante :
 

Code :
  1. Default : Taquin_8x8 := (others => (others => 0));


 
Alors que le tableau est celui - ci :
 

Code :
  1. type Matrix_8x8 is array (1..4, 1..4) of integer;


 
 
Je comprends pas.
 
Je suis désolé.
 
Merci pour vos lumières.


Message édité par lady ada le 07-11-2026 à 07:28:36

---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546581
lady ada
Posté le 07-11-2026 à 05:39:37  profilanswer
 

Le type Taquin_8x8 est le suivant :
 

Code :
  1. type Taquin_8x8 is
  2.      record
  3.         Matrix : Matrix_8x8;
  4.      end record;


 
La correction à apporter est la suivante :
 
 
 

Code :
  1. Default : Taquin_8x8 := (Matrix => others => (others => 0)));


Message édité par lady ada le 07-11-2026 à 05:39:51

---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546582
lady ada
Posté le 07-11-2026 à 07:45:22  profilanswer
 

Bonjouir !
 
J'avoue que je pêche à l'établissment de ce problème.
Merci pour vos lumières.


Message édité par lady ada le 07-11-2026 à 07:45:37

---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546583
mechkurt
Posté le 07-11-2026 à 08:36:13  profilanswer
 

Le plus simple et de prendre la position vide est de l’échanger avec un voisin possible de manière aléatoire un grand nombre de fois (faire jouer la machine toute seule en somme).


---------------
D3
n°2546584
lady ada
Posté le 07-11-2026 à 08:40:37  profilanswer
 

Le plus simple ?
Oulala !


---------------
main is business suite for Ada projects. Web site : inconito.net
mood
Publicité
Posté le 07-11-2026 à 08:40:37  profilanswer
 

n°2546585
lady ada
Posté le 07-11-2026 à 08:51:26  profilanswer
 

Merci, 6 lines.


---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546586
lady ada
Posté le 12-11-2026 à 07:39:42  profilanswer
 

25 itérations et une réponse en 2minutes.
25 itérations et une réponse 1s.
 
Les aléas !


---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546587
spark
Luc ?
Posté le 17-11-2026 à 08:32:29  profilanswer
 

t'en a pas marre de parler tout seul ? :o
 
et je comprends pas trop le but de tes posts... tu avances rien comme informations...


---------------
Un cycle complet sera une série de 100.
n°2546588
lady ada
Posté le 17-11-2026 à 09:05:11  profilanswer
 

spark a écrit :

t'en a pas marre de parler tout seul ? :o
 
et je comprends pas trop le but de tes posts... tu avances rien comme informations...


Le monde serait fondé sur des paradoxes.


---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546589
lady ada
Posté le 12-11-2026 à 00:18:40  profilanswer
 

Bonjour,
 
Mon implémentation avace Ada trouve une solution. Cependant la liste retournée est incomplète.
 
 

Code :
  1. procedure Astar (open : in Element_List;
  2.                close  : in out Element_List) is
  3.     
  4.     
  5.     
  6.      Openned : Node_List;    
  7.      Closed : Node_List;
  8.     
  9.      Openned_Curs : Node_Lists.Cursor;
  10.      Close_Curs : Element_Lists.Cursor;
  11.     
  12.      Done : Boolean := False;
  13.     
  14.      Initial_Node : Node_Record;
  15.      Goal : Element;
  16.      Node : Node_Record;
  17.     
  18.      begin
  19.      Goal := Element_Lists.Last_Element(close);
  20.      Close_Curs := Element_Lists.First(close);
  21.      Adjust(Initial_Node, Element_Lists.First_Element(open));    
  22.      Node_Lists.Append(Openned, Initial_Node);
  23.      Element_Lists.Delete_First(Close);          
  24.      Text_Io.Put_Line("initialized !" );
  25.     
  26.     Astar_Loop :
  27.     
  28.      while not Is_Empty(Openned) loop
  29.         
  30.         U_Sorting.Sort(Openned);
  31.         H_Sorting.Sort(Openned);
  32.         declare
  33.            Openned_Find_Curs : Node_Lists.Cursor :=
  34.          Node_Lists.First(Openned);
  35.            Best_Node : Node_Record;
  36.            F : Float := 0.0;
  37.         begin
  38.            Best_Node := Node_Lists.Element(Openned_Find_Curs);          
  39.            Node_Lists.Delete_First(Openned);          
  40.           
  41.  
  42.            declare
  43.           Best_Successors : El_Array := Successors(Best_Node.E);
  44.           
  45.            begin
  46.  
  47.           for Succ in Best_Successors ' range loop
  48.              declare
  49.             E : Element := Best_Successors(Succ);
  50.              begin
  51.             
  52.             
  53.             if Equal(E, Goal) then
  54.                Adjust(Node, E);
  55.               
  56.                Node_Lists.Append(Closed, Node);
  57.                --Adjust(Node, Goal);
  58.                Text_Io.Put_Line("Count : " & Integer'Image(Integer(Node_Lists.Length (Closed))));
  59.                --Node_Lists.Append(Closed, Node);
  60.  
  61.                Text_Io.Put_Line("Goal !" );
  62.                exit Astar_Loop;                      
  63.             else
  64.               
  65.                Adjust(Node, E);
  66.               
  67.                Node.Ucost :=  Best_Node.Ucost + heuristic(Node.E) + Best_Node.Hcost;
  68.                Text_Io.Put_Line("Ucost : " & float'Image(Node.ucost));
  69.                Node.Hcost := Best_Node.Hcost + Heuristic(Node.E) - Uniform(Node.E);
  70.                Text_Io.Put_Line("Hcost : " & float'Image(Node.Hcost));
  71.                F := Node.Hcost + Best_Node.ucost + Uniform(Node.E);
  72.               
  73.               
  74.               
  75.                Text_Io.Put_Line("F : " & Float'Image(F));
  76.               
  77.                if (Node.Hcost + (Node.Ucost) + Best_Node.ucost) < F then
  78.                   Node_Lists.Append(closed, node);
  79.               
  80.                   
  81.                   
  82.                   
  83.                end if;
  84.                if not Node_Lists.Is_Empty(openned) then
  85.                  Text_Io.Put_Line("Openned length : " & Integer'Image(Integer(Node_Lists.Length(openned))));
  86.                  declare
  87.                     Open_Curs : Node_Lists.Cursor := Node_Lists.First(Openned);
  88.                  begin
  89.                     
  90.                     declare
  91.                        Open_Node : Node_Record := Node_Lists.Element(Open_Curs);
  92.                     begin
  93.                       
  94.                        if Equal(Open_Node.E, Node.E)
  95.                       and (Open_Node.Ucost + Open_Node.Hcost) > F then
  96.                       Done := True;
  97.                        end if;
  98.                       
  99.                     end;
  100.                     
  101.                     if not Done then
  102.                        for Open in 1..Node_Lists.Length(openned) - 1 loop
  103.                       Open_Curs := Node_Lists.Next(Open_Curs);
  104.                       
  105.                       declare
  106.                          Open_Node : Node_Record := Node_Lists.Element(Open_Curs);
  107.                       begin
  108.                         
  109.                          if Equal(Open_Node.E, Node.E)
  110.                         and  (Open_Node.Ucost + Open_Node.Hcost) > F then
  111.                         Done := True;
  112.                          end if;
  113.                         
  114.                       end;
  115.                       exit when Open = Node_Lists.Length(Openned);
  116.                       
  117.                       
  118.                        end loop;
  119.                     end if;
  120.                     
  121.                     
  122.                  end;
  123.                   end if;
  124.                   if not Done then
  125.                  Node_Lists.Append(Openned, Node);
  126.  
  127.                 
  128.                   end if;
  129.                   Done := False;
  130.  
  131.                   
  132.  
  133.             end if;            
  134.              end;
  135.           end loop;
  136.           
  137.            end;
  138.         end;
  139.         
  140.         
  141.      end loop Astar_Loop;
  142.     
  143.      Openned_Finalization(close, closed);
  144.      --Element_Lists.Reverse_Elements(Close);
  145.     
  146.      end Astar;


 

1 2 0 4
 5 6 3 7
 9 10 11 8
 13 14 15 12
 1 2 3 4
 5 6 11 7
 9 10 15 8
 13 14 0 12
 1 2 3 4
 5 6 7 0
 9 10 11 8
 13 14 15 12
 1 2 3 4
 5 0 6 7
 9 10 11 8
 13 14 15 12
 1 0 3 4
 5 2 6 7
 9 10 11 8
 13 14 15 12
 1 2 3 4
 5 10 6 7
 9 14 11 8
 13 0 15 12
 1 2 3 4
 5 6 7 0
 9 10 11 8
 13 14 15 12
 1 2 3 4
 0 5 6 7
 9 10 11 8
 13 14 15 12
 1 2 3 4
 5 6 11 7
 9 10 15 8
 13 14 0 12
 1 2 4 0
 5 6 3 7
 9 10 11 8
 13 14 15 12
 1 0 2 4
 5 6 3 7
 9 10 11 8
 13 14 15 12
 1 2 3 0
 5 6 7 4
 9 10 11 8
 13 14 15 12
 1 2 3 4
 5 6 7 8
 9 10 11 12
 13 14 15 0


 
Merci pour votre aide.


Message édité par lady ada le 18-11-2026 à 19:35:46

---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546590
lady ada
Posté le 12-11-2026 à 01:42:37  profilanswer
 

J'en suis là  
 

Init...
 1 2 3 4
 5 6 7 8
 9 10 11 12
 13 14 15 0
Random...
Step :  5
 1 2 3 4
 0 5 6 7
 9 10 11 8
 13 14 15 12
Init...
Astar...
initialized !
Ucost :  9.99998E+05
Hcost : -1.00000E+00
F : -1.00000E+06
Ucost :  9.99998E+05
Hcost : -1.00000E+00
F : -1.00000E+06
Openned length :  1
Ucost :  9.99998E+05
Hcost : -1.00000E+00
F : -1.00000E+06
Openned length :  2
Ucost :  9.99996E+05
Hcost : -1.00000E+00
F : -1.00000E+06
Openned length :  2
Count :  5
Goal !
Count :  5
List...
First...
 
 5
 0 2 3 4
 1 5 6 7
 9 10 11 8
 13 14 15 12
 1 2 3 4
 9 5 6 7
 13 10 11 8
 0 14 15 12
 1 2 3 4
 5 6 7 0
 9 10 11 8
 13 14 15 12
 1 2 3 0
 5 6 7 4
 9 10 11 8
 13 14 15 12
 1 2 3 4
 5 6 7 8
 9 10 11 12
 13 14 15 0


 
Ucost et Hcost sont initialisés à 999_999.0 et je fais des soustractions
 

Code :
  1. --
  2.               Adjust(Node, E);
  3.               
  4.                Node.Ucost :=  (Best_Node.Ucost - uniform(Node.E)) + Best_Node.Hcost;
  5.                Text_Io.Put_Line("Ucost : " & float'Image(Node.ucost));
  6.                Node.Hcost := Best_Node.Hcost + Heuristic(Node.E) + Uniform(Node.E);
  7.                Text_Io.Put_Line("Hcost : " & float'Image(Node.Hcost));
  8.                F := Node.Hcost - Best_Node.ucost - Uniform(Node.E);
  9.               
  10.               
  11.               
  12.                Text_Io.Put_Line("F : " & Float'Image(F));
  13.               
  14.                if (Best_Node.Hcost - Node.ucost) + Node.hcost > F then
  15.                   Node_Lists.Append(closed, node);
  16.               
  17.                   
  18.                   
  19.                   
  20.  
  21.  
  22.                end if;


Message édité par lady ada le 12-11-2026 à 01:52:28

---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546591
lady ada
Posté le 12-11-2026 à 05:28:43  profilanswer
 

Init...
 1 2 3 4
 5 6 7 8
 9 10 11 12
 13 14 15 0
Random...
Step :  5
 1 2 3 4
 5 6 7 8
 9 0 10 11
 13 14 15 12
Init...
Astar...
initialized !
Ucost :  3.00000E+00
Hcost : -1.20000E+01
F :  1.00000E+01
Ucost :  3.00000E+00
Hcost : -1.20000E+01
F :  1.00000E+01
Openned length :  1
Ucost :  5.00000E+00
Hcost : -1.20000E+01
F :  1.40000E+01
Openned length :  2
Ucost :  6.00000E+00
Hcost : -1.20000E+01
F :  1.60000E+01
Openned length :  3
Ucost :  2.10000E+01
Hcost : -3.60000E+01
F :  5.40000E+01
Openned length :  3
Ucost :  2.10000E+01
Hcost : -3.60000E+01
F :  5.40000E+01
Openned length :  4
Count :  7
Goal !
Count :  7
List...
First...
 
 7
 1 2 3 4
 5 0 7 8
 9 6 10 11
 13 14 15 12
 1 2 3 4
 5 6 7 8
 0 9 10 11
 13 14 15 12
 1 2 3 4
 5 6 7 8
 9 14 10 11
 13 0 15 12
 1 2 3 4
 5 6 7 8
 9 10 11 0
 13 14 15 12
 1 2 3 4
 5 6 7 0
 9 10 11 8
 13 14 15 12
 1 2 3 4
 5 6 7 8
 9 10 0 11
 13 14 15 12
 1 2 3 4
 5 6 7 8
 9 10 11 12
 13 14 15 0
 
Astar task halted.


Code :
  1. --
  2.           Adjust(Node, E);
  3.               
  4.                Node.Ucost :=  -((Best_Node.Hcost) + (Best_Node.ucost))  + Uniform(Node.E);
  5.                Text_Io.Put_Line("Ucost : " & float'Image(Node.ucost));
  6.                Node.Hcost := Heuristic(Node.E) + (Best_Node.Hcost - Node.Ucost);
  7.                Text_Io.Put_Line("Hcost : " & float'Image(Node.Hcost));
  8.                F :=  (-(Node.Hcost) + Node.Ucost + heuristic(Node.E));
  9.               
  10.               
  11.               
  12.                Text_Io.Put_Line("F : " & Float'Image(F));
  13.                if (Node.Hcost + Node.Ucost + Best_Node.Ucost) - Uniform((Best_Node.E)) > -F then
  14.                   Node_Lists.Append(closed, node);
  15.                end if;


 

Code :
  1. type Node_Record is tagged
  2.      record
  3.         E : Element;
  4.         Ucost : Float := 0.0;
  5.         Hcost  : Float := 0.0;
  6.      end record;


 

Code :
  1. function Token_Length(Usr : in Taquin_8x8) return Float is
  2.      --Count : Integer := 0;
  3.   begin
  4.      for Line in Usr.Matrix'Range(1) loop
  5.           for Col in  Usr.Matrix'Range(2) loop
  6.              if Usr.Matrix(Line, Col).Num = 0 then
  7.                 return -Float((Usr.Matrix'Last(1) - (Line) + (Usr.Matrix'Last(2) - (Col)))); --Float(Count);
  8.              end if;
  9.           end loop;
  10.      end loop;
  11.      return 1.0;
  12.   end Token_length;
  13.  
  14.  
  15.  
  16.  
  17.   function Heuristic (Usr : in Taquin_8x8) return Float is
  18.      
  19.      
  20.      
  21.      
  22.   begin
  23.      
  24.      return Token_Length(Usr) - 1.0;
  25.   end Heuristic;
  26.  
  27.   function Uniform (Usr : in Taquin_8x8) return Float is
  28.      --Count : Integer := 0;
  29.   begin
  30.      for Line in reverse Usr.Matrix'Range(1) loop
  31.           for Col in reverse Usr.Matrix'Range(2) loop
  32.              if Usr.Matrix(Line, Col).Num = 0 then
  33.                 return Float((Usr.Matrix'Last(1) + (Line) + (Usr.Matrix'Last(2) + (Col)))) + 1.0;-- Float(Count);
  34.              end if;
  35.           end loop;
  36.      end loop;
  37.      return  1.0;
  38.   end Uniform;


Message édité par lady ada le 12-11-2026 à 05:40:17

---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546592
lady ada
Posté le 14-11-2026 à 14:43:57  profilanswer
 

Une première correction.
je dois érifier le contenu de la liste.

Code :
  1. procedure Astar (open : in Element_List;
  2.                close  : in out Element_List) is
  3.     
  4.     
  5.     
  6.      Openned : Node_List;    
  7.      Closed : Node_List;
  8.     
  9.      Openned_Curs : Node_Lists.Cursor;
  10.      Close_Curs : Element_Lists.Cursor;
  11.     
  12.      Done : Boolean := False;
  13.     
  14.      Initial_Node : Node_Record;
  15.      Goal : Element;
  16.      Node : Node_Record;
  17.     
  18.      begin
  19.      Goal := Element_Lists.Last_Element(close);
  20.      Close_Curs := Element_Lists.First(close);
  21.      Adjust(Initial_Node, Element_Lists.First_Element(open));    
  22.      Node_Lists.Append(Openned, Initial_Node);
  23.      Element_Lists.Delete_First(Close);          
  24.      Text_Io.Put_Line("initialized !" );
  25.     
  26.     Astar_Loop :
  27.     
  28.      while not Is_Empty(Openned) loop
  29.         
  30.         U_Sorting.Sort(Openned);
  31.         H_Sorting.Sort(Openned);
  32.         declare
  33.            Openned_Find_Curs : Node_Lists.Cursor :=
  34.          Node_Lists.First(Openned);
  35.            Best_Node : Node_Record;
  36.            F : Float := 0.0;
  37.         begin
  38.            Best_Node := Node_Lists.Element(Openned_Find_Curs);
  39.            Node_Lists.Delete_First(Openned);          
  40.           
  41.  
  42.            declare
  43.           Best_Successors : El_Array := Successors(Best_Node.E);
  44.           
  45.            begin
  46.           
  47.           for Succ in Best_Successors ' range loop
  48.              declare
  49.             E : Element := Best_Successors(Succ);
  50.              begin
  51.             
  52.             
  53.             if Equal(E, Goal) then
  54.                Adjust(Node, E);
  55.               
  56.                Node_Lists.Append(Closed, Node);
  57.               
  58.                Text_Io.Put_Line("Count : " & Integer'Image(Integer(Node_Lists.Length (Closed))));
  59.               
  60.  
  61.                Text_Io.Put_Line("Goal !" );
  62.                exit Astar_Loop;                      
  63.             else
  64.               
  65.                Adjust(Node, E);
  66.                  Node.Ucost :=  ((Best_Node.Hcost) - (Best_Node.ucost))  + Uniform(Node.E) + heuristic(node.E);
  67.                Text_Io.Put_Line("Ucost : " & float'Image(Node.ucost));
  68.                Node.Hcost := Heuristic(Node.E) + (Best_Node.Hcost - Node.Ucost);
  69.                Text_Io.Put_Line("Hcost : " & float'Image(Node.Hcost));
  70.               
  71.                F :=  (Node.Hcost + Node.Ucost + heuristic(Node.E)) ;
  72.               
  73.               
  74.               
  75.                Text_Io.Put_Line("F : " & Float'Image(F));
  76.                     if (Node.Hcost - Node.Ucost + Best_Node.Ucost) - Uniform((Best_Node.E)) > -F then
  77.               
  78.                   Node_Lists.Append(closed, node);
  79.                   
  80.                if not Node_Lists.Is_Empty(openned) then
  81.                  Text_Io.Put_Line("Openned length : " & Integer'Image(Integer(Node_Lists.Length(openned))));
  82.                  declare
  83.                     Open_Curs : Node_Lists.Cursor := Node_Lists.First(Openned);
  84.                  begin
  85.                     
  86.                     declare
  87.                        Open_Node : Node_Record := Node_Lists.Element(Open_Curs);
  88.                     begin
  89.                       
  90.                        if Equal(Open_Node.E, Node.E) then
  91.                       
  92.                       Done := True;
  93.                        end if;
  94.                       
  95.                     end;
  96.                     
  97.                     if not Done then
  98.                        for Open in 1..Node_Lists.Length(openned) - 1 loop
  99.                       Open_Curs := Node_Lists.Next(Open_Curs);
  100.                       
  101.                       declare
  102.                          Open_Node : Node_Record := Node_Lists.Element(Open_Curs);
  103.                       begin
  104.                         
  105.                          if Equal(Open_Node.E, Node.E) then
  106.                         
  107.                         Done := True;
  108.                          end if;
  109.                         
  110.                       end;
  111.                       exit when Open = Node_Lists.Length(Openned);
  112.                       
  113.                       
  114.                        end loop;
  115.                     end if;
  116.                     
  117.                     
  118.                  end;
  119.                   end if;
  120.                   if not Done then
  121.                  Node_Lists.Append(Openned, Node);
  122.  
  123.                 
  124.                   end if;
  125.                   Done := False;
  126.  
  127.                end if;            
  128. end if;              
  129.              end;
  130.           end loop;
  131.           
  132.            end;
  133.         end;
  134.         
  135.         
  136.      end loop Astar_Loop;
  137.     
  138.      Openned_Finalization(close, closed);
  139.  
  140.     
  141.      end Astar;


Message édité par lady ada le 14-11-2026 à 14:45:01

---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546593
lady ada
Posté le 17-11-2026 à 09:01:16  profilanswer
 

Bonjour !
 
J'ai écrit deux fonctions, uniform et heuristic plus significatives qu'une simple incrémentation dans l'objectif de retourner le chemin de la solution exclusivement.
 
Je suis néanmoins dans une impasse au regard des calculs que je reussi à établire.
 
Voici un exemple de résultat :
 
 

Init...
 1 2 3
 4 5 6
 7 8 0
Random...
Step :  9
 1 2 3
 4 5 0
 7 8 6
Init...
Astar...
initialized !
Best_Node :
 1 2 3
 4 5 0
 7 8 6
Ucost :  0.00000E+00
Hcost :  0.00000E+00
 1 2 0
 4 5 3
 7 8 6
Ucost : -6.00000E+00
Hcost : -5.00000E+00
F : -1.10000E+01
-5.00000E+00 > -1.10000E+01
 1 2 3
 4 0 5
 7 8 6
Ucost : -5.00000E+00
Hcost : -6.00000E+00
F : -1.10000E+01
-6.00000E+00 > -1.10000E+01
 1 2 3
 4 5 6
 7 8 0
Ucost :  1.00000E+00
Hcost : -9.00000E+00
F : -9.00000E+00
-8.00000E+00 > -9.00000E+00
Goal !
Count :  3
List...
Press enter...
 3
 1 2 0
 4 5 3
 7 8 6
 1 2 3
 4 0 5
 7 8 6
 1 2 3
 4 5 6
 7 8 0
 
Astar task halted.


 
Les fonction évoquées plus haut :
 

Code :
  1. function Token_Length(Usr : in Taquin_8x8) return Float is
  2.  
  3.   begin
  4.      for Line in Usr.Matrix'Range(1) loop
  5.           for Col in  Usr.Matrix'Range(2) loop
  6.              if Usr.Matrix(Line, Col).Num = 0 then
  7.                 return -float(Usr.Matrix'Last(1) - (Line) + (Usr.Matrix'Last(2) - (Col)));
  8.              end if;
  9.           end loop;
  10.      end loop;
  11.      return 1.0;
  12.   end Token_length;
  13.  
  14.   function Heuristic (Usr : in Taquin_8x8) return Float is
  15.      
  16.      count : float := 0.0;
  17.   begin
  18.      for Line in Usr.Matrix'Range(1) loop
  19.           for Col in  Usr.Matrix'Range(2) loop
  20.              if Usr.Matrix(Line, Col).Num /= 0 then
  21.                 count := Count - float((Usr.Matrix(Line, Col).Num - (((Line) * (Col)))));
  22.              end if;
  23.           end loop;
  24.      end loop;
  25.    
  26.      return count + Token_Length(Usr);
  27.   end Heuristic;


 

Code :
  1. function Uniform (Usr : in Taquin_8x8) return Float is
  2.      
  3.      Total : Float := Float(Usr.Matrix'Last(1) * Usr.Matrix'Last(2));
  4.      
  5.   begin
  6.      for Line in reverse Usr.Matrix'Range(1) loop
  7.           for Col in reverse Usr.Matrix'Range(2) loop
  8.              if Usr.Matrix(Line, Col).Num = 0 then
  9.            if Usr.Matrix'Last(1) /= Line or Usr.Matrix'Last(2) /= Col then
  10.           return Float((Line) * (Col)) - Total;
  11.            else
  12.           return 1.0;
  13.            end if;
  14.              end if;
  15.           end loop;
  16.      end loop;
  17.      return  1.0;
  18.   end Uniform;


 
Enfin, mon implémentation de Astar :
 

Code :
  1. procedure Astar (open : in Element_List;
  2.                close  : in out Element_List) is
  3.     
  4.      Openned : Node_List;    
  5.      Closed : Node_List;
  6.     
  7.      Openned_Curs : Node_Lists.Cursor;
  8.      Close_Curs : Element_Lists.Cursor;
  9.     
  10.      Done : Boolean := False;
  11.     
  12.      Initial_Node : Node_Record;
  13.      Goal : Element;
  14.      Node : Node_Record;
  15.  
  16.      Exhausted : boolean := false;
  17.  
  18.      begin
  19.      Goal := Element_Lists.Last_Element(close);
  20.      Close_Curs := Element_Lists.First(close);
  21.      Adjust(Initial_Node, Element_Lists.First_Element(open));    
  22.      Node_Lists.Append(Openned, Initial_Node);
  23.      Element_Lists.Delete_First(Close);          
  24.      Text_Io.Put_Line("initialized !" );
  25.     
  26.     Astar_Loop :
  27.     
  28.      while not Is_Empty(Openned) loop
  29.         
  30.         U_Sorting.Sort(Openned);
  31.         H_Sorting.Sort(Openned);
  32.         declare
  33.            Openned_Find_Curs : Node_Lists.Cursor :=
  34.          Node_Lists.First(Openned);
  35.            Best_Node : Node_Record;
  36.            F : Float := 0.0;
  37.         begin
  38.            Best_Node := Node_Lists.Element(Openned_Find_Curs);
  39.            text_io.put_line("Best_Node :" );
  40.            print(Best_node.E);
  41.            Text_Io.Put_Line("Ucost : " & float'Image(Best_Node.ucost));
  42.            Text_Io.Put_Line("Hcost : " & float'Image(Best_Node.Hcost));
  43.            Node_Lists.Delete_First(Openned);          
  44.           
  45.            declare
  46.           Best_Successors : El_Array := Successors(Best_Node.E);
  47.           
  48.            begin
  49.           
  50.           for Succ in Best_Successors ' range loop
  51.              declare
  52.             E : Element := Best_Successors(Succ);
  53.              begin
  54.  
  55.             
  56.             if Equal(E, Goal) then
  57.             print(E);
  58.                Adjust(Node, E);              
  59.                Node.Ucost :=  Best_Node.ucost  + (Uniform(Node.E));
  60.                  Node.Hcost := (Heuristic(Node.E) + Best_Node.Hcost);
  61.                     F := (best_node.ucost + heuristic(Node.E)) ;
  62.                  Text_Io.Put_Line("Ucost : " & float'Image(Node.ucost));
  63.                  Text_Io.Put_Line("Hcost : " & float'Image(Node.Hcost));
  64.                     Text_Io.Put_Line("F : " & Float'Image(F));
  65.                  Text_Io.Put_Line(Float'Image(Node.Hcost + Best_Node.Ucost + uniform(Node.E)) & " > " & Float'Image(F));
  66.                Node_Lists.Append(Closed, Node);
  67.                Text_Io.Put_Line("Goal !" );
  68.                exit Astar_Loop;                      
  69.             else
  70.                print(E);
  71.                Adjust(Node, E);
  72.               
  73.                  Node.Ucost :=  Best_Node.ucost  + (Uniform(Node.E));
  74.                Text_Io.Put_Line("Ucost : " & float'Image(Node.ucost));
  75.  
  76.                Node.Hcost := (Heuristic(Node.E) + Best_Node.Hcost);
  77.                Text_Io.Put_Line("Hcost : " & float'Image(Node.Hcost));
  78.               
  79.  
  80.                  F := (best_node.hcost + Best_Node.ucost +
  81.                    heuristic(Node.E) + Uniform(Node.E));
  82.                  Text_Io.Put_Line("F : " & Float'Image(F));
  83.  
  84.                Text_Io.Put_Line(Float'Image(Node.Hcost + Best_Node.Ucost) & " > " & Float'Image(F));
  85.                if Node.hcost + Best_Node.Ucost > F then
  86.                   
  87.                   Node_Lists.Append(closed, node);
  88.                   Node.Hcost := F;
  89.                   Node.ucost := F + uniform(Node.E);
  90.  
  91.                if not Node_Lists.Is_Empty(openned) then
  92.  
  93.                  declare
  94.                     Open_Curs : Node_Lists.Cursor := Node_Lists.First(Openned);
  95.                  begin
  96.                     
  97.                     declare
  98.                        Open_Node : Node_Record := Node_Lists.Element(Open_Curs);
  99.                     begin
  100.                       
  101.                        if Equal(Open_Node.E, Node.E) then
  102.                       
  103.                       Done := True;
  104.                        end if;
  105.                       
  106.                     end;
  107.                     
  108.                     if not Done then
  109.                        for Open in 1..Node_Lists.Length(openned) - 1 loop
  110.                       Open_Curs := Node_Lists.Next(Open_Curs);
  111.                       
  112.                       declare
  113.                          Open_Node : Node_Record := Node_Lists.Element(Open_Curs);
  114.                       begin
  115.                         
  116.                          if Equal(Open_Node.E, Node.E) then
  117.                         
  118.                         Done := True;
  119.                          end if;
  120.                         
  121.                       end;
  122.                       exit when Open = Node_Lists.Length(Openned);
  123.                        end loop;
  124.                     end if;
  125.                  end;
  126.                   end if;
  127.                   if not Done then
  128.                  Node_Lists.Append(Openned, Node);
  129.                   end if;
  130.  
  131.                   Done := False;
  132.  
  133.                end if;
  134.                  end if;
  135.              end;
  136.           end loop;
  137.            end;
  138.         end;
  139.      end loop Astar_Loop;
  140.      Openned_Finalization(close, closed);
  141.      end Astar;


Message édité par lady ada le 17-11-2026 à 09:10:12

---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546594
dow33t
Posté le 17-11-2026 à 10:37:51  profilanswer
 

salut,
 
dans a*, chaque état a f = g + h :
- g = le coût du chemin depuis le départ. au taquin chaque coup vaut 1, donc g d'un successeur = g du parent + 1 (0 au départ).
- h = une estimation de ce qu'il reste, qui ne doit jamais surestimer. la classique au taquin : la somme des distances de manhattan entre chaque pièce et sa place finale. elle vaut 0 au but et n'est jamais négative.
à chaque tour, on sort de la liste ouverte l'état qui a le plus petit f.
 
dans ton code, trois choses s'en écartent : Ucost ajoute Uniform(), qui dépend de la place du vide, au lieu de 1 ; Hcost ajoute le Hcost du parent, alors que h se calcule sur l'état seul ; et Heuristic donne -9 sur l'état final (ta sortie : Hcost : -9 au but) au lieu de 0. vérifie aussi que la liste ouverte est bien triée sur Ucost + Hcost : dans ce que tu montres, elle passe par U_Sorting puis H_Sorting.


---------------
Dev indé — ShapeMorph, mon jeu de formes sur mobile et prixometre.fr, mon comparateur de prix, qui vit des liens marchands
n°2546595
lady ada
Posté le 17-11-2026 à 11:21:31  profilanswer
 

Merci d'être passé par là.
Bonne continuation...


---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546596
lady ada
Posté le 17-11-2026 à 14:38:43  profilanswer
 

[fixed][/fixed]Re, salutations.
 
J'ai écrit la distance de Manhattan

Code :
  1. function Manhattan (Usr : in Taquin_8x8) return Float is
  2.      Distance : Float := 0.0;
  3.      count : float := 0.0;
  4.      Nb_Col : Integer := 0;
  5.      Nb_Line : Integer := 0;
  6.      
  7.   begin
  8.      for Line in Usr.Matrix'Range(1) loop
  9.           for Col in  Usr.Matrix'Range(2) loop
  10.              if Usr.Matrix(Line, Col).Num /= 0 then
  11.              Nb_Col := ((Usr.Matrix(Line, Col).Num - 1) mod Usr.Matrix'Last(2)) + 1;
  12.              Nb_Line := (Usr.Matrix(Line, Col).Num - 1) / Usr.Matrix'Last(2) + 1;
  13.              if Nb_Col < Col then          
  14.             count := Count + float(Col - Nb_col);
  15.              else
  16.             count := Count + float(Nb_Col - col);
  17.              end if;
  18.              if Nb_Line < Line then          
  19.             count := Count + float(Line - Nb_Line);
  20.              else
  21.             count := Count + float(Nb_Line - Line);
  22.              end if;    
  23.            --Put_Line("Num : " & Integer'Image(Usr.Matrix(Line, Col).Num) & "Nb_Line : " & Integer'Image(Nb_Line) &
  24. --              "Nb_Col : " & Integer'Image (Nb_Col) & "count : " & Float'Image(Count));
  25.         end if;
  26.      end loop;
  27.      end loop;
  28.      return count;
  29.   end Manhattan;


 
J'ai révisé tous les calculs :
 

Code :
  1. else
  2.                print(E);
  3.                Adjust(Node, E);
  4.               
  5.                  Node.Ucost :=  Best_Node.ucost  + Uniform(Node.E);
  6.                Text_Io.Put_Line("Ucost : " & float'Image(Node.ucost));
  7.  
  8.                Node.Hcost := Heuristic(Node.E);
  9.                Text_Io.Put_Line("Hcost : " & float'Image(Node.Hcost));
  10.               
  11.                F := (Best_Node.Hcost - Best_Node.ucost) + Heuristic(Node.E);
  12.               
  13.                  Text_Io.Put_Line("F : " & Float'Image(F));
  14.               
  15.                Text_Io.Put_Line(Float'Image(Node.Hcost) & " > " & Float'Image(F));
  16.  
  17.                if Node.Hcost - Best_Node.Ucost > F then
  18.                   Node_Lists.Append(closed, node);
  19.  
  20.                   
  21.                   --Node.Ucost := F;
  22.                   --Node.Hcost := F + Heuristic(Node.E);


 
Je suis encore coinçé par l'apparence du résultat pour laquelle je ne trouve pas de solution.

Init...
 1 2 3
 4 5 6
 7 8 0
Random...
Step :  8
 1 2 3
 4 0 5
 7 8 6
Init...
Astar...
initialized !
Best_Node :
 1 2 3
 4 0 5
 7 8 6
Ucost :  0.00000E+00
Hcost :  0.00000E+00
Distance :  2.00000E+00
 1 0 3
 4 2 5
 7 8 6
Ucost :  1.00000E+00
Hcost :  3.00000E+00
F :  3.00000E+00
 3.00000E+00 >  3.00000E+00
 1 2 3
 0 4 5
 7 8 6
Ucost :  1.00000E+00
Hcost :  3.00000E+00
F :  3.00000E+00
 3.00000E+00 >  3.00000E+00
 1 2 3
 4 8 5
 7 0 6
Ucost :  1.00000E+00
Hcost :  3.00000E+00
F :  3.00000E+00
 3.00000E+00 >  3.00000E+00
 1 2 3
 4 5 0
 7 8 6
Ucost :  1.00000E+00
Hcost :  1.00000E+00
F :  1.00000E+00
 1.00000E+00 >  1.00000E+00
List...
Press enter...
 
Astar task halted.


 
Ici, aucun élément n'a été ajouté dans la liste résultante.


---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546597
lady ada
Posté le 17-11-2026 à 16:00:25  profilanswer
 

Mon problème semble résolut.
J'ai ajouté le distance du jeton 0 à la fonction uniform et remplacé Node.E par Best_Node.E dans l'affectation de F.
 
J'utilise deux fonction de trie conformément à la nécessité d'utiliser une file à proiorité pour la liste open ici réalisé grace à deux tri inverse sur deux critère distinct.
 
 
 
La fonction Astar résultante est la suivante :

Code :
  1. procedure Astar (open : in Element_List;
  2.                close  : in out Element_List) is
  3.     
  4.      Openned : Node_List;    
  5.      Closed : Node_List;
  6.     
  7.      Openned_Curs : Node_Lists.Cursor;
  8.      Close_Curs : Element_Lists.Cursor;
  9.     
  10.      Done : Boolean := False;
  11.     
  12.      Initial_Node : Node_Record;
  13.      Goal : Element;
  14.      Node : Node_Record;
  15.      Exhausted : boolean := false;
  16.  
  17.      begin
  18.     
  19.      Goal := Element_Lists.Last_Element(close);
  20.  
  21.      Close_Curs := Element_Lists.First(close);
  22.      Adjust(Initial_Node, Element_Lists.First_Element(open));    
  23.      Node_Lists.Append(Openned, Initial_Node);
  24.      Element_Lists.Delete_First(Close);          
  25.      Text_Io.Put_Line("initialized !" );
  26.     
  27.     Astar_Loop :
  28.     
  29.      while not Is_Empty(Openned) loop
  30.         
  31.         U_Sorting.Sort(Openned);
  32.         H_Sorting.Sort(Openned);
  33.         declare
  34.            Openned_Find_Curs : Node_Lists.Cursor :=
  35.          Node_Lists.First(Openned);
  36.            Best_Node : Node_Record;
  37.            F : Float := 0.0;
  38.         begin
  39.            Best_Node := Node_Lists.Element(Openned_Find_Curs);
  40.           
  41.            Node_Lists.Delete_First(Openned);          
  42.           
  43.            declare
  44.  
  45.           Best_Successors : El_Array := Successors(Best_Node.E);
  46.           
  47.            begin
  48.           
  49.           for Succ in Best_Successors ' range loop
  50.              declare
  51.             E : Element := Best_Successors(Succ);
  52.              begin
  53.  
  54.             if Equal(E, Goal) then
  55.  
  56.                Adjust(Node, E);              
  57.                Node_Lists.Append(Closed, Node);
  58.                Text_Io.Put_Line("Goal !" );
  59.                exit Astar_Loop;                      
  60.             else
  61.  
  62.                Adjust(Node, E);
  63.               
  64.                  F := Best_Node.hcost + Heuristic(Node.E) + Uniform(Node.E);
  65.  
  66.                if heuristic(Best_Node.E) + Uniform(Best_Node.E) > F then
  67.                       
  68.                   Node_Lists.Append(closed, node);
  69.                   if not Node_Lists.Is_Empty(openned) then
  70.  
  71.                  declare
  72.                     Open_Curs : Node_Lists.Cursor := Node_Lists.First(Openned);
  73.                  begin
  74.                     
  75.                     declare
  76.                        Open_Node : Node_Record := Node_Lists.Element(Open_Curs);
  77.                     begin
  78.                        if Equal(Open_Node.E, Node.E) then
  79.                       Done := True;
  80.                        end if;
  81.                     end;
  82.                     
  83.                     if not Done then
  84.                        for Open in 1..Node_Lists.Length(openned) - 1 loop
  85.                       Open_Curs := Node_Lists.Next(Open_Curs);
  86.                       
  87.                       declare
  88.                          Open_Node : Node_Record := Node_Lists.Element(Open_Curs);
  89.                       begin
  90.                         
  91.                          if Equal(Open_Node.E, Node.E) then
  92.                         
  93.                         Done := True;
  94.                          end if;
  95.                         
  96.                       end;
  97.                       exit when Open = Node_Lists.Length(Openned);
  98.                        end loop;
  99.                     end if;
  100.                  end;
  101.                   end if;
  102.                   if not Done then
  103.                  Node_Lists.Append(Openned, Node);
  104.                   end if;
  105.                   Done := False;
  106.                end if;
  107.                  end if;
  108.              end;
  109.           end loop;
  110.            end;
  111.         end;
  112.      end loop Astar_Loop;
  113.      Openned_Finalization(close, closed);
  114.      end Astar;


Le projet complet avec Ada est sur sourceforge : Ada_Taquin. version 1.12.0r en archive zip.
 
Exemple :


Init...
 1 2 3
 4 5 6
 7 8 0
Random...
Step :  6
 1 2 3
 4 5 6
 0 7 8
Init...
Astar...
initialized !
Goal !
Count :  2
List...
Press enter...
 2
 1 2 3
 4 5 6
 7 0 8
 1 2 3
 4 5 6
 7 8 0
 


 
Merci dow33t !


Message édité par lady ada le 17-11-2026 à 16:00:51

---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546598
lady ada
Posté le 17-11-2026 à 16:11:41  profilanswer
 

Apparemment j'ai des problèmes de cognition liés à la gestion de la mémoire.
 
Néanmoins le projet semble être efficace.
 
Autre exemple :
 


Init...
 1 2 3
 4 5 6
 7 8 0
Random...
Step :  6
 0 1 2
 4 5 3
 7 8 6
Init...
Astar...
initialized !
Goal !
Count :  4
List...
Press enter...
 4
 1 0 2
 4 5 3
 7 8 6
 1 2 0
 4 5 3
 7 8 6
 1 2 3
 4 5 0
 7 8 6
 1 2 3
 4 5 6
 7 8 0
 
Astar task halted.
 


---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546599
lady ada
Posté le 18-11-2026 à 07:29:10  profilanswer
 

Je ne sais pas si Astar est une solution considérée comme une solution simplement efficace ou efficiente. Cependant, je constate une faille à l'éxécution de mon implémentation.
 
Environ 10% des matrice générées ne trouve pas de solution avec Astar.


---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546600
lady ada
Posté le 18-11-2026 à 07:59:09  profilanswer
 

J'ai tenté de mesuré le taux d'échec exact.
 
une fois sur cinq, c'est cent pourcent d'echec. Cent pourcent de succés si non.  :D


---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546601
dow33t
Posté le 18-11-2026 à 10:27:01  profilanswer
 

re,
 
pour ton échec une fois sur cinq : si ton mélange part de la grille rangée et ne fait que des coups permis, chaque grille a une solution (il suffit de rejouer les coups à l'envers). et sur un graphe fini, a* trouve toujours une solution quand il en existe une. ces échecs viennent donc du code, pas des grilles.
 
la piste que je vois dans ton astar : un successeur n'entre dans la liste ouverte que si heuristic(Best_Node.E) + Uniform(Best_Node.E) > F. a* n'a pas ce filtre : un état jamais vu entre toujours dans la liste ouverte, le seul test sert à garder le chemin le moins cher vers un état déjà vu. avec ce filtre, la liste ouverte peut se vider avant le but, et ta boucle while not Is_Empty(Openned) s'arrête sans solution.


---------------
Dev indé — ShapeMorph, mon jeu de formes sur mobile et prixometre.fr, mon comparateur de prix, qui vit des liens marchands
n°2546602
lady ada
Posté le 18-11-2026 à 11:39:00  profilanswer
 

J'étais encore sur le sujet à l'instant.
De manière surprenante, l'implémentation que tu évoques obtiens alternativement 100% de succés ou 100% d'échec, sur une machine alors que sur une autre, c'est 98 environ d'échecs systématique. La vérité semble subtilement caché dernière ce dont je peux avoir connaissance.
 
J'ai entre temps révisé la source et j'obtiens systématiquement 100% de succé sur une machine.
 
Voici la correction...


Message édité par lady ada le 18-11-2026 à 11:49:20

---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546603
lady ada
Posté le 18-11-2026 à 11:40:51  profilanswer
 

Code :
  1. procedure Astar (open : in Element_List;
  2.                close  : in out Element_List) is
  3.     
  4.      Openned : Node_List;    
  5.      Closed : Node_List;
  6.     
  7.      Openned_Curs : Node_Lists.Cursor;
  8.      Close_Curs : Element_Lists.Cursor;
  9.     
  10.      Done : Boolean := False;
  11.     
  12.      Initial_Node : Node_Record;
  13.      Goal : Element;
  14.      Node : Node_Record;
  15.      Exhausted : boolean := false;
  16.  
  17.      begin
  18.     
  19.      Goal := Element_Lists.Last_Element(close);
  20.  
  21.      Close_Curs := Element_Lists.First(close);
  22.      Adjust(Initial_Node, Element_Lists.First_Element(open));    
  23.      Node_Lists.Append(Openned, Initial_Node);
  24.      Element_Lists.Delete_First(Close);          
  25.      Text_Io.Put_Line("initialized !" );
  26.     
  27.     Astar_Loop :
  28.     
  29.      while not Is_Empty(Openned) loop
  30.         
  31.         U_Sorting.Sort(Openned);
  32.         H_Sorting.Sort(Openned);
  33.         declare
  34.            Openned_Find_Curs : Node_Lists.Cursor :=
  35.          Node_Lists.First(Openned);
  36.            Best_Node : Node_Record;
  37.            F : Float := 0.0;
  38.         begin
  39.            Best_Node := Node_Lists.Element(Openned_Find_Curs);
  40.           
  41.            Node_Lists.Delete_First(Openned);          
  42.           
  43.            declare
  44.  
  45.           Best_Successors : El_Array := Successors(Best_Node.E);
  46.           
  47.            begin
  48.           
  49.           for Succ in Best_Successors ' range loop
  50.              declare
  51.             E : Element := Best_Successors(Succ);
  52.              begin
  53.  
  54.             if Equal(E, Goal) then
  55.  
  56.                Adjust(Node, E);              
  57.                Node_Lists.Append(Closed, Node);
  58.               
  59.                exit Astar_Loop;                      
  60.             else
  61.  
  62.                Adjust(Node, E);
  63.               
  64.                Node.Ucost := Best_Node.Ucost + Uniform(Node.E);
  65.                Node.Hcost := Heuristic(Node.E);
  66.               
  67.               
  68.                F := Heuristic(Node.E) - Uniform(Node.E);
  69.  
  70.                if heuristic(Best_Node.E) - Uniform(Best_Node.E) > F then
  71.               
  72.                   
  73.                   Node_Lists.Append(closed, node);
  74.                   if not Node_Lists.Is_Empty(openned) then
  75.  
  76.                  declare
  77.                     Open_Curs : Node_Lists.Cursor := Node_Lists.First(Openned);
  78.                  begin
  79.                     
  80.                     declare
  81.                        Open_Node : Node_Record := Node_Lists.Element(Open_Curs);
  82.                     begin
  83.                        if Equal(Open_Node.E, Node.E) then
  84.                       Done := True;
  85.                        end if;
  86.                     end;
  87.                     
  88.                     if not Done then
  89.                        for Open in 1..Node_Lists.Length(openned) - 1 loop
  90.                       Open_Curs := Node_Lists.Next(Open_Curs);
  91.                       
  92.                       declare
  93.                          Open_Node : Node_Record := Node_Lists.Element(Open_Curs);
  94.                       begin
  95.                         
  96.                          if Equal(Open_Node.E, Node.E) then
  97.                         
  98.                         Done := True;
  99.                          end if;
  100.                         
  101.                       end;
  102.                       exit when Open = Node_Lists.Length(Openned);
  103.                        end loop;
  104.                     end if;
  105.                  end;
  106.                   end if;
  107.                   if not Done then
  108.                  Node_Lists.Append(Openned, Node);
  109.                   end if;
  110.                   Done := False;
  111.      
  112.                end if;
  113.             end if;
  114.              end;
  115.           end loop;
  116.            end;
  117.         end;
  118.      end loop Astar_Loop;
  119.      Openned_Finalization(close, closed);
  120.      end Astar;


---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546604
lady ada
Posté le 18-11-2026 à 11:47:42  profilanswer
 

Maleheurement, sur une autre machine, le problème reste présent, soit alternativement 100% de succés ou 100% d'échec.
De plus cette implémentation retourne une liste dont le nombre d'éléments peut être démesuré au regard du nombre de mouvement éffectués pour le mélange.


---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546605
lady ada
Posté le 18-11-2026 à 14:25:00  profilanswer
 

Je suis currieux d'avoir la répartie ad'hoc !
 
S'il vous plait ! [:dawa_neowen]


---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546606
lady ada
Posté le 18-11-2026 à 14:51:03  profilanswer
 

Après investigation et surtout réinstallation de mon système. Je constate 1000 pourmile de succés. Cependant, le chemin retourné est sensiblement différent du chemin parcouru par le mélange.
En effet, pour des mélange de 20 permutation maximum ; J'obtiens des chemin de plus de 100 permutations.
 
La dernière source posté ici est celle évoqué ici. Le rojet complet est sur sourceforge.net : Ada_Taquin version 1.12.1r.
 
Merci encore Dow33t !


---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546607
lady ada
Posté le 18-11-2026 à 19:34:23  profilanswer
 

Finalement ne devrait pas se trouver dans le dictionnaire.
 
Néanmoins, ma boucle de test soulevait potentiellement une incohérence relative à l'initialisation et j'ai déplacé la partie déclarative dans la boucle de manière a appliquer Astar sur une nouvelle donnée à chaque itération.
Il s'avère qu'éffectivement, seule 90% environ des appel a Astar aboutissait à un succés et environ 5% à un echec.
 
 
J'ai donc repris la source en main et voici celle attendu avec 100% de succés.
 

Code :
  1. procedure Astar (open : in Element_List;
  2.                close  : in out Element_List) is
  3.     
  4.      Openned : Node_List;    
  5.      Closed : Node_List;
  6.     
  7.      Openned_Curs : Node_Lists.Cursor;
  8.      Close_Curs : Element_Lists.Cursor;
  9.     
  10.      Done : Boolean := False;
  11.     
  12.      Initial_Node : Node_Record;
  13.      Goal : Element;
  14.      Node : Node_Record;
  15.      Exhausted : boolean := false;
  16.  
  17.      begin
  18.     
  19.      Goal := Element_Lists.Last_Element(close);
  20.  
  21.      Close_Curs := Element_Lists.First(close);
  22.      Adjust(Initial_Node, Element_Lists.First_Element(open));    
  23.      Node_Lists.Append(Openned, Initial_Node);
  24.      Element_Lists.Delete_First(Close);          
  25.      Text_Io.Put_Line("initialized !" );
  26.     
  27.     Astar_Loop :
  28.     
  29.      while not Is_Empty(Openned) loop
  30.         
  31.         U_Sorting.Sort(Openned);
  32.         H_Sorting.Sort(Openned);
  33.         declare
  34.            Openned_Find_Curs : Node_Lists.Cursor :=
  35.          Node_Lists.First(Openned);
  36.            Best_Node : Node_Record;
  37.            F : Float := 0.0;
  38.         begin
  39.            Best_Node := Node_Lists.Element(Openned_Find_Curs);
  40.           
  41.            Node_Lists.Delete_First(Openned);          
  42.           
  43.            declare
  44.  
  45.           Best_Successors : El_Array := Successors(Best_Node.E);
  46.           
  47.            begin
  48.           
  49.           for Succ in Best_Successors ' range loop
  50.              declare
  51.             E : Element := Best_Successors(Succ);
  52.              begin
  53.  
  54.             if Equal(E, Goal) then
  55.  
  56.                Adjust(Node, E);              
  57.                Node_Lists.Append(Closed, Node);
  58.               
  59.                exit Astar_Loop;                      
  60.             else
  61.  
  62.                Adjust(Node, E);
  63.               
  64.                Node.Ucost := Best_Node.Ucost + Uniform(Node.E);
  65.  
  66.                Node.Hcost := Best_Node.Hcost + Heuristic(Node.E);
  67.               
  68.                F := Heuristic(Node.E) + Uniform(Node.E) + (Heuristic(Node.E) + Uniform(Node.E)) - (heuristic(Best_Node.E) + Uniform(Best_Node.E));
  69.               
  70.               
  71.               
  72.               
  73.                if Node.Hcost + Node.Ucost > F then
  74.                   
  75.                   
  76.                   Node_Lists.Append(closed, node);
  77.                   if not Node_Lists.Is_Empty(openned) then
  78.  
  79.                  declare
  80.                     Open_Curs : Node_Lists.Cursor := Node_Lists.First(Openned);
  81.                  begin
  82.                     
  83.                     declare
  84.                        Open_Node : Node_Record := Node_Lists.Element(Open_Curs);
  85.                     begin
  86.                        if Equal(Open_Node.E, Node.E) then
  87.                       Done := True;
  88.                        end if;
  89.                     end;
  90.                     
  91.                     if not Done then
  92.                        for Open in 1..Node_Lists.Length(openned) - 1 loop
  93.                       Open_Curs := Node_Lists.Next(Open_Curs);
  94.                       
  95.                       declare
  96.                          Open_Node : Node_Record := Node_Lists.Element(Open_Curs);
  97.                       begin
  98.                         
  99.                          if Equal(Open_Node.E, Node.E) then
  100.                         
  101.                         Done := True;
  102.                          end if;
  103.                         
  104.                       end;
  105.                       exit when Open = Node_Lists.Length(Openned);
  106.                        end loop;
  107.                     end if;
  108.                  end;
  109.                   end if;
  110.                   if not Done then
  111.                  Node_Lists.Append(Openned, Node);
  112.                   end if;
  113.                   Done := False;
  114.      
  115.                end if;
  116.             end if;
  117.              end;
  118.           end loop;
  119.            end;
  120.         end;
  121.      end loop Astar_Loop;
  122.      Openned_Finalization(close, closed);
  123.      end Astar;


---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546608
lady ada
Posté le 19-11-2026 à 09:02:20  profilanswer
 

Bonjour !
 
Les résultats sont répartis en quatre catégories.
 
Les jeux nules, les jeux insolubes, les jeux dont la solution n'est pas conforme et les succé ; Ici, respectivement, null, empty, fail et succ
 

Empty :  3 ; Null :  4 ; Fail :  5 ; Succ :  88


 
Un jeu insolube noté ici empty peut être celui - ci :
 

Init...
 1 2 3
 4 5 6
 7 8 0
Random...
Step :  16
 2 5 3
 1 7 6
 4 8 0
Init...
Astar...
initialized !
List...
Press enter...
Empty :  1 ; Null :  0 ; Fail :  0 ; Succ :  12


Message édité par lady ada le 19-11-2026 à 09:03:23

---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546609
lady ada
Posté le 19-11-2026 à 09:40:41  profilanswer
 

Sensiblement ; Il manque la notion d'infini quelque pare dans ma source.


---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546610
lady ada
Posté le 19-11-2026 à 09:51:09  profilanswer
 

Négatif ; Négatif ; Eureka !  :bounce:  
 
L'opérateur de conparaison...  
 
 
Oh Calisse !
 
replace "<" by "<=".
 

Empty :  0 ; Null :  4 ; Fail :  0 ; Succ :  96


 
 
[:dawa_neowen]


---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546611
lady ada
Posté le 15-11-2026 à 20:31:12  profilanswer
 

Bonjour !
 
Je cherche depuis trois jours à établir le chemin pour un jeu du taquin avec Astar.
 
Mon implémentation trouve la solution. Cependant la liste ne retourne pas le chemin attendu.
 
Le résultat fourni en fin de message correspond à une parti de l'éxecution de ce bout de programme et il ne me semble pas conforme à ce qui est écrit.
En efftet, les états intermédiare du chemin du jeu ne son pas affiché comme attendu.
 

Code :
  1. procedure Astar (open : in Element_List;
  2.                close  : in out Element_List) is
  3.     
  4.     
  5.     
  6.      Openned : Node_List;    
  7.      Closed : Node_List;
  8.     
  9.      Openned_Curs : Node_Lists.Cursor;
  10.      Close_Curs : Element_Lists.Cursor;
  11.     
  12.      Done : Boolean := False;
  13.     
  14.      Initial_Node : Node_Record;
  15.      Goal : Element;
  16.      Node : Node_Record;
  17.  
  18.  
  19.      Exhausted : boolean := false;
  20.  
  21.      begin
  22.      Goal := Element_Lists.Last_Element(close);
  23.      Close_Curs := Element_Lists.First(close);
  24.      Adjust(Initial_Node, Element_Lists.First_Element(open));    
  25.      Node_Lists.Append(Openned, Initial_Node);
  26.      Element_Lists.Delete_First(Close);          
  27.      Text_Io.Put_Line("initialized !" );
  28.     
  29.     Astar_Loop :
  30.     
  31.      while not Is_Empty(Openned) loop
  32.         
  33.         U_Sorting.Sort(Openned);
  34.         H_Sorting.Sort(Openned);
  35.         declare
  36.            Openned_Find_Curs : Node_Lists.Cursor :=
  37.          Node_Lists.First(Openned);
  38.            Best_Node : Node_Record;
  39.            F : Float := 0.0;
  40.         begin
  41.            Best_Node := Node_Lists.Element(Openned_Find_Curs);
  42.            Node_Lists.Delete_First(Openned);          
  43.           
  44.            declare
  45.           Best_Successors : El_Array := Successors(Best_Node.E);
  46.           
  47.            begin
  48.           
  49.           for Succ in Best_Successors ' range loop
  50.              declare
  51.             E : Element := Best_Successors(Succ);
  52.              begin
  53.  
  54.             
  55.             if Equal(E, Goal) then
  56.             print(E);
  57.                Adjust(Node, E);              
  58.                Node.Ucost :=  Best_Node.ucost  + (Uniform(Node.E));
  59.                  Node.Hcost := (Heuristic(Node.E) + Best_Node.Hcost) + best_node.ucost;
  60.                     F := (best_node.ucost + heuristic(Node.E)) ;
  61.                  Text_Io.Put_Line("Ucost : " & float'Image(Node.ucost));
  62.                  Text_Io.Put_Line("Hcost : " & float'Image(Node.Hcost));
  63.                     Text_Io.Put_Line("F : " & Float'Image(F));
  64.                Node_Lists.Append(Closed, Node);
  65.                Text_Io.Put_Line("Goal !" );
  66.                exit Astar_Loop;                      
  67.             else
  68.                print(E);
  69.                Adjust(Node, E);
  70.  
  71.  
  72.                Node.Ucost :=  Best_Node.ucost  + (Uniform(Node.E));
  73.                Text_Io.Put_Line("Ucost : " & float'Image(Node.ucost));
  74.  
  75.                Node.Hcost := (Heuristic(Node.E) + Best_Node.Hcost) + best_node.ucost;
  76.                Text_Io.Put_Line("Hcost : " & float'Image(Node.Hcost));
  77.               
  78.  
  79.                F := (best_node.ucost + node.hcost + heuristic(Node.E)) ;
  80.                  Text_Io.Put_Line("F : " & Float'Image(F));
  81.  
  82.                if Node.Ucost + heuristic(node.E) < F then
  83.  
  84.                    Node_Lists.Append(closed, node);
  85.  
  86.                if not Node_Lists.Is_Empty(openned) then
  87.  
  88.                  declare
  89.                     Open_Curs : Node_Lists.Cursor := Node_Lists.First(Openned);
  90.                  begin
  91.                     
  92.                     declare
  93.                        Open_Node : Node_Record := Node_Lists.Element(Open_Curs);
  94.                     begin
  95.                       
  96.                        if Equal(Open_Node.E, Node.E) then
  97.                       
  98.                       Done := True;
  99.                        end if;
  100.                       
  101.                     end;
  102.                     
  103.                     if not Done then
  104.                        for Open in 1..Node_Lists.Length(openned) - 1 loop
  105.                       Open_Curs := Node_Lists.Next(Open_Curs);
  106.                       
  107.                       declare
  108.                          Open_Node : Node_Record := Node_Lists.Element(Open_Curs);
  109.                       begin
  110.                         
  111.                          if Equal(Open_Node.E, Node.E) then
  112.                         
  113.                         Done := True;
  114.                          end if;
  115.                         
  116.                       end;
  117.                       exit when Open = Node_Lists.Length(Openned);
  118.                       
  119.                       
  120.                        end loop;
  121.                     end if;
  122.                     
  123.                     
  124.                  end;
  125.  
  126.                   end if;
  127.                   if not Done then
  128.                  Node_Lists.Append(Openned, Node);
  129.  
  130.                 
  131.                   end if;
  132.  
  133.                   Done := False;
  134.  
  135.                end if;
  136.                  end if;
  137.  
  138.              end;
  139.           end loop;
  140.           
  141.            end;
  142.         end;
  143.         
  144.         
  145.      end loop Astar_Loop;
  146.     
  147.      Openned_Finalization(close, closed);
  148.  
  149.     
  150.      end Astar;


 

Init...
 1 2 3
 4 5 6
 7 8 0
Random...
Step :  6
 1 2 3
 4 5 6
 0 7 8
Init...
Astar...
initialized !
 1 2 3
 0 5 6
 4 7 8
Ucost : -1.00000E+00
Hcost :  1.00000E+00
F :  2.00000E+00
 1 2 3
 4 5 6
 7 0 8
Ucost : -1.00000E+00
Hcost :  1.00000E+00
F :  2.00000E+00
 1 2 3
 4 0 6
 7 5 8
Ucost : -2.00000E+00
Hcost :  1.00000E+00
F :  1.00000E+00
 1 2 3
 4 5 6
 0 7 8
Ucost : -2.00000E+00
Hcost :  1.00000E+00
F :  1.00000E+00
 1 2 3
 4 5 6
 7 8 0
Ucost : -2.00000E+00
Hcost :  1.00000E+00
F :  0.00000E+00
Goal !
Count :  5
List...
Press enter...
 5
 1 2 3
 0 5 6
 4 7 8
 1 2 3
 4 5 6
 7 0 8
 1 2 3
 4 0 6
 7 5 8
 1 2 3
 4 5 6
 0 7 8
 1 2 3
 4 5 6
 7 8 0
 
Astar task halted.


 
Merci pour votre aide.


---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546612
lady ada
Posté le 15-11-2026 à 20:47:19  profilanswer
 

J'ai trouvé une erreur déjà.
Le problème reste entier avec l'exemple suivant.
L'implémentation ci - dessus est inchangée.
 


Init...
 1 2 3
 4 5 6
 7 8 0
Random...
Step :  6
 1 2 0
 4 5 3
 7 8 6
Init...
Astar...
initialized !
 1 0 2
 4 5 3
 7 8 6
Ucost : -1.00000E+00
Hcost :  1.00000E+00
F :  2.00000E+00
 1 2 3
 4 5 6
 7 8 0
Ucost : -1.00000E+00
Hcost :  1.00000E+00
F :  1.00000E+00
Goal !
Count :  2
List...
Press enter...
 2
 1 0 2
 4 5 3
 7 8 6
 1 2 3
 4 5 6
 7 8 0
 
Astar task halted.
 


Message édité par lady ada le 15-11-2026 à 20:49:24

---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546613
lady ada
Posté le 16-11-2026 à 10:12:23  profilanswer
 

Afin de vous fournir l'ensemble des éléments impliqués dans le déroulement de ce programme ; Je vous communique les fonctions utilisées :
 

Code :
  1. Moves : Move_Array :=
  2.     (Right'Access, Down'Access, Left'Access, Up'Access);
  3.  
  4.  
  5.   function Successors (Usr : in Taquin_8x8) return Taquin_Array is
  6.      Successors : access Taquin_Array := new Taquin_Array (1..0);
  7.      buffer : access Taquin_Array;
  8.   begin
  9.      for Move in reverse Moves'Range loop
  10.      begin
  11.         if Moves(Move)(Usr) /= Usr then
  12.            Buffer := new Taquin_Array(1..Successors'Length+1);
  13.            Buffer(1..Successors'Length) := Successors.all;          
  14.            Buffer(Buffer'Last) := Moves(Move)(Usr);
  15.            Successors := new Taquin_array ' (Buffer.all);
  16.         end if;
  17.      exception
  18.         when No_Succ =>
  19.            null;
  20.      end;
  21.      end loop;
  22.      Return Successors.all;
  23.   end Successors;


 

Code :
  1. function Up (Usr : in Taquin_8x8) return Taquin_8x8 is
  2.      Node : Taquin_8x8 := Usr;
  3.      Token : Token_Type;
  4.      Done : Boolean := False;
  5.   begin
  6.      for Line in Node.Matrix'range(1) loop
  7.      for col in Node.Matrix'range(2) loop
  8.         if Node.Matrix(Line, Col).Num = 0 then
  9.            if Line > 1 then
  10.           Token := Node.Matrix(Line-1, Col);
  11.           Node.Matrix(Line-1, Col) := Node.Matrix(Line, Col);
  12.           Node.Matrix(Line, Col) := Token;
  13.           Done := True;
  14.           Step := Step + 1;
  15.            end if;
  16.            exit;
  17.         end if;
  18.      end loop;
  19.      end loop;
  20.      if not Done then
  21.      raise No_Succ;
  22.      end if;
  23.      return Node;
  24.   end Up;


 

Code :
  1. function Down (Usr : in Taquin_8x8) return Taquin_8x8 is
  2.      Node : Taquin_8x8 := Usr;
  3.      Token : Token_Type;
  4.      Done : Boolean := False;
  5.   begin
  6.      for Line in Node.Matrix'range(1) loop
  7.      for col in Node.Matrix'range(2) loop
  8.         if Node.Matrix(Line, Col).Num = 0 then
  9.            if Line < Node.Matrix'Last(1) then
  10.           Token := Node.Matrix(Line+1, Col);
  11.           Node.Matrix(Line+1, Col) := Node.Matrix(Line, Col);
  12.           Node.Matrix(Line, Col) := Token;
  13.           Done := True;
  14.           Step := Step + 1;
  15.            end if;
  16.            exit;
  17.         end if;
  18.      end loop;
  19.      end loop;
  20.      if not Done then
  21.      raise No_Succ;
  22.      end if;
  23.      return Node;
  24.   end Down;


 

Code :
  1. function Right (Usr : in Taquin_8x8) return Taquin_8x8  is
  2.      Node : Taquin_8x8 := Usr;
  3.      Token : Token_Type;
  4.      Done : Boolean := False;
  5.   begin
  6.      for Line in Node.Matrix'range(1) loop
  7.      for Col in Node.Matrix'range(2) loop
  8.         if Node.Matrix(Line, Col).Num = 0 then
  9.            if Col < Node.Matrix'Last(2) then
  10.           Token := Node.Matrix(Line, Col+1);
  11.           Node.Matrix(Line, Col+1) := Node.Matrix(Line, Col);
  12.           Node.Matrix(Line, Col) := Token;
  13.           Done := True;
  14.           Step := Step + 1;
  15.            end if;
  16.            exit;
  17.         end if;
  18.      end loop;
  19.      end loop;
  20.      if not Done then
  21.      raise No_Succ;
  22.      end if;
  23.      return Node;
  24.   end Right;


Code :
  1. function Left (Usr : in Taquin_8x8) return Taquin_8x8  is
  2.      Node : Taquin_8x8 := Usr;
  3.      Token : Token_Type;
  4.      Done : Boolean := False;
  5.   begin
  6.      for Line in Node.Matrix'range(1) loop
  7.      for col in Node.Matrix'range(2) loop
  8.         if Node.Matrix(Line, Col).Num = 0 then
  9.            if col > 1 then
  10.           Token := Node.Matrix(Line, Col-1);
  11.           Node.Matrix(Line, Col-1) := Node.Matrix(Line, Col);
  12.           Node.Matrix(Line, Col) := Token;
  13.           Done := True;
  14.            Step := Step + 1;
  15.            end if;
  16.             exit;
  17.         end if;
  18.      end loop;
  19.      end loop;
  20.      if not Done then
  21.      raise No_Succ;
  22.      end if;
  23.      return Node;
  24.   end Left;


 
Dans le dernier exemple communiqué ; N'apparait pas l'état suivant :
 


 1 2 3
 4 5 0
 7 8 6


Message édité par lady ada le 16-11-2026 à 10:16:03

---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546614
lady ada
Posté le 16-11-2026 à 11:01:17  profilanswer
 

Pour ce cas :
 


1 2 3
4 5 6
0 7 8


 
J'ai bien :
 


1 2 3
4 5 6
7 0 8


Message édité par lady ada le 16-11-2026 à 11:01:45

---------------
main is business suite for Ada projects. Web site : inconito.net
n°2546615
lady ada
Posté le 16-11-2026 à 11:23:40  profilanswer
 

Eureka.
 
Les fonctions de mouvement ne sont pas fonctionnelles car l'instruction "exist" permet de sortir de la boucle interrieur ; Cependant, il s'agir d'un tableau à deux dimenssion et il y a deux boucles.
 
La correction choisie est la suivante, ici pour Down, à généraliser :
 

Code :
  1. function Down (Usr : in Taquin_8x8) return Taquin_8x8 is
  2.      Node : Taquin_8x8 := Usr;
  3.      Token : Token_Type;
  4.      
  5.   begin
  6.      for Line in Node.Matrix'range(1) loop
  7.      for col in Node.Matrix'range(2) loop
  8.         if Node.Matrix(Line, Col).Num = 0 then
  9.           
  10.            if Line < Node.Matrix'Last(1) then
  11.           
  12.           Token := Node.Matrix(Line+1, Col);
  13.           
  14.           Node.Matrix(Line+1, Col) := Node.Matrix(Line, Col);
  15.           
  16.           Node.Matrix(Line, Col) := Token;
  17.           
  18.           Step := Step + 1;
  19.           return Node;
  20.            end if;
  21.           
  22.         end if;        
  23.      end loop;
  24.      end loop;
  25.  
  26.      raise No_Succ;
  27.  
  28.   end Down;


 
Merci !


---------------
main is business suite for Ada projects. Web site : inconito.net
mood
Publicité
Posté le   profilanswer
 

 Page :   1  2  3  4  5  6  7  8  9  10  11  12  13  14  15

Aller à :
Ajouter une réponse
 

Sujets relatifs
Probleme robot google ? Ma source internet ? aidez moiInterface ADA avec C
Projet de frontend Open-Source pour émulateursOpen Office: Base de données
code source pdf ?Modifier le code source de SIP-Communicator
[JS] Pb avec un page de javascripts et module open flash chart[ADA] /!\ Combien on peux boire de biere JEUDI MIDI §§§ la defense ??
Fonction window.open (javascript) 
Plus de sujets relatifs à : [Ada][Topic Unic][Open Source] Je fais péter mes codes.


Copyright © 1997-2025 Groupe LDLC (Signaler un contenu illicite / Données personnelles)