mot binaire et modulo.

Version imprimable

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:

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.

Citation:

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.

une solution.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
function Asimov_Function(Loi : in Asimov_Type) return Asimov_Type is
      Code : T_Code := Code_Of(loi);
   begin
      if Code(Positive(Loi/2+1)) = 1.0 then
         Text_Io.Put("True");
         return Asimov_Type(2**(Positive(Loi/2+1))-1);
      else
         Text_Io.Put("False");
         return 15;
 
      end if; 
   end Asimov_Function;

A non, je me plante encore à mon avis. Je suis perdu.

12/03/2014, 05h04
Invité

Tout ça pour le résoudre par réseau de neurone.
J'ai oublié ce que je voulais faire entre temps mais ça va revenir.

Merci en tout cas, ça m'a permit de bosser un peu les modulo et la logique.
12/03/2014, 07h09
Invité

Re bonjour, je suis désolé je reviens pour poser une question connexe.

J'ai une variable qui prend les valeur 1 3 7 15 je voudrait faire de l'arithmétique pour trouver 0 pour 1, 1 pour 3, 2 pour 7, et 3 pour 15.

Si vous avez le temps. Merci pour votre aide.
12/03/2014, 13h11
DonQuiche

Citation:

Envoyé par jovalise

Re bonjour, je suis désolé je reviens pour poser une question connexe.

J'ai une variable qui prend les valeur 1 3 7 15 je voudrait faire de l'arithmétique pour trouver 0 pour 1, 1 pour 3, 2 pour 7, et 3 pour 15.

Si vous avez le temps. Merci pour votre aide.

Bonjour. Je n'ai peut-être pas correctement compris le problème mais....
r = ((n >> 1) & 1) + ((n >> 2) & 1) + ((n >> 3) & 1) + ...
12/03/2014, 18h47
Invité

Des décalage donc, merci je vais tester ça.
12/03/2014, 19h42
Invité

j'y suis pas parvenu, j'ai compris que c'étaient des décalage à droite.

Par contre après je suis obligé de passer en 8 bit pour faire des décalage, j'arrive pas à trouver de combien.
J'obtiens toujours 0.