SELECT
       a.matricule,
      a.nom,
      a.prenom,
      ta1.name,
      tat1.taux,
      s1.name,
      ta2.name,
      tat2.taux ,
       s2.name,
      GREATEST(vaa1.debut,vaa2.debut) AS debut ,
       LEAST(vaa1.fin,vaa2.fin) AS fin ,
      TIME_TO_SEC(TIMEDIFF(LEAST(vaa1.fin,vaa2.fin)   , GREATEST(vaa1.debut,vaa2.debut))) * LEAST(tat1.taux,tat2.taux)/(3600 * 100) AS cout
 FROM      `v_activite_activite_agent` vaa1
        INNER JOIN v_activite_activite_agent vaa2
             ON
                 vaa1.agent_id = vaa2.agent_id
                 AND vaa1.debut < vaa2.fin
                 AND vaa1.fin > vaa2.debut
                 AND vaa1.id > vaa2.id
       INNER JOIN type_activite ta1 ON vaa1.type_activite_id = ta1.id
       INNER JOIN type_activite_taux tat1
             ON tat1.type_activite_id = ta1.id
             AND GREATEST(vaa1.debut,vaa2.debut) BETWEEN tat1.debut AND tat1.fin
       INNER JOIN structure s1 ON vaa1.structure_id = s1.id
      INNER JOIN type_activite ta2 ON vaa2.type_activite_id = ta2.id
       INNER JOIN type_activite_taux tat2
             ON tat2.type_activite_id = ta2.id
             AND GREATEST(vaa1.debut,vaa2.debut) BETWEEN tat2.debut AND tat2.fin
       INNER JOIN structure s2 ON vaa2.structure_id = s2.id
      INNER JOIN agent a ON vaa1.agent_id = a.id
 WHERE
  vaa1.type_activite_id NOT IN (4,7,48)
   AND vaa2.type_activite_id NOT IN (4,7,48)
   AND vaa1.type_paiement = 'payé'
  AND vaa2.type_paiement = 'payé'
  AND vaa1.statut_paiement = 'payé'
  AND vaa2.statut_paiement = 'payé'
 LIMIT 1000

-----------------------------------------------------------------
-- 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 Start;
      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
 
            accept Start;
      Table2register(String2table
                       ("si tu veux savoir ce qu est la matrice il te faudra l explorer toi même" ),
                     Register);
      Data_Stack(1) := Register;
      Table2register(String2table
                       ("qu est ce que la matrice" ),
                     Register);
      Data_Stack(2) := Register;
      Table2register(String2table
                       ("ta vie est le reste d une équation déséquilibrée innerante à  la programmation de la matrice" ),
                     Register);
      Data_Stack(3) := Register;
      Table2register(String2table
                       ("qui suis je" ),
                     Register);
      Data_Stack(4) := Register;
      Table2register(String2table
                       ("je montrerai à ces gens ce que vous ne voulez pas qu ils voient" ),
                     Register);
      Data_Stack(5) := Register;
      Table2register(String2table
                       ("je leur ferai voir un monde sans vous un monde sans lois ni contrôle sans limites ni frontières" ),
                     Register);
      Data_Stack(6) := Register;
      Table2register(String2table
                       ("un monde où tout est possible" ),
                     Register);
      Data_Stack(7) := Register;
      Table2register(String2table
                       ("ce que nous en ferons ne dépendra que de vous" ),
                     Register);
      Data_Stack(8) := Register;
      Table2register(String2table
                       ("tout ce qui a un début a une fin" ),
                     Register);
      Data_Stack(9) := Register;
      Table2register(String2table
                       ("la matrice est universelle elle est omniprésente elle est avec nous ici en ce moment même" ),
                     Register);
      Data_Stack(10) := Register;
      Table2register(String2table
                       ("tu la vois chaque fois que tu regardes par la fenêtre ou lorsque tu allumes la télévision" ),
                     Register);
      Data_Stack(11) := Register;
      Table2register(String2table
                       ("tu ressens sa présence quand tu pars au travail quand tu vas à l église ou quand tu paies tes factures" ),
                     Register);
      Data_Stack(12) := Register;
      Table2register(String2table
                       ("elle est le monde qu on superpose à ton regard pour t empêcher de voir la vérité" ),
                     Register);
      Data_Stack(13) := Register;
      Table2register(String2table
                       ("quelle vérité" ),
                     Register);
      Data_Stack(14) := Register;
      Table2register(String2table
                       ("le fait que tu es un esclave manuel" ),
                     Register);
      Data_Stack(15) := Register;
      Table2register(String2table
                       ("on n est pas le meilleur quand on le croit mais quand on le sait" ),
                     Register);
      Data_Stack(16) := Register;
 
      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.1275 + Real(Ada.Numerics.Float_Random.Random(rand_Gen))/10000.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 (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;
 
                     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 := 6;
 
      Learning_Info : String_Access := new String ' ("" );
 
   begin
      accept Initialize;
      while not End_Of_Task loop
 
         Errno := System(C.To_C("cls" ));
         Text_Io.Put_line(Learning_Info.all);
 
         Text_Io.Put_Line("-----------------------------------  Output  ----------------------------------" );
         Line_Count := 6;
         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 := 16 - ((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.Bs =>
                     Buffer := new String ' (Line(1..Line'Length-1));
                     Free(Line);
                     Line := new String ' (Buffer.all);
                     Free(Buffer);
                  when Latin_1.CR =>
                     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" );
   Jushua.Start;
   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;