bonjour,
J'ai des difficultés à trouver la raison pour laquelle mon programme ne fonctionne pas comme je le souhaite, c'est pourquoi je viens vous demander votre aide.
Il s'agit d'une petite recherche de bit dans un mot de 4 bits pour faire en suite des ou entre modulo.
C'est écrit avec Ada.

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
 
with Ada.Text_Io;
use Ada;
with Generic_Extended_Binary_Code;
with PragmARC.REM_NN_Wrapper;
procedure Asimov is
 
   Max_Bits : constant Positive := 4;
 
   type Asimov_Type is mod 2**Max_bits;
 
   type String_Access is access all String;
 
   type Bit_Index_Type is new Natural range 0..Max_Bits-1;
 
   for Asimov_Type'size use Max_bits;
 
   package Asimov_Binary_Code is new Generic_Extended_Binary_Code(Asimov_Type);
 
   use Asimov_Binary_Code;
 
   use PragmARC.REM_NN_Wrapper;
 
   function Asimov_Function(Loi : in Asimov_Type) return Asimov_Type is
 
      Code : T_Code := Code_Of(Loi);
 
      Item : Asimov_Type := 0;
 
   begin
      if Code((Natural(Loi)/2)+1) = 1.0 then
         Text_Io.Put("True");
         return (item);
      else
         Text_Io.Put("False");
         return ((Loi)/2)+1;
 
      end if;
   end Asimov_Function;
 
   Asimov_Code : T_Code := Code_Of(15);
 
begin
 
   while Item_Of(Asimov_Code) = 15  loop
 
  Main :
      for Asimov in Asimov_Type loop
         declare
            Code : T_Code;
         begin
            Code := Code_Of(Asimov);
            Text_Io.Put("item of code ");
            for Bit in Code'Range loop
               if Code(Bit) = 1.0 then
                  Text_Io.Put("1");
               elsif Code(Bit) = 0.0 then
                  Text_Io.Put("0");
               else
                  Text_Io.Put("erreur");
                  exit Main;
               end if;
            end loop;
            Text_Io.Put_Line(" is : " & Asimov_Type'Image(Item_Of(Code)));
         end;
      end loop Main;
 
      Asimov_Code := Code_Of((Asimov_Function(0) or Asimov_Function(1) or Asimov_Function(2) or Asimov_Function(3) or
                                Asimov_Function(4) or Asimov_Function(5) or Asimov_Function(6) or Asimov_Function(7)));
 
      Text_Io.New_Line;
      Text_Io.Put_Line("Item of Asimov : " & Asimov_Type'Image(Item_Of(Asimov_Code)));
   end loop;
end Asimov;
Donc, je cherche à faire une boucle qui vérifie une fonction Asimov_Fonction qui doit retourner le un mot de 4 bits vérifiant la somme des loi de 0 à 7.

Voici ce qu'affiche ce programme.
item of code 0000 is : 0
item of code 0001 is : 1
item of code 0010 is : 2
item of code 0011 is : 3
item of code 0100 is : 4
item of code 0101 is : 5
item of code 0110 is : 6
item of code 0111 is : 7
item of code 1000 is : 8
item of code 1001 is : 9
item of code 1010 is : 10
item of code 1011 is : 11
item of code 1100 is : 12
item of code 1101 is : 13
item of code 1110 is : 14
item of code 1111 is : 15
FalseFalseFalseFalseFalseFalseFalseTrue
Item of Asimov : 7
Donc les 7 première lois sont vérifier mais pas la huitième. je cherche à écrire la fonction Asimov_Fonction qui vérifiera les 8 lois.