Discussion :

[Invité]

Bonjour, meilleurs voeux.
J'ai un projet énorme, un système de niveau 9, voir pire.
C'est de I.A., mais c'est pas si compliqué, mais c'est énorme pour mon cerveau.
Je viens essayer de faire le point, et d'obtenir éventuellement de l'aide pour l'architecture de ce système avec Ada, tout est la.
C'est pas toujours très clair, mais je pense que tout ce tiens un minimum.


[Je dois] 'modéliser' (une architecture) generic multi_couche de nombre_de_couches variable positif de {discours et liste_de réseaux_de_neurones et dictionnaire_à_mots_permutable}

un utilisateur en langage naturel est une liste de RdN, un discours (ascii), et un dictionnaire.
Chaque discours doit passer par tous les réseau selon l'ordre des couche de code (langage).


Sachant que tout ça, est un système client/Serveur

(Je reviendrais, j'ai le cerveau qui chauffe).

[Invité]

j'ai commencer à modéliser un peu... En espérant que ça vous éclaire sur mes intentions.
Finalement, pas de généricité, je souhaite pouvoir créer des langage à la volé.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
with Ada.Strings.Unbounded;
package Machina is
 
   -- Création de système linguisique --
   -- 'Length' est la taille de l'alphabet ;
   -- 'Name' est le nom du système.
   procedure Create_System(Length : in Positive; Name : in String);
 
   -- Si un système porte déjà le nom donné, on lève une exception ;
   Name_Exist : exception;
 
   -- Les mots sources sont représentés par des tableaux de positifs.
   type T_Positive_String is array (Positive range <>) of Positive;
   type T_Positive_Word(Length : Positive) is
      record
         Positive_String : T_Positive_String(1..Length);
      end record;
 
   -- Création d'un mot d'un système --
   -- 'Item' est la représentation du mot ;
   -- 'Name' est le système auquel appartien le mot.
   procedure Create_Word(Word : in T_Positive_Word; Name : in String);
 
   -- Si l'alphabet utiliser dans word à la création d'un mot est en dehors
   -- de la borne supérieur de l'alphabet, on lève une exception ;
   Out_Of_Range : exception;
 
   -- Pour la conversion Ascii à T_Positive_Array ;
   function To_Machina(Source : in String) return T_Positive_Word;
 
private
 
   -- Une lettre est codé par un tableau binaire.
   type T_Binary_Code is array (Positive range <>) of Boolean;
   type T_Letter(Width : Positive) is
     record
        Code : T_Binary_Code(1..Width);
     end record;
 
   -- on accède au lettres par référence à l'alphabet.
   type Letter_Access is access T_Letter;
 
   -- L'aphabet contient toute les lettres d'un système linguistique.
   type T_Alphabet is array (Natural range <>) of Letter_access;
 
   -- Toute les lettres d'un mot sont dans l'alphabet.
   type T_Valid_Letter is access
     function(Index : in Positive; Name : in String) return Letter_Access;
 
   -- Les mots codés d'un système sont représentés par des tableaux
   -- de lettres de l'alphabet.
   type T_Alpha_Beta_code is array (Positive range <>) of T_Valid_Letter;
   type T_Coded_Word(Length : Positive) is
      record
         Alpba_Beta_Code : T_Alpha_Beta_Code(1..Length);
      end record;
 
   -- Pour convertir les mots sources en mots codés.
   function To_Coded_Word(Source_Word : T_Positive_Word) return T_Coded_Word;
 
 
   -- Un système linguistique est un alphabet.
   type T_System(Length : Positive) is
      record
         Alpabet : T_Alphabet(1..Length);
         Name    : Ada.Strings.Unbounded.Unbounded_String;
      end record;
 
end Machina;

[Invité]

Bonjour ; Voici mon code ce matin.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
package Machina is
   -- Les mots sources sont représentés par des tableaux de positifs.
   type T_Positive_String is array (Positive range <>) of Positive;
   type T_Positive_Word(Length : Positive) is
      record
         Positive_String : T_Positive_String(1..Length);
      end record;
 
   subtype T_System_Name is String(1..16);
 
   task Life_Cycle is
 
      -- Démmarer et redémmarer le service après une suspension.
      entry Start;
 
      -- Suspendre le service.
      entry Suspend;
 
      -- Terminer le processus.
      entry Halt;
 
      -- Création de système linguistique --
      -- 'Length' est la taille de l'alphabet ;
      -- 'System_Name' est le nom du système.
      entry Create_System(Length : in Positive; System_Name : in T_System_Name);
 
      -- Création d'un mot d'un système --
      -- 'Word' est la représentation du mot ;
      -- 'System_Name' est le système auquel appartient le mot.
      entry Create_Word(Word : in T_Positive_Word; System_Name : in T_System_Name);
 
      -- Création d'un utilisateur --
      -- 'User_name' est un nom unique.
      -- System_Name est le système utilisé par l'utilisateur.
      entry Create_User(User_Name : in String; System_name : in T_System_Name);
 
   end Life_Cycle;
 
   -- Si l'alphabet utilisé dans word à la création d'un mot est en dehors
   -- de la borne supérieur de l'alphabet, on lève une exception ;
   Out_Of_Range : exception;
 
   -- Si un système porte déjà le nom donné à la création d'un système,
   -- on lève une exception ;
   System_Exist : exception;
 
   -- Si un utilisateur porte déjà le nom donné à la création d'un utilisateur,
   -- on lève une excpetion ;
   User_Exist : exception;
 
   -- Pour la conversion Ascii à T_Positive_Array ;
   function To_Positive(Source : in String) return T_Positive_Word;
 
end Machina;

Je cherche maintenant, le moyen de traiter chaque utilisateurs en parallèle.

[Invité]

Voila ce que donne ma spécification... Au final peut-être.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
package Machina is
 
   -- Les mots sources sont représentés par des tableaux de positifs.
   type T_Positive_String is array (Positive range <>) of Positive;
 
   -- Pour le nommage des systèmes linguistiques.
   subtype T_System_Name is String(1..16);
 
   -- L'unité de traitement parallèle pour chaque utilisateur;
   type T_Machina is limited private;
 
   task Life_Cycle is
 
      -- Démmarer et redémmarer le service après une suspension.
      entry Start;
 
      -- Suspendre le service.
      entry Suspend;
 
      -- Terminer le processus.
      entry Halt;
 
      -- Création de système linguistique --
      -- 'Length' est la taille de l'alphabet ;
      -- 'System_Name' est le nom du système.
      entry Create_System(Length : in Positive; System_Name : in T_System_Name);
 
      -- Création d'un mot d'un système --
      -- 'Word' est la représentation du mot ;
      -- 'System_Name' est le système auquel appartient le mot.
      entry Create_Word(Word : in T_Positive_string; System_Name : in T_System_Name);
 
      -- Création d'un utilisateur --
      -- 'User_name' est un nom unique.
      -- System_Name est le système utilisé par l'utilisateur.
      entry Create_User(User_Name : in String; System_name : in T_System_Name);
 
      -- Obtenir une connection --
      -- 'User_Name' est le nom de l'utilisateur demandeur de la connection.
      -- 'System_Name' est le système linguistique utilisé par le demandeur.
      -- 'Recipient' est l'utilisateur cible de la connection.
      -- 'Cross_Name' est le système linguistique d'lutilisateur cible.
      entry Connect_User(User_Name : in String; System_Name : in T_System_Name;
                         Recipient : in String; Cross_Name  : in T_System_Name;
                         Treatment_Unit                     : out T_machina);
 
   end Life_Cycle;
 
   -- Si l'alphabet utilisé dans word à la création d'un mot est en dehors
   -- de la borne supérieur de l'alphabet, on lève une exception ;
   Out_Of_Range : exception;
 
   -- Si un système porte déjà le nom donné à la création d'un système,
   -- on lève une exception ;
   System_Exist : exception;
 
   -- Si un utilisateur porte déjà le nom donné à la création d'un utilisateur,
   -- on lève une excpetion ;
   User_Exist : exception;
 
   -- Si un des deux utilisateurs donnés à la demande de connection est inconnu
   -- du système,on lève une exception ;
   No_User : exception;
 
   -- Si un des deux systèmes linguistiques donnée à la connection est inconnu
   -- du système,on lève une exception ;
   No_Systeme : exception;
 
   -- Un support d'information est une liste de mots d'un système linguistique.
   type T_Word_List is private;
 
   -- Pour construire une liste de mots.
   procedure Constructor(Word_List : in out T_Word_List;
                         Word      : in T_Positive_String);
 
   -- Pour connaitre la taille d'un liste.
   function Length(Word_List  : in T_Word_List) return Natural;
 
   -- Pour extraire les mots d'une liste de mots.
   function Extract_Word(Word_List  : in T_Word_List;
                         Index      : in Positive) return T_Positive_String;
 
   -- Si index est supérieur à la longueur de la liste, on lève une exception ;
   Index_Error : exception;
 
   -- Procéder au traitement de l'information.
   -- Substrat est modifier pour contenir le résulat.
   procedure Proceed(Machina : in out T_Machina; Substrat : in out T_Word_List);
 
   -- Pour la conversion Ascii à T_Positive_Array ;
   function To_Positive(Source : in String) return T_Positive_String;
 
   -- Pour la convertsion de Positive_String à ascii.
   function To_String(Source : in T_Positive_String) return String;
 
private
 
 
   type T_Positive_Word(Length : Positive) is
      record
         Positive_String : T_Positive_String(1..Length);
      end record;
 
   type T_Word_Node(Length : Positive);
   type Word_Node_Access is access T_Word_Node;
   type T_Word_Node(Length : Positive) is
      record
         Word       : T_Positive_Word(Length);
         Prev, Next : Word_Node_Access;
      end record;
 
   type T_Word_List is
      record
         Root  : Word_Node_Access;
         Count : Natural;
      end record;
 
   type T_System;
   type System_Access is access T_System;
   type T_Machina is limited
      record
         Source      : System_Access ;
         Destination : System_Access ;
      end record;
 
end Machina;

[Invité]

Bonjour,

Pour modéliser mon système de neuvième niveau, je souhaiterais le décomposer comme suit :

# Finalization ; qui dépend de
# Decision ; qui dépend de
# Imagination ; qui dépend de
# Memorization.

Et je souhaiterais que seul le paquetage Finalization soit visible à l'utilisateur.
J'ai donc l'idée de déclarer privé les paquetage desquels dépend Finalization et de faire des paquetage enfant.
Ce qui me ferait un nom à ralonge : Memorization.Imagination.Decision.Finalization ;
J'ai donc idée de renommer ce dernier pour plus de lisibilité.

Est-il possible de faire mieux, autrement ?
Qu'en pensez-vous ?
S'il vous plait ?
Merci.