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

  FORUM HardWare.fr
  Programmation
  Ada

  [Ada][Résolut] Error Vertex_Not_In_Graph à l'ajout d'un arc.

 
 


 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

[Ada][Résolut] Error Vertex_Not_In_Graph à l'ajout d'un arc.

n°1985194
Profil sup​primé
Posté le 18-04-2010 à 08:31:53  answer
 

Bonjour, je viens poser un problème.  
J'ai fait un petit programme à vocation d'agent de dialogue dans lequel je relie les mots en eux avec un graphe.
 
J'en suis théoriquement au chaînage des phrases entre elles. Mais l'erreur Vertex_Not_In_Graph est levée dans ma procédure Add à l'ajout de l'arc de liaison ligne 66.
 
Si je tente d'ajouter les sommets concernés, je lève alors Other Error qui doit en fait cacher un Sommet non initialisé, et c'est là que rien ne va plus, car tout mes sommet sont sensé être initialisé.
 
Quelques déclarations (pour la compréhension du problème) :

Code :
  1. type T_Node;
  2.    type Node_Access is access T_Node;
  3.    type T_Network is
  4.       record
  5.          The_Graph : Graph;
  6.          Root      : Node_Access;
  7.       end record;
  8.  
  9.  type T_Node is
  10.       record
  11.          The_vertex : Vertex;
  12.          Neuron     : Neuron_Access;
  13.          Next       : Node_Access;
  14.       end record;


 
 
Voici ma procédure d'initialisation :

Code :
  1. procedure Initialize(Network : out T_Network; Input : in T_Sentence; Last_Vertex : out Vertex) is
  2.       Current_Node : Node_Access;
  3.       The_Arc : Arc;
  4.       Vertex_A, Vertex_B : Vertex;
  5.       The_Neuron : Neuron_Access;
  6.  
  7.    begin
  8.  
  9.       if Input'Length = 1 then
  10.          Vertex_A := New_Vertex;
  11.          The_Neuron := new T_Neuron(1, Input(1));
  12.          Make(The_Neuron.all);
  13.          Add(The_Neuron.all, Input(1..1));
  14.          Network.Root := new T_Node ' (Vertex_A, The_Neuron, null);
  15.          Train(Network.root.Neuron.all);
  16.          Add(Vertex_A, Network.The_Graph);
  17.          Last_Vertex := Vertex_A;
  18.       else
  19.          Vertex_B := New_Vertex;
  20.          The_Neuron := new T_Neuron(2, Input(2));
  21.          Make(The_Neuron.all);
  22.          Add(The_Neuron.all, Input(1..1));
  23.          Network.Root := new T_Node ' (Vertex_B, The_Neuron, null);
  24.          Train(Network.root.Neuron.all);
  25.          Add(Vertex_B, Network.The_Graph);
  26.  
  27.          if Input'Length > 2 then
  28.             Current_node := Network.Root;
  29.             for I in 3..Input'Length loop
  30.                Vertex_A := Current_Node.The_Vertex;
  31.                Vertex_B := New_Vertex;
  32.                The_Arc := New_Arc(Vertex_A, Vertex_B);
  33.                The_Neuron := new T_Neuron(I, Input(I));
  34.                Make(The_Neuron.all);
  35.                Add(The_Neuron.all, Input(1..I-1));
  36.                Current_Node.next := new T_Node ' (Vertex_B, The_Neuron, null);
  37.                Train(Current_Node.Next.Neuron.all);
  38.                Add(Vertex_B, Network.The_Graph);
  39.                Add(The_Arc, Network.The_Graph);
  40.                Current_Node := Current_Node.Next;
  41.             end loop;
  42.          end if;
  43.          Last_Vertex := Vertex_B;
  44.       end if;
  45.    end Initialize;


 
Voici ma procédure Add pour les ajouts suivant :
 

Code :
  1. procedure Add(Feed_Back : in Vertex; Network : in out T_Network; Input : in T_Sentence; Last_Vertex : out Vertex) is
  2.       Current_Node : Node_Access := Network.Root;
  3.       The_Arc : Arc;
  4.       Init, Vertex_A, Vertex_B : Vertex;
  5.       The_Neuron : Neuron_Access;
  6.       Done : Boolean := False;
  7.    begin
  8.  
  9.       if Input'Length = 1 then
  10.          if Current_Node.Neuron.Width = 1 and Current_Node.Neuron.Keyword = Input(1) then
  11.             Add(Current_Node.Neuron.all, Input(1..1));
  12.             Train(Current_Node.Neuron.all);
  13.             Vertex_A := Current_Node.The_Vertex;
  14.          else
  15.             while Current_Node.Next /= null loop
  16.                Current_Node := Current_Node.Next;
  17.                if Current_Node.Neuron.Width = 1 and Current_Node.Neuron.Keyword = Input(1) then
  18.  
  19.                   Add(Current_Node.Neuron.all, Input(1..1));
  20.                   Train(Current_Node.Neuron.all);
  21.                   Last_Vertex := Current_Node.The_Vertex;
  22.                   return;
  23.                end if;
  24.             end loop;
  25.             Vertex_A := New_Vertex;
  26.             The_Neuron := new T_Neuron(1, Input(1));
  27.             Make(The_Neuron.all);
  28.             Add(The_Neuron.all, Input(1..1));
  29.             Current_Node.Next := new T_Node ' (Vertex_A, The_Neuron, null);
  30.             Train(Current_Node.Next.Neuron.all);
  31.             Add(Vertex_A, Network.The_Graph);
  32.             Current_Node := Current_Node.Next;
  33.          end if;
  34.          Last_Vertex := Vertex_A;
  35.          The_Arc := New_Arc(Feed_back, Vertex_A);
  36.          Add(The_Arc, Network.The_Graph);
  37.       else
  38.  
  39.          if Current_Node.Neuron.Width = 2 and Current_Node.Neuron.Keyword = Input(2) then
  40.             Vertex_A := Current_Node.The_Vertex;
  41.             Add(Current_Node.Neuron.all, Input(1..1));
  42.             Train(Current_Node.Neuron.all);
  43.          else
  44.             while Current_Node.Next /= null loop
  45.                Current_Node := Current_Node.Next;
  46.                if Current_Node.Neuron.Width = 2 and Current_Node.Neuron.Keyword = Input(2) then
  47.                   Vertex_A := Current_Node.The_Vertex;
  48.                   Add(Current_Node.Neuron.all, Input(1..1));
  49.                   Train(Current_Node.Neuron.all);
  50.                   Done := True;
  51.                   exit;
  52.                end if;
  53.             end loop;
  54.             if not Done then
  55.                Vertex_A := New_Vertex;
  56.                The_Neuron := new T_Neuron(2, Input(2));
  57.                Make(The_Neuron.all);
  58.                Add(The_Neuron.all, Input(1..1));
  59.                Current_Node.Next := new T_Node ' (Vertex_A, The_Neuron, null);
  60.                Train(Current_Node.Next.Neuron.all);
  61.                Add(Vertex_A, Network.The_Graph);
  62.             end if;
  63.          end if;
  64.          The_Arc := New_Arc(Feed_back, Vertex_A);
  65.          begin
  66.             Add(The_Arc, Network.The_Graph);
  67.          exception
  68.             when VERTEX_NOT_IN_GRAPH =>
  69.                Text_Io.Put("VERTEX_NOT_IN_GRAPH" );
  70.                delay 1.0;
  71.             when others =>
  72.                Text_Io.Put("Other Error !!" );
  73.                delay 1.0;
  74.          end;
  75.          Last_Vertex := Vertex_A;
  76.          if Input'Length > 2 then
  77.             Current_Node := Network.Root;
  78.             if Current_Node.Neuron.Width = 3 and Current_Node.Neuron.Keyword = Input(3) then
  79.                Vertex_B := Current_Node.The_Vertex;
  80.                Add(Current_Node.Neuron.all, Input(1..2));
  81.                Train(Current_Node.Neuron.all);
  82.             else
  83.                Done := False;
  84.                while Current_Node.Next /= null loop
  85.                   Current_Node := Current_Node.Next;
  86.                   if Current_Node.Neuron.Width = 3 and Current_Node.Neuron.Keyword = Input(3) then
  87.                      Vertex_B := Current_Node.The_Vertex;
  88.                      Add(Current_Node.Neuron.all, Input(1..2));
  89.                      Train(Current_Node.Neuron.all);
  90.                      Done := True;
  91.                      exit;
  92.                   end if;
  93.                end loop;
  94.                if not Done then
  95.                   Vertex_B := New_Vertex;
  96.                   The_Neuron := new T_Neuron(3, Input(3));
  97.                   Make(The_Neuron.all);
  98.                   Add(The_Neuron.all, Input(1..2));
  99.                   Current_Node.Next := new T_Node ' (Vertex_B, The_Neuron, null);
  100.                   Train(Current_Node.Next.Neuron.all);
  101.                   Add(Vertex_B, Network.The_Graph);
  102.                end if;
  103.             end if;
  104.             The_Arc := New_Arc(Vertex_A, Vertex_B);
  105.             Add(The_Arc, Network.The_Graph);
  106.             Last_Vertex := Vertex_B;
  107.          end if;
  108.  
  109.          if Input'Length > 3 then
  110.             for I in 4..Input'Length loop
  111.                Current_Node := Network.Root;
  112.                Vertex_A := Vertex_B;
  113.                if Current_Node.Neuron.Width = I and Current_Node.Neuron.Keyword = Input(I) then
  114.                   Vertex_B := Current_Node.The_Vertex;
  115.                   Add(Current_Node.Neuron.all, Input(1..I-1));
  116.                   Train(Current_Node.Neuron.all);
  117.                else
  118.                   Done := False;
  119.                   while Current_Node.Next /= null loop
  120.                      Current_Node := Current_Node.Next;
  121.                      if Current_Node.Neuron.Width = I and Current_Node.Neuron.Keyword = Input(I) then
  122.                         Vertex_B := Current_Node.The_Vertex;
  123.                         Add(Current_Node.Neuron.all, Input(1..I-1));
  124.                         Train(Current_Node.Neuron.all);
  125.                         Done := True;
  126.                         exit;
  127.                      end if;
  128.                   end loop;
  129.                   if not Done then
  130.                      Vertex_B := New_Vertex;
  131.                      The_Neuron := new T_Neuron(I, Input(I));
  132.                      Make(The_Neuron.all);
  133.                      Add(The_Neuron.all, Input(1..I-1));
  134.                      Current_Node.Next := new T_Node ' (Vertex_B, The_Neuron, null);
  135.                      Train(Current_Node.Next.Neuron.all);
  136.                      Add(Vertex_B, Network.The_Graph);
  137.                   end if;
  138.                end if;
  139.                The_Arc := New_Arc(Vertex_A, Vertex_B);
  140.                Add(The_Arc, Network.The_Graph);
  141.                Last_Vertex := Vertex_B;
  142.             end loop;
  143.          end if;
  144.       end if;
  145.    end Add;


 
Et voici ma procédure principale dans le or delay de la tache :
 

Code :
  1. task body Life_Cycle is
  2.  
  3.       The_Network : T_Network;
  4.  
  5.       End_Of_Task : Boolean := False;
  6.  
  7.       Input  : T_Message_Box := (null, null);
  8.       Output : T_Message_Box := (new String ' (Program_Logname), null);
  9.       Available : Boolean := False;
  10.  
  11.  
  12.       Sub_Node,
  13.       Current_Node : Node_Access;
  14.  
  15.  
  16.       Result, Sub_Result : T_Sentence(1..256) := (others => 0);
  17.       Result_Last,
  18.       Sub_Result_Last : Natural := 0;
  19.  
  20.  
  21.       The_Vertex_Set : Vertex_Set;
  22.  
  23.       The_End, Last_Vertex : Vertex;
  24.  
  25.    begin
  26.       accept Start(Date : out Time) do
  27.          Date := Clock;
  28.       end Start;
  29.       while not End_Of_Task loop
  30.  
  31.          select
  32.  
  33.             accept Halt do
  34.                End_Of_Task := True;
  35.             end Halt;
  36.          or
  37.             delay 1.0;
  38.  
  39.             Message_IO.Look(Program_Logname, Available);
  40.  
  41.             if Available then
  42.                Message_Io.Send(Program_Logname, Input);
  43.  
  44.                --
  45.                --
  46.  
  47.                if The_Network.Root = null then
  48.                   Initialize(The_Network, Input.Message.all, Last_vertex);
  49.                else
  50.  
  51.                   if Result_Last /= 0 then
  52.                      Add(Last_Vertex, The_Network, Result(1..Result_Last), The_end);
  53.                   end if;
  54.                   Current_Node := The_Network.Root;
  55.                   for I in 1..Input.message'Length loop
  56.                      Result(I) := Input.message(I);
  57.                   end loop;
  58.                   Result_Last := Input.message'Length;
  59.  
  60.  
  61.                   while Current_Node /= null and then Current_Node.The_Vertex /= Last_Vertex loop
  62.  
  63.  
  64.                      if Current_Node /= null and then Current_Node.Neuron.Width >= Result_Last then
  65.                         declare
  66.                            Buffer : T_Sentence(1..Current_Node.Neuron.Width) := (others => 0);
  67.                         begin
  68.                            if Current_Node.Neuron.Reuse_Network then
  69.                               Respond(Current_Node.Neuron.all,
  70.                                       Result(1..Current_Node.Neuron.Width), buffer);
  71.                               if Sub_Result_Last /= 0 then
  72.                                  if Sub_Result(Sub_Result_Last) /= Buffer(Current_Node.Neuron.Width) then
  73.                                     Sub_Result(Sub_Result_Last + 1) := Buffer(Current_Node.Neuron.Width);
  74.                                     Sub_Result_Last := Sub_Result_Last + 1;
  75.                                  end if;
  76.                               else
  77.                                  Sub_Result(Sub_Result_Last + 1) := Buffer(Current_Node.Neuron.Width);
  78.                                  Sub_Result_Last := Sub_Result_Last + 1;
  79.                               end if;
  80.                            end if;
  81.                         end;
  82.  
  83.                         for I in Leaving(Current_Node.The_Vertex, The_Network.The_Graph) ' range loop
  84.                            Add(Other_End
  85.                                  (Leaving
  86.                                     (Current_Node.The_Vertex, The_Network.The_Graph)(I),
  87.                                   Current_Node.The_Vertex), The_Vertex_Set);
  88.                            Text_Io.Put_Line("Add member in Vertex set" );
  89.                         end loop;
  90.  
  91.                         Sub_Node := Current_Node.Next;
  92.  
  93.                         while Sub_Node /= null and then Sub_Node.The_Vertex /= Last_Vertex loop
  94.                            if Member(Sub_Node.The_Vertex, The_Vertex_Set) then
  95.                               for I in Leaving(Sub_Node.The_Vertex, The_Network.The_Graph) ' range loop
  96.                                  Add(Other_End
  97.                                        (Leaving
  98.                                           (Sub_Node.The_Vertex, The_Network.The_Graph)(I),
  99.                                         Sub_Node.The_Vertex), The_Vertex_Set);
  100.                                  Text_Io.Put_Line("Add member in Vertex set" );
  101.  
  102.                               end loop;
  103.                               if Sub_Node.Neuron.Width >= Result_Last  then
  104.                                  declare
  105.                                     Buffer : T_Sentence(1..Sub_Node.Neuron.Width) := (others => 0);
  106.                                  begin
  107.                                     if Sub_Node.Neuron.Reuse_Network then
  108.                                        Respond(Sub_Node.Neuron.all,
  109.                                                Result(1..Sub_Node.Neuron.Width), buffer);
  110.                                        if Sub_Result_Last /= 0 then
  111.                                           if Sub_Result(Sub_Result_Last) /= Buffer(Sub_Node.Neuron.Width) then
  112.                                              Sub_Result(Sub_Result_Last + 1) := Buffer(Sub_Node.Neuron.Width);
  113.                                              Sub_Result_Last := Sub_Result_Last + 1;
  114.                                           end if;
  115.                                        else
  116.                                           Sub_Result(Sub_Result_Last + 1) := Buffer(Sub_Node.Neuron.Width);
  117.                                           Sub_Result_Last := Sub_Result_Last + 1;
  118.                                        end if;
  119.                                        Text_Io.Put_Line("Add member from Vertex set" );
  120.                                     end if;
  121.                                  end;
  122.                               end if;
  123.  
  124.                            end if;
  125.  
  126.                            Sub_Node := Sub_Node.Next;
  127.                         end loop;
  128.                         Empty(The_Vertex_Set);
  129.                         exit;
  130.                      end if;
  131.  
  132.                      Current_Node := Current_Node.Next;
  133.                   end loop;
  134.  
  135.                   Result(1..Sub_Result_Last) := Sub_Result(1..Sub_Result_Last);
  136.                   Result_Last := Sub_Result_Last;
  137.                   Sub_Result := (others => 0);
  138.                   Sub_Result_Last := 0;
  139.  
  140.                   Add(The_end, The_Network, Input.Message.all, Last_vertex);
  141.  
  142.  
  143.                   if Result_Last /= 0 then
  144.                      Output.message := new T_Sentence ' ( Result(1..Result_Last) );
  145.                   else
  146.                      Output.Message := null;
  147.  
  148.                   end if;
  149.  
  150.                   Result := (others => 0);
  151.  
  152.                end if;
  153.  
  154.                --
  155.                --
  156.  
  157.                Output.Logname := new String ' (Program_Logname);
  158.                Message_IO.Receive(Input.Logname.all, Output);
  159.  
  160.  
  161.  
  162.  
  163.  
  164.             else
  165.  
  166.                null;
  167.  
  168.  
  169.             end if;
  170.          end select;
  171.       end loop;
  172.    end Life_Cycle;


 
Même si je n'ai pas tout bien fait, le chainage devrais fonctionner, mais non, et je planche depuis un moment.
 
Merci pour votre aide.


Message édité par Profil supprimé le 18-04-2010 à 12:27:05
mood
Publicité
Posté le 18-04-2010 à 08:31:53  profilanswer
 

n°1985209
Profil sup​primé
Posté le 18-04-2010 à 11:05:29  answer
 

Hello,
 
Apparemment, il y aurait un problème avec l'opérateur d'affectation des vertex.

n°1985216
Profil sup​primé
Posté le 18-04-2010 à 12:26:37  answer
 

Bien, j'ai trouvé une grossière erreur... entre les utilisations de The_End et Last_Vertex alors de Relsult_last vaut encore 0 au second appel j'étais pas sortie de l'auberge.
J'ai regardé ce qu'est un vertex, un key, a priori il ne doit y avoir de problème à la copy.
Je me suis un peu embrouillé sur le coup et la fatigue, désolé.


Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  Ada

  [Ada][Résolut] Error Vertex_Not_In_Graph à l'ajout d'un arc.

 

Sujets relatifs
[GMF] Ajout d'entrée dans le menu contextuelliste incremental string [RESOLU]
je cherche une implémentation des graphes avec Ada.[Résolu] jquery , 2 div draggable l'un dans l'autre
Ajout d'une valeur dans un tableau dans un tableau[Ada/Modélisation] Modélisation d'un cerveau bicéphale.
decomposer une chaine de caractère[resolut]Exécuter une commande externe avec Ada
[resolut]ma page ne fonctionne plus sous un include??Error Parse PHP ... :-( Wikimedia
Plus de sujets relatifs à : [Ada][Résolut] Error Vertex_Not_In_Graph à l'ajout d'un arc.

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo
Page générée en 0.139 secondes

Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR