loop
         accept Compute(Data : in T_Lang_Array;
                        Response : out T_Lang_Array) do
            Table2register(Data, Input);
 
            for I in Section..T_Layer_Id'Last loop
               select
                  Brain(I).Respond(Input, Output);
                  Input := Output;
               or
                  delay 1.0;
                  exit;
               end select;
            end loop;
            if Section > 1 then
               Section := Section - 1;
            else
               Section := T_Layer_Id'Last;
               end if;
               Register2table(Output, Response);
         end Compute;
      end loop;

with Glossary, Generic_Extended_Binary_Code;
 
with Ada.Calendar, Ada.Command_Line;
use Ada.Calendar, Ada.Command_Line;
 
with Ada.Text_Io, Interfaces.C;
use Ada, Interfaces;
 
with PragmARC.Ansi_Tty_Control;
use PragmARC.Ansi_Tty_Control;
 
with PragmARC.REM_NN_Wrapper;
use PragmARC.REM_NN_Wrapper;
 
with PragmARC.Math.Functions;
 
procedure Main is
 
 
   function System(Command : C.Char_Array) return C.Int;
   pragma Import(C, System, "system" );
 
   package The_Glossary is new Glossary(125660);
   use The_Glossary;
 
   package Coded_Word is new Generic_Extended_Binary_Code(T_Language);
   use Coded_Word;
 
   Sentence_Length : constant Positive := 20;
 
   task Life_Cycle is
      entry Receive(Char : in Character);
   end Life_Cycle;
 
 
 
   subtype T_Layer_Id is Natural range 1..8;
 
   task type T_NN_Layer(Id : T_Layer_Id) is
      entry Respond(Data : in Node_Set;
                    Response : out Node_set);
      entry Train(Data : in Node_Set;
                  Response : in Node_set);
   end T_NN_Layer;
 
   type Layer_Access is access T_NN_Layer;
 
   package Real_Math is new PragmARC.Math.Functions (Supplied_Real => Real);
   package Real_Io is new Text_Io.Float_Io(Real);
 
   type T_Data is record
      Data : Node_Set(1..T_Code'Length*Sentence_Length) := (others => 0.0);
      Response : Node_Set(1..T_Code'Length*Sentence_Length) := (others => 0.0);
   end record;
 
   type T_Data_Stack is array (1..8) of T_Data;
 
   task body T_NN_Layer is
 
      Date : Time := Clock + 240.0;
      Data_Stack : T_Data_Stack;
      Stack_Index : Natural := 0;
 
   begin
      if Argument_Count > 0 and then
        Argument(1) = "-i" then
         declare
            procedure Get_Init(Pattern : in Positive;
                               Input : out Node_Set;
                               Desired : out Node_Set) is
            begin
 
               Input := (others => 0.0);
               Desired := (others => 0.0);
            end Get_Init;
 
            package NN_Init is new REM_NN
              (
               Num_Input_Nodes => Sentence_Length * T_Code'Length,
               Num_Hidden_Nodes => Sentence_Length,
               Num_Output_Nodes => Sentence_Length * T_Code'length,
               Num_Patterns => 1,
               New_Random_Weights => true,
               Input_To_Output_Connections => False,
               Weight_File_Name => "network" & T_Layer_Id'Image(Id) & ".wgt",
               Get_Input => Get_Init
               );
 
            use NN_Init;
         begin
            NN_Init.Train;
            NN_Init.Save_Weights;
         end;
      end if;
 
 
      loop
         select
            accept Respond(Data : in Node_Set;
                           Response : out Node_set) do
               declare
                  procedure Get(Pattern : in Positive;
                                Input : out Node_Set;
                                Desired : out Node_Set) is
                  begin
 
                     Input := Data;
                     Desired := (others => 0.0);
                  end Get;
 
 
                  package NN is new REM_NN
                    (
                     Num_Input_Nodes => Sentence_Length * T_Code'Length,
                     Num_Hidden_Nodes => Sentence_Length,
                     Num_Output_Nodes => Sentence_Length * T_Code'length,
                     Num_Patterns => 1,
                     New_Random_Weights => False,
                     Input_To_Output_Connections => False,
                     Weight_File_Name => "network" & T_Layer_Id'Image(Id) & ".wgt",
                     Get_Input => Get
                     );
 
                  use NN;
 
               begin
 
                  NN.Respond(1,Response);
 
                  for I in Response'Range loop
                     if Response(I) > 0.5 then
                        Response(I) := 1.0;
                     else
                        Response(I) := 0.0;
                     end if;
                  end loop;
               end;
            end Respond;
         or
            accept Train(Data : in Node_Set;
                         Response : in Node_set) do
 
               if Stack_Index < Data_Stack'Length then
                  Data_Stack(Stack_Index + 1) := (Data, Response);
                  Stack_Index := Stack_Index + 1;
               end if;
            end Train;
         or
            delay until Date;
            if Stack_Index /= 0 then
               declare
 
                  procedure Get_Expl(Pattern : in Positive;
                                     Input : out Node_Set;
                                     Desired : out Node_Set) is
                  begin
 
                     Input := Data_Stack(Pattern).data;
                     Desired := Data_Stack(Pattern).Response;
                  end Get_Expl;
 
 
                  package NN_Expl is new REM_NN
                    (
                     Num_Input_Nodes => Sentence_Length * T_Code'Length,
                     Num_Hidden_Nodes => Sentence_Length,
                     Num_Output_Nodes => Sentence_Length * T_Code'length,
                     Num_Patterns => Stack_index,
                     New_Random_Weights => False,
                     Input_To_Output_Connections => False,
                     Weight_File_Name => "network" & T_Layer_Id'Image(Id) & ".wgt",
                     Get_Input => Get_Expl
                     );
 
                  use NN_Expl;
 
 
                  Desired, Response : Node_Set(1..Sentence_Length * T_Code'Length) :=
                    (others => 0.0);
                  RMS_Error : Real := 0.0;
                  Error     : Real := 0.0;
                  Converged  : constant real := 1.0/Real(Stack_Index);
                  Max_Epochs : constant Positive := 2500;
                  Epoch : Natural := 0;
               begin
 
                  loop
 
                 All_Patterns :
                     for Pattern in 1..Stack_index Loop
                        NN_Expl.Train;
                        NN_Expl.Respond (Pattern, Response);
                        for I in Response'Range loop
                           Error :=
                             Error + (Data_Stack(Pattern).Response(i) - Response(i) );
                        end loop;
                        RMS_Error := RMS_Error + ((Error/Real(Response'Length)) ** 2);
                        Error := 0.0;
                     end loop All_Patterns;
                     RMS_Error := Real_Math.Sqrt(RMS_Error / Real (Stack_index)) ;
                     if Epoch > 50 and then
                       ((RMS_Error <= Converged) or
                       (Epoch >= Max_Epochs)) then
                        exit;
                     else
                        Text_Io.Put(Position(Id, 1));
                        Text_Io.Put ("Epoch" );
                        Text_Io.Put (Integer'Image (Epoch) );
                        Text_Io.Put(" => RMS_Error: " );
 
                        Real_Io.Put(RMS_Error);
 
                     end if;
 
                     Epoch := Epoch + 1;
                  end loop;
                  NN_Expl.Save_Weights;
               end;
            end if;
            Stack_Index := 0;
            Date := Clock + 60.0;
         end select;
      end loop;
   end T_NN_Layer;
 
   procedure Table2register(Table : in T_Lang_Array;
                            Register : out Node_Set) is
      Code : T_Code;
   begin
      for I in 0..Table'length-1 loop
         Code := Code_Of(Table(I+1));
         for J in T_Code'Range loop
            Register(I*T_Code'Length+J) := Code(J);
         end loop;
      end loop;
   end Table2register;
 
   procedure Register2table(Register : in Node_Set;
                            Table    : out  T_Lang_Array) is
      Code : T_Code;
   begin
      for I in 0..Table'length-1 loop
         Code := Register(I*T_Code'Length+1..I*T_Code'Length+T_Code'Length);
         Table(I+1) := Item_Of(Code);
      end loop;
   end Register2table;
 
 
   type T_Layer_Stack is array(T_Layer_Id'range) of Layer_access;
 
   task body Life_Cycle is
      Word : String(1..64) := (others => Character'Val(32));
      Last : Natural := 0;
      Response, Line : T_Lang_Array(1..Sentence_length) := (others => 0);
      Index : Natural := 0;
      Input, Output : Node_Set(1..T_Code'Length*Sentence_Length);
      Init : Boolean := False;
      Brain : T_Layer_Stack;
      Current_Layer : T_Layer_Id := T_Layer_Id'First;
      Errno : C.Int;
   begin
      The_Glossary.Initialize("Lexique-355.txt" );
      for I in brain'Range loop
         Brain(I) := new T_NN_Layer(I);
      end loop;
      loop
         select
            accept Receive(Char : in Character) do
               case Char is
                  when Character'Val(8) | Character'Val(127) =>
                     if Last > 0 then
                        Word(Last) := Character'Val(32);
                        Last := Last - 1;
                     elsif Index > 0 then
                        Line(Index) := 0;
                        Index := Index - 1;
                     end if;
                  when Character'Val(10) =>
                     begin
                        if Last /= 0 then
                           Line(Index+1) := Keyword(Word(1..Last));
                           Index := Index + 1;
                        end if;
                        if Init and Index > 0 then
                           Table2register(Line, Output);
                           Init := False;
                           --
                           Brain(Current_Layer).Train(Input, Output);
                           if Current_Layer < T_Layer_Id'Last then
                              Current_Layer := Current_Layer + 1;
                           else
                              Current_Layer := T_Layer_Id'First;
                           end if;
                           --
                        elsif Init then
                           --
                           for I in Current_Layer..T_Layer_Id'Last loop
                              Brain(i).Respond(Input, Output);
                              Brain(Current_Layer).Train(Input, Output);
                              if Current_Layer < T_Layer_Id'Last then
                                 Current_Layer := Current_Layer + 1;
                              else
                                 Current_Layer := T_Layer_Id'First;
                              end if;
                              Input := Output;
                           end loop;
                           if Current_Layer > T_Layer_Id'First then
                              for I in T_Layer_Id'First..Current_Layer - 1 loop
                                 Brain(i).Respond(Input, Output);
                                 Brain(Current_layer).Train(Input, Output);
                                 if Current_Layer < T_Layer_Id'Last then
                                    Current_Layer := Current_Layer + 1;
                                 else
                                    Current_Layer := T_Layer_Id'First;
                                 end if;
                                 Input := Output;
                              end loop;
                           end if;
 
                           Register2table(Output, Response);
                           --
                           Init := False;
                        else
                           Input := (others => 0.0);
                           Table2register(Line, input);
                           Init := True;
                        end if;
                        Word := (others => Character'Val(32));
                        Last := 0;
                        Line := (others => 0);
                        Index := 0;
                     exception
                        when Specification_Error =>
                           null;
                     end;
                  when Character'Val(32) =>
                     begin
                        Line(Index+1) := Keyword(Word(1..Last));
                        Index := Index + 1;
                        Word := (others => Character'Val(32));
                        Last := 0;
                     exception
                        when Specification_Error =>
                           null;
                     end;
                  when others =>
                     if Last < Word'Length then
                        Word(Last+1) := Char;
                        Last := Last + 1;
                     end if;
               end case;
            end Receive;
         or
            delay 0.1;
            Errno := System(C.To_C("clear" ));
            Text_Io.Put(Position(21, 1));
            Text_Io.Put("# " );
            for I in Response'Range loop
               Text_Io.Put(Image(Response(I)) & ' ');
            end loop;
            Text_Io.New_Line;
            Text_Io.Put("# " );
            if Index > 0 then
               for I in 1..Index loop
                  Text_Io.Put(Image(Line(I)) & ' ');
               end loop;
            end if;
            if Last > 0 then
               Text_Io.Put(Word(1..Last));
            end if;
            Text_Io.New_Line;
            Text_Io.Put("Current_Layer : " & T_Layer_Id'image(Current_Layer));
         end select;
 
      end loop;
   end Life_Cycle;
 
 
   Char : Character;
 
 
begin
 
   loop
      Text_Io.Get_Immediate(Char);
      Life_Cycle.Receive(Char);
   end loop;
 
end Main;

-----------------------------------------------------------------
-- Copyright (C) 2011 Numeric Prescience ; All right reserved. --
-----------------------------------------------------------------
-- Author  : Manuel De Girardi.                                --
-- Date    : 2011/01/14.                                       --
-- Version : Release.                                          --
-----------------------------------------------------------------
 
with Np.Glossary;
with Np.Generic_Extended_Binary_Code;
with PragmARC.REM_NN_Wrapper;
use PragmARC.REM_NN_Wrapper;
with PragmARC.Math.Functions;
with Ada.Direct_Io;
use Np;
 
with Ada.Numerics.Float_Random;
 
with Text_Io, Ada.Characters.Latin_1;
use Ada.Characters;
with Ada.Unchecked_Deallocation;
with Interfaces.C;
use Interfaces;
procedure Main is
 
   task Jushua is
      entry Halt;
      entry Receive(Pattern : in String);
   end Jushua;
 
   task Console is
      entry Initialize;
      entry Receive(Char : in Character);
      entry Receive(Pattern : in String);
      entry Lock;
      entry Unlock;
      entry Info(RMS_Error : in Real; Percent : in Real);
      entry Halt;
   end Console;
 
   function System(Command : in C.Char_Array) return C.Int;
   pragma Import(C, System, "system" );
 
   type String_Access is access all String;
   procedure Free is
      new Ada.Unchecked_Deallocation(String, String_Access);
 
 
 
   package The_Glossary is new Glossary(125660);
   use The_Glossary;
   Sentence_Length : constant Natural := 20;
   subtype T_Sentence is T_Lang_Array(1..Sentence_Length);
   package Coded_Word is new Generic_Extended_Binary_Code(T_Language);
   use Coded_Word;
 
   Rand_Gen :
     Ada.Numerics.Float_Random.Generator;
 
 
   subtype T_Register is Node_Set(1..T_Code'Length*Sentence_Length);
   package Real_Math is new PragmARC.Math.Functions (Supplied_Real => Real);
   package Real_Io is new Text_Io.Float_Io(Real);
   --package Register_Io is new Direct_Io(T_Register);
   procedure Table2register(Table : in T_Lang_Array;
                            Register : out Node_Set) is
      Code : T_Code;
   begin
      for I in 0..Table'Length-1 loop
         Code := Code_Of(Table(I+1));
         for J in T_Code'Range loop
            Register(I*T_Code'Length+J) := Code(J);
         end loop;
      end loop;
   end Table2register;
 
   procedure Register2table(Register : in Node_Set;
                            Table    : out  T_Lang_Array) is
      Code : T_Code;
   begin
      for I in 0..Table'Length-1 loop
         begin
            Code := Register(I*T_Code'Length+1..I*T_Code'Length+T_Code'Length);
               Table(I+1) := Item_Of(Code);
         exception
            when others =>
               null;
         end;
      end loop;
   end Register2table;
 
 
   function String2table(Expr : in String) return T_Lang_Array is
      Sentence : T_Sentence := (others => 0);
      Prec : Natural := 0;
      Index : Natural := 0;
   begin
      if Expr'length /= 1 then
         for I in 2..Expr'length loop
            case Expr(I) is
               when Character'Val(32) =>
                  begin
                     Text_Io.Put("." );
                     sentence(Index+1) := keyword(Expr(Prec+1..I-1));
                     Index := Index + 1;
                     Prec := I;
                  exception
                     when others =>
                        null;
                  end;
               when others =>
                  null;
            end case;
            exit when Index = Sentence'Length;
         end loop;
      end if;
      if Index < Sentence'Length then
         begin
            sentence(Index+1) := keyword(Expr(Prec+1..Expr'last));
            Index := Index + 1;
            Text_Io.Put("Done" );
         exception
            when others =>
               null;
         end;
      end if;
      return Sentence;
   end String2table;
 
   task body Jushua is
      End_Of_Section, End_Of_Task : Boolean := False;
      Data_stack : array (1..8*2) of T_Register :=
        (others => (others => 0.0));
 
      Temp, Register : T_Register := (others => 0.0);
 
      Buffer : String_Access;
      Output : String_Access := new String ' ("" );
 
      Sentence : T_Sentence;
 
      Reuse : Boolean := False;
 
   begin
 
      while not End_Of_Task loop
         declare
            procedure Get_Expl(Pattern : in Positive;
                               Input : out Node_Set;
                               Desired : out Node_Set) is
            begin
               Input := Data_Stack(Pattern*2-1);
               Desired :=  Data_Stack(Pattern*2);
            end Get_Expl;
 
 
            package NN_Expl is new REM_NN
              (
               Num_Input_Nodes => Sentence_Length * T_Code'Length,
               Num_Hidden_Nodes => Sentence_Length,
               Num_Output_Nodes => Sentence_Length * T_Code'length,
               Num_Patterns => Data_Stack'Length/2,
               New_Random_Weights => not Reuse,
               Input_To_Output_Connections => False,
               Weight_File_Name => "network.wgt",
               Get_Input => Get_Expl
              );
 
            use NN_Expl;
 
 
            Desired, Response : T_register := (others => 0.0);
            RMS_Error : Real := 10.0;
            Error     : Real := 0.0;
            Converged  : constant real :=
              0.125 + Real(Ada.Numerics.Float_Random.Random(rand_Gen))/1000.0;
 
 
         begin
            while not End_Of_Section loop
               select
                  accept Halt do
                     End_Of_Task := True;
                     End_Of_Section := True;
                  end Halt;
               or
                  accept Receive(Pattern : in String) do
                     Register := (others => 0.0);
                     Table2register(String2table(Pattern), Register);
                     for I in 2..Data_Stack'Length loop
                        Data_Stack(I-1) := Data_Stack(I);
                     end loop;
                     Data_Stack(Data_Stack'last) := Register;
                     End_Of_Section := True;
                  end Receive;
               or
                  delay 0.0;
 
                  for Pattern in 1..Data_Stack'Length/2 Loop
                     NN_Expl.Train;
                     NN_Expl.Respond (Pattern, Response);
                     Desired := Data_Stack(Pattern*2);
                     for I in Response'Range loop
 
                        Error :=
                          Error + (Desired(I) - Response(i) );
                     end loop;
                     RMS_Error := RMS_Error + ((Error/Real(Response'Length)) ** 2);
                     Error := 0.0;
                  end loop;
                  NN_Expl.Save_Weights;
                  RMS_Error :=
                    Real_Math.Sqrt(RMS_Error / Real (Data_Stack'Length/2)) ;
 
                  if (RMS_Error <= Converged) then
                     NN_Expl.Respond (8, Response);
 
                     for I in Response'Range loop
                        if Response(I) >= 0.5 then
                           Response(I) := 1.0;
                        else
                           Response(I) := 0.0;
                        end if;
                     end loop;
 
                     Register2table(Response, sentence);
                     for I in Sentence'Range loop
                        begin
                           Free(Buffer);
                           Buffer := new String ' (Output.all & Image(sentence(I)) & Character'Val(32));
                           Free(Output);
                           Output := new String ' (Buffer.All);
                        exception
                           when others =>
                              null;
                        end;
                     end loop;
                     Console.Receive(Output.all);
                     Free(Output);
                     Output := new String ' ("" );
 
                     Temp := Data_Stack(Data_Stack'last-1);
 
                     for I in 3..Data_Stack'Length loop
                        Data_Stack(I-2) := Data_Stack(I);
                     end loop;
                     Data_Stack(Data_Stack'Last-1) := Response;
                     Data_Stack(Data_Stack'last) := Temp;
                     End_Of_Section := True;
 
                  else
                     select
                        Console.info(RMS_Error, (converged/RMS_Error)*100.0);
                     or
                        delay 0.0;
                     end select;
                  end if;
 
               end select;
            end loop;
         end;
         End_Of_Section := False;
         Reuse := True;
      end loop;
   end Jushua;
 
   task body Console is
      Suspended, End_Of_Task : Boolean := False;
      Line : String_access := new String ' ("" );
      Buffer : String_Access;
      Errno : C.Int;
 
      Input_Page_Stack : array (1..12) of String_Access;
      Input_Window_Index : Natural := 0;
      input_Page_Index : Natural := 0;
      Output_Page_Stack : array (1..12) of String_Access;
      Output_Window_Index : Natural := 0;
      Output_Page_Index : Natural := 0;
      Line_Count : Integer := 10;
 
      Learning_Info : String_Access := new String ' ("" );
 
   begin
      accept Initialize;
      while not End_Of_Task loop
 
         Errno := System(C.To_C("clear" ));
         Text_Io.Put_line(Learning_Info.all);
 
         Text_Io.Put_Line("-----------------------------------  Output  ----------------------------------" );
         Line_Count := 10;
         if Output_Page_Index /= 0 then
            for I in reverse 1..Output_Page_Index loop
               exit when (Line_Count - ((Output_Page_Stack(I).all'Length/80) + 1)) < 1;
               Line_Count := Line_Count - ((Output_Page_Stack(I).all'Length/80) + 1);
               Output_Window_Index := Output_Window_Index + 1;
            end loop;
            for I in reverse 0..Output_Window_Index-1 loop
               Text_Io.Put_Line(Output_Page_Stack(output_Page_Index - I).all);
            end loop;
         end if;
         Output_Window_Index := 0;
         if Line_Count > 0 then
            Text_Io.New_Line(Text_Io.Count(Line_Count));
         end if;
         Text_Io.Put_Line("-----------------------------------  Input  -----------------------------------" );
         Line_Count := 12 - ((Line.all'Length/80) + 1);
         if Input_Page_Index /= 0 then
            for I in reverse 1..Input_Page_Index loop
               exit when (Line_Count - ((Input_Page_Stack(I).all'Length/80) + 1)) < 1;
               Line_Count := Line_Count - ((Input_Page_Stack(I).all'Length/80) + 1);
               Input_Window_Index := Input_Window_Index + 1;
            end loop;
            for I in reverse 0..Input_Window_Index-1 loop
               Text_Io.Put_Line(Input_Page_Stack(Input_Page_Index - I).all);
            end loop;
         end if;
         Input_Window_Index := 0;
         if Line_Count > 0 then
            Text_Io.New_Line(Text_Io.Count(Line_Count));
         end if;
         Text_Io.Put(Line.all);
         delay 0.01;
         select
            accept Lock do
               Suspended := True;
            end Lock;
         or
            accept Receive(Char : in Character) do
               case Char is
                  when Latin_1.Del =>
                     Buffer := new String ' (Line(1..Line'Length-1));
                     Free(Line);
                     Line := new String ' (Buffer.all);
                     Free(Buffer);
                  when Latin_1.LF =>
                     Jushua.Receive(Line.all);
                     if Input_Page_Index = Input_Page_Stack'Length then
                        for I in 2..Input_Page_Index loop
                           Input_Page_Stack(I-1) :=
                             Input_Page_Stack(I);
                        end loop;
                        Input_Page_Index := Input_Page_Index - 1;
                     end if;
                     if Input_Page_Index < Input_Page_Stack'Length then
                        Input_Page_Stack(Input_Page_Index+1) :=
                          new String ' (Line.all);
                        Input_Page_Index := Input_Page_Index + 1;
                     end if;
                     Free(Line);
                     Line := new String ' ("" );
                  when others =>
                     Buffer := new String ' (Line.all & Char);
                     Free(Line);
                     Line := new String ' (Buffer.all);
                     Free(Buffer);
               end case;
            end Receive;
         or
            accept Receive(Pattern : in String) do
               if Output_Page_Index = Output_Page_Stack'Length then
                  for I in 2..Output_Page_Index loop
                     Output_Page_Stack(I-1) :=
                       Output_Page_Stack(I);
                  end loop;
                  Output_Page_Index := Output_Page_Index - 1;
               end if;
               if Output_Page_Index < Output_Page_Stack'Length then
                  Output_Page_Stack(Output_Page_Index+1) :=
                    new String ' (Pattern);
                  Output_Page_Index := Output_Page_Index + 1;
               end if;
            end Receive;
         or
            accept Info(RMS_Error : in Real; Percent : in Real) do
               Free(Learning_Info);
               Learning_Info := new String ' ("Learning : " &
                                                Real'Image(Percent) & "% ; " &
                                                "RMS_Error = " &
                                                Real'Image(RMS_Error));
            end Info;
         end select;
         while Suspended loop
            select
               accept Halt do
                  Suspended := False;
                  End_Of_Task := True;
               end Halt;
            or
               accept Unlock do
                  Suspended := False;
               end Unlock;
            end select;
         end loop;
      end loop;
 
   end Console;
 
   Char : Character;
begin
 
   Initialize("Lexique-355.txt" );
   Console.Initialize;
   loop
      begin
         Text_Io.Get_Immediate(Char);
         if char =  Latin_1.Esc then
            Console.Lock;
            Text_Io.New_Line;
            Text_Io.Put("Quit? " );
            Text_Io.Get_Immediate(Char);
            if Char = 'y' or Char = 'Y' then
               exit;
            else
               Text_Io.Put_line("Excelent!" );
               Console.Unlock;
            end if;
         else
            Console.Receive(Char);
         end if;
      exception
         when others =>
            null;
      end;
   end loop;
   Jushua.Halt;
   Console.Halt;
end Main;

----------------------------------------
-- Joshua is an artificial intelligence.
----------------------------------------
-- Author      : Manuel De Girardi
-- Date        : 28/01/2011
-- version     : devel.
-- Description : On va essayer de traiter
--               le langage naturel au
--               niveau caractères en
--               exploitant les RdN.
----------------------------------------
with Lfa.Data_Types, Lfa.Fann, Lfa.Fann.Train_Data;
use Lfa, Lfa.Data_Types, Lfa.Fann;
 
with Ada.Text_Io, Ada.Command_Line;
use Ada;
 
procedure Main is
 
   package Fann_Text_Io is new Text_Io.Float_Io(Fann_Type);
   -- pour les entrées/sorties texte du type Fann_Type;
 
   Max_Words : constant := 21;
   Max_Chars_By_Word : constant := 26;
 
 
 
   type T_Register is array (1..8*Max_Chars_By_word*Max_words) of Fann_Type;
   -- 32 mots de 26 caracters codés sur 8 bits.
 
   type Register_Access is access all T_Register;
   -- les accès aux registres.
 
   subtype T_Str is String(1..Max_Chars_By_word*Max_words);
   -- 32 mots de 26 caracters.
 
   type Str_Access is access all T_Str;
   -- les accès aux chaînes T_Str.
 
   function Str2Reg(Buffer : in Str_Access) return Register_access is separate;
   -- Routine pour convertir des T_Str en T_Register.
 
   function Reg2Str(Buffer : in Register_Access) return Str_Access is separate;
   -- Routine pour convertir des T_Register en T_Str.
 
 
 
   procedure Txt2Fann(Source, Target : in String);
   -- procédure de conversion de fichier texte vers fichier fann type.
 
   Buffer_Overflow : exception;
   -- levée par Txt2Fann lorsque une ligne dépasse la longueur de T_Str.
 
 
   procedure Txt2Fann(Source, Target : in String) is
 
      Input, Output : Text_Io.File_Type;
      Line : String(1..T_Str'Length+1) := (others => Character'Val(32));
      Last : Natural := 0;
      Reg  : Register_Access;
      Str  : Str_Access := new T_Str ' (others => Character'Val(32));
      Line_Count : Text_Io.Count := 0;
   begin
      Text_Io.Open(Input, Text_Io.In_File, Source);
      -- D'abord, on compte le nombre de ligne lignes.
      while not Text_Io.End_Of_File(Input) loop
         Text_Io.Get_Line(Input, Line, Last);
         Line_Count := Text_Io."+"(Line_Count, 1);
      end loop;
 
      Text_Io.Reset(Input);
 
      Text_Io.Create(Output, Text_Io.Out_File, Target);
      -- on écrit la géométrie du réseau dans le fichier d'entrainement.
      Text_Io.Put(Output, positive'Image(Positive(Line_Count)/2));
      Text_Io.Put(Output, Positive'Image(8*Max_Chars_By_word*Max_words));
      Text_Io.Put(Output, Positive'Image(8*Max_Chars_By_word*Max_words));
      Text_Io.New_Line(Output);
 
      while not Text_Io.End_Of_File(Input) loop
         Text_Io.Get_Line(Input, Line, Last);
         if Last = Line'Length then
            -- Si la ligne dépasse la longueur d'un T_Str
            -- on lève l'exception buffer_overflow;
            raise Buffer_Overflow;
         end if;
         Str.all := Line(1..Line'Last-1);
         Reg := Str2Reg(str);
         for Bit in Reg'Range loop
            Fann_Text_Io.Put(Output, Reg(Bit), 1, 1);
            Text_Io.Put(Output, Character'Val(32));
         end loop;
         Text_Io.New_Line(Output);
         Line := (others => Character'Val(32));
      end loop;
      Text_Io.Close(Output);
      Text_Io.Close(Input);
   end Txt2Fann;
 
   Train_Filename : constant String := "fann_train.txt";
   -- Le nom du fichier Fann type d'entrainement.
 
 
   Layout_Array : Fann_Layout_Array(1..5) :=
     (1 =>              Neuron_Number(8*Max_Chars_By_Word*Max_Words),
      2 =>              Neuron_Number(Max_Words*8),
      3 =>              Neuron_Number(Max_Words),
      4 =>              Neuron_Number(Max_Words*8),
      5 =>              Neuron_Number(8*Max_Chars_By_Word*Max_Words));
   -- définition de la structure du RdN.
 
   Ann : Fann_Access;
   -- Le RdN.
 
   Data_Train : Train_Data.Train_Data_Access;
   -- Les données du RdN.
 
 
begin
   ....
   null;
end Main;