IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Algorithmes et structures de données Discussion :

mot binaire et modulo.


Sujet :

Algorithmes et structures de données

  1. #1
    Invité
    Invité(e)
    Par défaut mot binaire et modulo.
    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.

  2. #2
    Invité
    Invité(e)
    Par défaut une solution.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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.

  3. #3
    Invité
    Invité(e)
    Par défaut
    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.

  4. #4
    Invité
    Invité(e)
    Par défaut
    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.

  5. #5
    Expert confirmé Avatar de DonQuiche
    Inscrit en
    Septembre 2010
    Messages
    2 741
    Détails du profil
    Informations forums :
    Inscription : Septembre 2010
    Messages : 2 741
    Points : 5 485
    Points
    5 485
    Par défaut
    Citation Envoyé par jovalise Voir le message
    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) + ...

  6. #6
    Invité
    Invité(e)
    Par défaut
    Des décalage donc, merci je vais tester ça.

  7. #7
    Invité
    Invité(e)
    Par défaut
    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.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. convertion d'un mot binaire en une couleur sous matlab
    Par Por Qué dans le forum Images
    Réponses: 5
    Dernier message: 20/08/2013, 01h02
  2. alignement de mots binaires
    Par mathieu.desprez dans le forum VHDL
    Réponses: 0
    Dernier message: 02/04/2013, 17h01
  3. Ecriture mot binaire
    Par Condor7 dans le forum C
    Réponses: 6
    Dernier message: 16/07/2004, 13h39

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo