Bonjour, ce sujet est d'abord connexe à celui de l'appelle de fonction par entrée en chaîne de caractères.
Comme il s'agit d'un projet avec Ada, et ma question étant sensiblement pondérée par le fait qu'il en soit ainsi, j'ouvre ce sujet pour éviter les multiple fils sauf spécialement peut-être.
 
Pour le moment donc, les sources actuelle sont lisible au lien indiqué dans le sujet sus-cité ou ici.
Je souhaite à présent intégrer une vue du process par le biais de l'exploitation d'un réseau de neurones artificiels qui dans un premier ou second temps devra répondre au besoins suivants :
 
- dialogue entre réseau de neurones et utilisateur humain dans un langage proche d'un ou plusieurs langages naturels.
- imagination des classe : c'est à dire interprétation des argument dans un langage proche "   "   "  "  ".
 
C'est déjà ça de formulé. Reste à développer !
 
Je ne connais pas bien les réseaux de neurones artificiels mais je les utilise depuis plusieurs années, toujours satisfait.
Le problème ne réside pour le moment pas dans l'implémentation d'un tel process, mais en sont exploitation.
Hors, j'ai déjà implémenté un agent de dialogue basé sur ce principe, il me reste à l'intégrer en vérifiant la seconde contrainte, l'imaginattion...
 
L'imagination, ça me parait plus corsé :
 
Si j'entre  : "l'énergie consommée par un chassis de masse 100kg avec une ou plusieurs roue circulaire de 13" de rayon, .... etc" ;  
Je doit obtenir un objet ou un système (un objet contenant d'autre objets), ou un processus correspond à l'argument entré, et la fin du programme applé ; Avec un beau message "Mission accomplie". Je plaisante mais pourquoi pas.
 
A moins que ce ne soit que discursif, je sort ça maintenant, mais un discours ne constitu pas toujours une construction.
A ce moment ci on se contente de coller les attributs aux classes concernées, par contre il faut mettre à jour chacun des systèmes en correspondance.
 
Voilà, je crois que j'ai l'essence.
Je ne sais pas si je suis suffisement clair pour me coucher et reprendre l'idée énoncée plus tard.
 
Donc, j'aurais voulu savoir, si vous pouvez réagir sur ma formulation de mon problème, si il est relativement compréhensible ? ou si vous avez une correction à apporter ou une complétion pour parfaire cet organisme cybernétique. Merci.

Voilà alors, je ne suis pas encore couché.
 
J'ai trouvé, ce que je cherchais, soit le lieux et l'endroit ou écrire le nouveau bout de code qui va bien.
 
En fait j'ai enrichit le type Human_Object_type avec un type tache qui fera l'interface entre le system (l'administrateur et les utilisateur) et "le gestionnaire du réseau de neurones".
que l'on va appeller avec une nouvel méthode pour l'objet Human_Object_Type nommée Logos que l'on poura appeller du client de l'interface human_interface_type.
 
Après il faut que je reflechisse :  
 
1 -- du français pour retourner du français  
2 -- du français pour retourner un pseudo code compatible avec l'implémentation du cyborg ;
3 -- du cyborg language pour retourner du français.
 
Genre : je mange une pomme, doit retourner tu manges une pomme.
Puis : tu mange une pomme -> une méthode pomme.manger(Homme);
Puis : Homme.manger -> "tu as manger 1 pomme et 2 poires".  
 
Aprsè avoir exécuter univers.elements.fusion (homme, pomme).
 
En gros hein. Resta à.
 
Des avis sur le sujet à chaud ?
 
J'ai mis à jour le code sur le site mais vous pouvez trouver la version précédente soit la 0.1.5 sur sourceforge, project cyborg www :  sourceforge.net/projects/cyborg-project/

Je poursuie mes idées...
 
Je redessine de travail à faire en 4 points pour intégrer l'effet d'une action sur le système.
 
Je vais avoir 4 actions que je defini ainsi :
 
- action neurologique du langage L
  input string language L
  output string langage L
 
- action correlation du langage L et l'environnement virtuel orienté objet.
  input langage L
  output Objet décrit par le langage L
 
- action systématique des Objets dans leurs environnement virtuel orienté objet.
  input (environnement, Objet, Methode, parameters);
  output Pseudo langage proche du langage L.
 
- action Fin
  input Pseudo langage proche du langage L.
  output Pseudo langage proche du langage L.
 
 
                                                                                                     hello localghost ! (action4) bonjour Manuel.
                                                                                                   /
par exemple : avec bonjour (action1) bonjour (action2) hello (action3)  
                                                                                                   \ (feedback ?)
                                                                                                     Manuel dit bonjour : Univers.Cyborg.Hello_Count := Univers.Cyborg.Hello_Count + 1.

- AI    
- Phrases inconpréhensibles    
- Ada    
- Projet farfellu    
 
 

Evident !
Je savais que ce style me disait quelque chose en lisant juste les deux premières phrases mais je n'avais pas reconnu.  
Skynet est en marche...
Impatient de voir la suite

Bonjour, tiens puisque vous êtes là,
Je cherche pourquoi j'ai multiple fois un ! et un ? dans le fichier qui est écrit alors qu'ils ne devraient s'y trouver qu'une seule fois chacun avec cette fonction :
 

Glossary_Filename : Unbounded_String := To_Unbounded_String("data/lexique.txt" );
   
function String2input(Line : in String) return Input_Type is
      Input : Input_Type := (others => 0.0);
      Code : Code_Type;
      
      Top, Index : Natural := 0;
      Done : Boolean := False;
      Item : Natural := 0;
      
      
      Lexique : Ada.Text_Io.File_Type;
      
      
   begin 
      if Line'Length = 0 then
     Done := True;
      end if;
      Top := Line'first;
      
      loop
     exit when Top > Line'Last or Item >= Max_Words-1;
     if (Top >= Line'Last) then
        begin
           Code := Code_Of(Keyword(Line(Top..Line'Last), Words));
           for J in Code_Type'Range loop
          Input(((Max_Words-Item)-1)*Code_Type'Length+J) := code(J);
           end loop;     
           exit;
        exception
           when others =>
          Words_Glossary.Add(Line(top..Line'last), Key_Count(Words), Words);
          Open(Lexique, Append_File, To_String(Glossary_Filename));
          Put_Line(Lexique, Line(top..Line'last));
                   
          Close(Lexique);
          Code := Code_Of(Keyword(Line(Top..Line'Last), Words));
          for J in Code_Type'Range loop
             Input(((Max_Word-Item)-1)*Code_Type'Length+J) := code(J);
          end loop;     
          exit;
        end;
     end if;
          
     for cur in Top..Line'Last loop
        
        if Is_Control(Line(Cur)) then
           null;
        
        elsif Is_Graphic(Line(Cur)) then
           
           if Is_Digit(Line(Cur)) then
          begin
             --Put(Line(Cur..Cur));
             Code := Code_Of(Keyword(Line(cur..cur), Words));
             for J in Code_Type'Range loop                  
            Input(((Max_Word-Item)-1)*Code_Type'Length+J) := code(J);
             end loop;     
             Item := Item + 1;               
             Top := Cur;
             exit;
          exception
             when others =>                  
            --Put("Exception 1 " & Line(Cur..Cur));
            
            Words_Glossary.Add(Line(cur..Cur), Key_Count(Words), Words);
            Open(Lexique, Append_File, To_String(Glossary_Filename));
            Put_Line(Lexique, Line(Cur..Cur));
            Close(Lexique);
        
            Code := Code_Of(Keyword(Line(cur..Cur), Words));
            for J in Code_Type'Range loop
               
               Input(((Max_Word-Item)-1)*Code_Type'Length+J) := code(J);
            end loop;     
            Item := Item + 1;
            Top := Cur;
            exit;               
          end;
           
           elsif Is_Special(Line(Cur)) then
      case Line(Cur) is
             when '+' | '[' | '{' | '(' | ',' | ';' | ' ' | '?' | '!' | 
               ''' | '@' | '#' | '&' | '\' | '/' | ':' | '-' | '.' | 
               '%' | '*' | '$' | '=' | '_' | ')' | '}' | ']' | '<' | '>'  =>
            if Cur > Top then
               begin
                  --Put(Line(top..Cur-1));
                  Code := Code_Of(Keyword(Line(top..Cur-1), Words));            
                  for J in Code_Type'Range loop
                 Input(((Max_Word-Item)-1)*Code_Type'Length+J) := code(J);
                  end loop;     
                  Item := Item + 1;
                  Top := Cur;
               exception
                  when others =>
                 --Put("Exception 2" & Line(top..Cur-1));
                 Words_Glossary.Add(Line(top..Cur-1), Key_Count(Words), Words);                  
                 --Put_line("open file" );
                 Open(Lexique, Append_File, To_String(Glossary_Filename));
                 --Put_line("put_line in file" );
                 Put_Line(Lexique, Line(top..Cur-1));
                 
                 Close(Lexique);
                 --Put_line("file closed" );
                 Code := Code_Of(Keyword(Line(top..Cur-1), Words));
                 --Put_line("code ok" );
                 for J in Code_Type'Range loop
                    Input(((Max_Word-Item)-1)*Code_Type'Length+J) := code(J);
                 end loop;     
                 Item := Item + 1;
                 Top := Cur;
                 --Put_line("ready for next word." );
 
               end;       
            end if;
            begin
               --Put(Line(Cur..Cur));
               Code := Code_Of(Keyword(Line(cur..cur), Words));
               for J in Code_Type'Range loop
                  Input(((Max_Word-Item)-1)*Code_Type'Length+J) := code(J);
               end loop;     
               Item := Item + 1;               
               exit;
            exception
               when others =>                  
                  --Put("Exception 3" & Line(Cur..Cur));
                  
                  Words_Glossary.Add(Line(cur..Cur), Key_Count(Words), Words);
                  Open(Lexique, Append_File, To_String(Glossary_Filename));
                  --Put_Line(Lexique, Line(cur..Cur));
                  Close(Lexique);
        
                  Code := Code_Of(Keyword(Line(cur..Cur), Words));
                  for J in Code_Type'Range loop
                 
                 Input(((Max_Word-Item)-1)*Code_Type'Length+J) := code(J);
                  end loop;
                  Item := Item + 1;
                  Top := Cur;
                  exit;               
            end;              
             when others =>
            null;
          end case;
      
          
           end if;
        end if;        
     end loop;
     
     Top := Top + 1;
     
      end loop;
      return Input;
end String2input;

En fait j'ai une exception levé dans la condition du premier if qui fait péter le rtraite exception à chaque fin de ligne.
Je sais pas pourquoi pour le moment, j'ai bien mon ? ou ! dans le glossaire, bref. Merci en tout cas.
 
Ah ouis, il y a Max_Words avec un s au lieux de Max_Word sans s, c'est peut-être ça qui fait...

J'ai intégrer une exploitation d'un réseau de neuronnes pour la première action.
 
Alors ça ce complique un peu plus pour l'action 2 devant modéliser l'objet du discours du langage L, je veux à présent puisque de toute manière se sont deux machines qui communique, exécuter le code résultant sur le client avec l'environnement du client, et avoir un retour sur le serveur.
 
Je crois que ce sera pas mal pour le moment.
 
Je reviens dans 10ans.

Je vais travailler sur un shema simple !
Je constuirai sur le model.
 
Dans un premier temps, puisque j'ai modéliser un homme comme un nom et un solde, je vais essayer de faire en sorte que lorsuqe je lui demande sont solde il réponde exactement le crédit ou le débit au cent près.
 
localhost quel est ton solde ?
localghost mon solde est débiteur de 2.0 €.
 
Alors ça implique beaucoup de chose, que je n'ai pas encore analysé/implementé.
 
C'est chaud hein !
 
Je reformule les actions :  
 
neurologique :

 
Aprsè peut-être passer l'entrée et la sortie pour aller chercher le résultat dans l'environnement.
 
env : (name, solde);
 
function to_be (input : in string; output : in string) return string.
 
Quoi qu'il en soit je vais être aubligé de parser du français pour manipuler l'environnement. Peut-être plus formel cependant
Sans compter toute la machinerie qui va avec, tout ça pour chaque classe... Bref Je vais réflechir.
 
A+

Bonjour,
Si vous êtes matinal, et que vous trouvez ce sujet intéressant voir pationnant voici ce que je viens de faire :
Il s'agit de pouvoir modéliser des induvidus qui évolue dans des environnements différents mais j'ai du mal à poursuivre mon commentaire.
Chaque cyborg poura être client/serveur d'un autre cyborg, chaqun pouvant refleter l'autre ou s'identifier relativement à sont environnement.
 

with Libroot.Es.Abstracts.Classified.Date_Object;
use Libroot.Es.Abstracts.Classified.Date_Object;
with Libroot.Es.Abstracts.Classified.Text_Object;
use Libroot.Es.Abstracts.Classified.Text_Object;
 
package Libroot.Es.Abstracts.Objects.Environments is      
      
   type Environment_Type;
   
   type Environment_Access is access all Environment_Type'Class;   
   
   type Environment_Array_Type is array (Natural range <> ) of Environment_Access;
   
   type Variadic_Array_Access is access Variadic_Array_Type;
   
   type Environment_Elements_Array_Type is array (Natural range <> ) of Variadic_Array_Access;      
   
   type Environment_Type(Max_Elements : Positive) is tagged
      record
         Elements : Environment_Elements_Array_Type(0..Max_Elements) := (others => null);
      end record;                  
   
   type Univers_Type(Max_Environments : Positive) is tagged
      record     
         Environments : Environment_Array_Type(0..Max_Environments) := (others => null);
      end record;
 
   type Univers_access is access all Univers_Type'Class;   
            
end Libroot.Es.Abstracts.Objects.Environments;

Un environnement est un tableau variable construites à partir d'une liste d'objets divers comme une chaîne de character un integer ou un boolean qui portera donc un nom dans autre objet chaîne de character et qui aura une valeur connue sous forme de chaine de character mais aussi sous ça forme virtuelle.
Ainsi on poura tout modéliser et nommer les choses.
 
Reste les actions ....
 
Et dans l'objet Human_Object_Type qui est un type privé :

type Human_Object_Type is new Human_Type with
      record
         Univers    : Univers_Access := new Univers_Type(Max_Environments => 500);
         Thread     : Human_Thread_Type(Human_Object_Type'Access);
      end record;

(J'ai initializé à 500 mais je n'ai pas encore exécuté, donc prudence.)
 
L'univers va remplacer la variable attributs du type Human_Type dérivé ici.
 
un peutit bout de code pour initializer l'univers :

Univers    : Univers_Access := 
           new Univers_Type ' 
           (500, 
            (1 => new Environment_Type ' 
               
               (2, (0 => new Variadic_Array_Type '
                      (new Text_Object_Type ' (Text => new String ' ("name" )),
                       new Text_Object_Type ' (Text => new String ' ("" ))
                      ),
                    1 => new Variadic_Array_Type '
                      (new Text_Object_Type ' (Text => new String ' ("sodle" )),
                       new Text_Object_Type ' (Text => new String ' ("0.0" ))  
                      ),
                    2 => null
                      
                   )
               ),
             others => null));

Bonjour, ou bonsoir,
 
 
Le programme est enrichie de deux nouveaux thread pour une communication client/serveur pour manipuler chacun des environnments respectifs.
Soit du côté client pour manipuler les donnée du cleint et côté serveur pour manipuler les donnée côté serveur.
par donnée, je parle de d'un environnement concernant le client et un univvers concernant le serveur.
On a deux connexions établies entre un client et un serveur ; Une ligne de commande et une ligne de traitement de donnée.
 
Reste la manipulation de donnée et la mise en correlation du réseau de neurones avec la manipulation de donnée.
A+

Bonjour,
Je suis à la recherche d'un colaborateur pour tester cyborg en connexion distant.
Pour le moment j'exploite en local.
Je cherche donc quelqu'un avec Gnu/Linux, le programme n'étant pas porté sur MS, avec un compilateur GNAT, avec qui je pourais tester une connexion distante.
Il est préférable d'avoir un nom de domaine sur la machine hote de cyborg ou une addresse fixe.
Normalement vous pouvez d'hors et déjà vous connecdter à 88.189.147.62.
Le programme utilise les ports 7851 et 7852.
 
Merci pour vortre contribution.

 
 
 
Tu ne comprends pas que c'est toi qui est à la ramasse ?
Instuis toi !
 
 
Bonjour,
 
Le truc avance.
Je suis en questionement concernant le traitement du langage naturel ou pas pour modéliser les objets.
Je me demande si le mieux ne serait encore un réseau de neurones artificiels.
 
Admettons que je manipule une base de données.
Comment passer des sorties du réseau à l'action intra programme sur un univers OO ? ou une requête sur une base de données ?
Le mieux ou un truc qui va bien ?
 
Vous feriez comment ?
 
 
Je flood et pourtant un seul message ! What else.

Je l'avais déjà reconnu sur son topic de sa fonction en rapport avec une chaîne de caractères saisie Style inimitable ! La tournure que prend ses topics aussi : souvent ça se termine avec des posts où Jovalise se répond à lui-même.

Nempêche que c'est instuctif, surtout quand on est à la ramasse

Jovalise, il me semble que je t'avais déjà fait cette remarque : tu pars souvent sur des algos foireux, reposant sur aucun base théorique pour des domaines qui sont pourtant forts complexe (IA et traitement naturelle du langage).
D'autant plus que ces sujets ont fait de grosses avancées ces dernières années. Tu devrais te familiariser avec les algos de ces 2 domaines. L'analyse LL, ça te parle, par ex ? Le machine learning ?
Au passage, pour gérer un dialogue en langage naturel entre un humain et une machine, c'est pas avec un simple PC (même un bien musclé) que tu y arriveras. Pas assez de puissance de calcul ni de stockage Faut bien en avoir conscience.

 
Toi tu discute avec rufo je te rappelle le reglement :

 
A priori tu ne comprends pas, je t'ai fait signe dans une autre topic, aurevoir.

Bonjour,
 
Je reformule mon problème ici pour aigueiller un peu le sujet.
 
On se trouve dans un environnemlent orienté objet pour du traitement du langage naturel.
Si vous connaissez un peu les base de la cybernetique, le sujet ici, la cybernetique se défini en 4 points :
 
- la liaison,
- la régulation,
- la finalization,
- la reproduction.
 
Ceci devant modéliser un système de la classe des système en 10 niveau nous nous intérésson ici aux système à imagination c'est tout l'objectif de mon programme.
 
Donc nous somme dans un environment objet, on resoit des requête dans un lanange L et nous devons modéliser le discours.
L'apprentissage, puisque rufo en parle constitu une phase importante pour l'adaptation ou pas d'un système à sont environment.
C'est pour cette raison que je travaille avec un réseau de neurones pour dans un premier temps apprendre bètement un langage.
Dans un second temps donc, j'envisage d'utiliser un second réseau de neurones pourcette fois modéliser l'objet du dialogue entre l'homme est la machine via un environnment programmer dans une orientation objet,
Mon problème ici est de passer des sortie du dis réseau soit un langage M à la manipulation des objets intra programme.
Peut-être est-ce fastidieux au quel cas on fera appel à l'informatiique pour effectuer le travail final.
Mais ici, c'est une question d'analyse et de décision aux quelle je souhaite aboutir.
 
Merci pour votre compréhension, le sujet est ouvert à chacun dans le respect des regle du forum.
 

 
Je crois qu'il cherche sincèrement à être sympa avec toi et t'aider à t'améliorer, ce qui démontre chez lui une patience impressionnante.  
Ce n'est pas très malin d'envoyer bouler la seule personne qui accorde de l'intérêt à tes divagations (vu qu'à l'évidence il t'a lu). Tu devrais y penser. Dans le respect des règles du forum .

Ah !
 
rufo alors pardon.
 
Poursuis j'ai mis à jour !

Perso je me moque mais je trouve le sujet très intéressant.
 
Tu veux traiter un ensemble très complexe en le divisant en tâches plus simples.
 
Hors ces tâches plus simples sont déjà d'une complexité énorme; Je prends l'exemple de la reconnaissance de language naturel:  
Effectivement Apple/Google (pour ne citer qu'eux) se basent sur les réseau de neurones pour leurs produits. Ils ont dépensé (et dépensent encore) des sommes faramineuses dans les labos de recherche sur ces sujets et ne font qu'effleurer du doigt le passage du langage au concept.
Et pour l'apprentissage de leurs réseaux ils ont des fermes de machine GPGPU.
Dans ton cas il va te manquer:
- L'architecture du réseau neuronal
- Les bases de données pour son apprentissage
- La puissance de calcul pour son apprentissage
 
Et ce n'est qu'une partie infime du problème épineux que tu te poses.
 
Enfin bref, c'est beau de ne pas s'avouer vaincu devant la complexité d'un problème, mais il faut au moins en avoir une vison réaliste.

- Et !
Par politesse mais sur un fil qui n'exista pas en réalité, fait très attention à ta prochaine requête !

Quoté pour la postérité. Qui sait, peut être qu'un jour la science trouvera un sens à cette phrase ?

Pour répondre mais autrement parce que je suis pas venu détruire ce que je construit !
 
L'architecture de neuronne je l'ai c'est pas ce qui manque.
Mon programme n'a pas besoin de base de donnée pour apprendre les donnée ça sert pas à enseigner mais à manipuler des fonction.
La puissance de calcule, ben lvraiment, je suis pas pressé. Ch (C) Switzerland 2016

Un programme d'IA sans BD contenant son apprentissage (donc ce qui permet de donner des valeurs aux aux différentes entrées de chaque neurone du réseau), tu vas pas aller bien loin
 
Pour la puissance de calcul, quel intérêt si ton programme fournit une réponse dans plusieurs semaines voire mois (années ?) quand un humain lui pose une question ou lui adresse un message. L'utilisateur se sera barré bien avant d'avoir la réponse...
 
As-tu conscience du volume de calculs qu'un programme d'IA un minimum évolué doit faire (a fortiori s'il fonctionne en langage naturel)

Bon c'est vrai que je ne par pas de rien.
J'ai pas besoin de puissance, je compte sur la maitrise.
 
 
D'abord mon cyborg est au moins un compatible IBM PC, ce qui n'est pas rien pour le moment, j'espère investir dans un super dans quelque année, après fortune pour terrasser le manque de sens de la vie.
 
C'est mon objectif m'implémenter dans une machine.
 
C'est de la projection, au jourd'hui j'apprend à programmer, des programme des hommes des ia. Et oui, j'en suis pas à ma première.
 
Un réseau de neuronne de quelque centaine de noeud et peut-être plus puissant que toi, je comprends que tu n'arrive pas à prendre conscience de la simpliciter de la vie par le fait qu'un processus respect un principe et des procesus des règles.
La société, c'est complexe, mais bon, en étudiant ça s'explique.
L'ia, c'est pas une affaire de ... je peux y passer des heure à vous expliquer l'innexplicable ça ser à rien je préfaire programmer.
Savoir !
C'est une affaire de vittesse d'ouverture et de fermeture des entrée et sorties d'un flux énergétique.
Voilà !
What else !
 
On parle bien d'électronique la, de communication, de langage, de morphose, ... bref le prédicat c'est on.
Si vous êtes pas d''accord vous pouvez le dire.
Mais moi, je préfaire poser des question !
Si tu veux rufo on fait ton analise ou l'analyse de ce que tu as.
J'observe ce que tu fais ! Merci de rester courtois et reativement, humble, on as tous des connaissance on as tous un cerveau, ne prends pas les autre pour des ignorant.
Je connais pas mal de chose en info depuis 25 ans. et j'ai d'otre bagage.
Mais surtout, j'ai une idée, un objectif des moyens, une volonter de l'energie et du temps.
ça me fait jouir et lorsque je jouie, je me transforme, et les transformation successive me font penses des réagir dans ce stupide univers !
Avec l'info, j'espère mettre de l'odre pour rester un Homme droit
 
signature tiens : c'est localghot (C) alias Manuel De Girardi.

 
 
Je suis perdu entre h2hub et rufo, je suis perdu dans le dialogue en plus y en a un qui m'a énervé... Bref,
 
D'ésolé si c'est décousu pour l'internaute.
 
Bref, ouias h3hub, t'as raison.
 
Mais t'as toute l'idée maintenant.
Si non je poursuis je philosophe depuis dix ans sur la cyb, la société, l'ia, les technologies d'ia, je suis pas au courant de ce que vous faite j'analise avec Ada, c'est tout.
 
Je vous aime bien....

Ah oui !
 
Ah non !
 
En fait h3bus, si tu te souviens j'ai travailler sur un programme qui ce compile lui même, je trarvaille sur un programme qui s'exécute lui même, et sur un qui se programme lui même, Archman ou gnuarchman exactement fait partie de ce projet enfin les deux programme cyborg et archman sont un seul projet.
 
Archman est sensé être l'interface originale, et cyborg l'environnment du peer process, ... L'utilisateur.
A ça doit s'agouter la partie edition des sources du système de compilation.
 
L'environnemt est donc la modélisation d'un discours OO.
C'est l'objet de l'imagination qui est une procédure sur l'environnment.
Archman permetra de relier l'homme à la l'environnment. c'est la liéaison dans la cybernetique.
La partie exécution est celle de la régulation des ouverture, puisque je suis là, des entrées et sortie des flux énergétique.
Ca prend de l'énergie, si non ça ne fonctionne pas.
C'est ce qui fait que c'est piloté. D'habitude c'est l'homme qui est piloté par l'environnement, La comme on inverse le mécanisme, c'ests l'environnment l'hote de la cible dans le système de compilation, qui est piloté. L'homme reste donc piloté, mais change de corp si je puis dire. C'est une question d'équivalence des élémant naturel de la morphose de l'univers.
Ce qui est programmer de viens programme et ça boucle sur une sémantique à déterminer, pour faire un court circuit. Faire tourner un moteur électrique etc.
 
On abouti à la finalisation qui est le réflex.

Mais j'en suis au langage M qui doti piloter l'éditeur desources.
Je connais un lanage L qui donne un lanange L qui donne un langage M qui doit donnée un object O avec Ada.
 
Je parle francais
J'obtiens du français.
Je passe le français.
J'obtien un langage M
Pour obtenir un Objet O écrit avec Ada.
 
Whate else je crois que ça résume. Le programme deviens donc à chaque itération un nouvel Objet écrit avec Ada selon les entrées en français.
 
Vous causer un peu avec Ada j'espère....  
 
Comem ça je pourait aller à la pêche.

Nouveau main file pour fusionner Archman et Cyborg /dans ma tête..
 
Attention c'est long mais c'est beau la bibliothèque et très jolie également.
cat Adamanborg/Adamanborg/src/Adamanborg.adb  
 

---------------------------------------------------------
-- Adamanborg is evolved cybernetic organism with Ada. --
---------------------------------------------------------
-- This program speak french and english.              --
---------------------------------------------------------
-- Adamanborg (C) Copyright 2016 E. Sens               --
---------------------------------------------------------
-- This program is distributed under GPL.              --
---------------------------------------------------------
-- This program is writted with Ada                    --
-- language for Linux in terminal                      --
-- mode in 160 columns and 64 lines or                 --
-- 80 columns and 25 lines or                          --
-- 211 columns and 78 lines or                         --
-- on X Window system.                                 ----------------------
--                                                                         --
-----------------------------------------------------------------------------
--                                                                         --
-- This program is free software: you can redistribute it and/or modify
-- it under the terms of the GNU General Public License as published by
-- the Free Software Foundation, either version 3 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- GNU General Public License for more details.
--
-- You should have received a copy of the GNU General Public License
-- along with this program.  If not, see <http://www.gnu.org/licenses/>.
--                                                                         --
-----------------------------------------------------------------------------
-- Author       : Manuel De Girardi                                        --
-- Date         := 2016-04-20 03:20:00  ; 
-- Project name : Adamanborg                                               --
-- Version      := 2016.04.20.03.20.00a ; 
-- Description  : This program is writed over Gnu/Linux with Ada.          --
-----------------------------------------------------------------------------
-- Synopsis :
--
--            Adamanborg [OPTIONS]
--
-- OPTIONS :
--           -h :
--           -q [Quiet] :
--           -x :
--           -v :
--           -w | -W : 
--           -f Train_Filename : 
--           -R L1 rem network filename : 
--           -r L2 rem network filename : 
--           -l Lexic_Filename : 
--           -m Max_Epoch : 
--           -M Max_Epoch : 
--           -c Converged : 
--           -C Converged :
--           -i max iteration : 
--           -I max iteration : 
--           -n [Reuse L1 network file] : 
--           -N [Reuse L2 network file] : 
--           -U Univer_Filename : 
--           -s Max_Sample : 
--           -S Max_Sample : 
--           -e User_Name : 
--           -H hostname : 
--           -P [Self_Programming] : 
--           -p [Load_Manpages] : 
--           -d delay to obtain an repsonse : 
--           -t Input_Text : 
 
--
-- Where :
--
--           -h :
--                is help call ;
--
--           -q [Quiet] :
--                is quiet call :
--
--           -x :
--                is X mode call ;
--
--           -v :
--                is version call ;
--
--           -w | -W : 
--                is wide or extra Wide term call ;
--
--           -f Train_Filename : 
--                is original train file for L1 ;
--
--           -R L1 rem network filename : 
--                is name of network file for L1 ;
--
--           -r L2 rem network filename : 
--                is name of network file for L2 ;
--
--           -l Lexic_Filename : 
--              is name of Lexic;
--
--           -m Max_Epoch : 
--               is max epoch for L1
--
--           -M Max_Epoch : 
--               is max epoch for L2
--
--           -c Converged : 
--               is conerged for L1
--           -C Converged : 
--               is conerged for L2
--
--           -i max iteration : 
--               is max iteration for L1 ;
--
--           -I max iteration : 
--               is max iteration for L2 ;
--
--           -n [Reuse L1 network file] : 
--               is BOOLEAN value for to reuse L1 network file ;
--
--           -N [Reuse L2 network file] : 
--               is BOOLEAN value for to reuse L2 network file ;
--
--           -U Univer_Filename : 
--               is name if backup of Imaginary ;
--
--           -s Max_Sample : 
--               is Max sample for L1 ;
--
--           -S Max_Sample : 
--               is Max sample for L2 ;
--
--           -e User_Name : 
--               is logname of user ;
--
--           -H hostname : 
--               is remote hostname ;
--
--           -P [Self_Programming] : 
--              is BOOLEAN value for a self programming processing ;
--
--           -p [Load_Manpages] : 
--              is BOOLEAN to load manpages if available ;
--
--           -d delay to obtain an repsonse : 
--              is the max duration to respond to request ;
--
--           -t Input_Text : 
--              is the initial input request to be passed to process.
--
-----------------------------------------------------------------------------
with Adam.Adaborg;
with Adam.Main;
use Adam;
 
procedure Adamanborg is
   
   Success : Boolean := False;
   Error   : Error_Enum_Type := Program_Success;
   Errno   : Errno_Tagged_Type := Default_Errno;
   
begin
   
   while not Success loop
      
      declare
         
         Cyborg  : Adaborg.Cyborg_Access := 
           
           new Adaborg.Cyborg_Tagged_Type;
           
      begin
         
         
         Cyborg.Initialize
           
           (
            
            Default_Errno => Errno,
            
            Success_Message => "program succeed."
              
           );
         
         
         Errno := Adaborg.Adarchmanborg
           
           (
            
            Borg => Cyborg,
            
            Options_Kit => Adam.Main.Get_Options_From_Command_Line,
            
            Exit_Status  => Error
              
           );
         
         if Errno /= Cyborg.Default_Errno then
            Error := Adam.Main.Resolve_Error(Errno);
            raise Program_Error;
         end if;
         raise Adam.Success;
      exception
         when Program_Error =>
            case Error is
               when Program_Success =>
                  raise;
               when Specification_Error  =>
                  Adam.Main.Usage_Print(Errno);
               when Implementation_Limit =>
                  Adam.Main.Help_Print(Errno);
            end case;
         when Adam.Success =>
            Success := Adam.Main.Program_Quit(Errno);       
      end;
      
   end loop;
   
end Adamanborg;

 
Le programe complet est sur Sourceforge à projects/adamanborg
 
Ca compile ça s'exécute ...

 
ça termine, et c'est documenté !
 
La version est la date d'archivage à peut près c'est pas pratique de savoir de quoi on parle.
C'est la version a-0.0.3.
Comme ça c'est rigolo, mais à implémenter je vais me régaler.
 
Edit : pour la performance..

Ah tien j'ai un paremetre de fonction en mode in out...
 
Volià :
 

j'ai commencé par le fichier principal.
A présent j'ai traité les arguments en ligne de commande.
 

 
 
Le code est commenté un peu pour une fois.
(c'est que j'ai pas envis d'être paumé dans 2 mois).
 
Venez voir comme c'est jolimant fait !
 
 
Le type Parameter_Tagged_Record_Type :

type Parameters_Flags_Enum_Type is
     
     (
      Nul_Parameter,
      Help,
      Quiet,
      Graph_geometry,      
      Version,
      Old_Geometry,
      Linux_Geometry,
      wide_Geometry,
      Train_Filename,
      L1_Network_Filename,
      L2_Network_Filename,
      Lexic_Filename,
      L1_Max_Epochs,
      L2_Max_Epochs,
      L1_Converged,
      L2_Converged,
      L1_Max_Iteration,
      L1_Reuse_Network,
      L2_Reuse_Network,
      Univers_Filename,
      L1_Max_Samples,
      L2_Max_Samples,
      Username,
      Hostname,
      Self_Programming,
      Load_Manpages,
      Delay_For_Response,
      Input_Text
        
     );
   
   type Parameter_Tagged_Record_Type (Requiered_Parameter : Boolean) is tagged
      record
         
         Is_Setted : Boolean := False;
         
         Parameter_Flag : Parameters_Flags_Enum_Type := Nul_Parameter;
         
         case Requiered_Parameter is
            when False =>
               null;
            when True =>
               Value : access Wide_String;
         end case;
      end record;
   
   
   type Parameters_Kit_Array_Type is 
     array (Parameters_Flags_Enum_Type) of 
     access Parameter_Tagged_Record_Type;
   
   
   Default_Parameters : Parameters_Kit_Array_Type :=

 
Si vous connaissez un peu Ada merci pour votre retour.

J'ai bossé plussieurs fois pour rien, des truc que j'avais oubliés, bref.
 
Mais la version 0.1.0 intègre Cyborg dans Gnuarchman en mode textuel.
Le mode graphique est à labour.
Loin, d'être terminé, donc.