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

 C Discussion :

Utilisation des operateurs logiques en C99.


Sujet :

C

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre éclairé Avatar de JulieCarree
    Homme Profil pro
    Inscrit en
    Juin 2012
    Messages
    50
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Juin 2012
    Messages : 50
    Par défaut Utilisation des operateurs logiques en C99.
    Bonjour,
    j'ai fait une petit programme pour tester les operateurs logiques en C99,
    je poste la partie qui alimente les deux entrees d'une eventuelle porte logique,
    j'aurai voulu avoir vos avis et critiques et si je merite l'excommunication .
    le programme est compilable tel quel et affiche le tableau ci-dessous:

    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
    ----------------
    |binaire| deci |
    ----------------
    | 0 | 0 |  0   |
    ----------------
    | 0 | 1 |  1   |
    ----------------
    | 1 | 0 |  2   |
    ----------------
    | 1 | 1 |  3   |
    ----------------
    | 0 | 0 |  4   |
    ----------------
    | 0 | 1 |  5   |
    ----------------
    | 1 | 0 |  6   |
    ----------------
    | 1 | 1 |  7   |
    ----------------
    pas taper SVP

    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
    /*   oscil.c
    compteur binaire sur deux bits
     
     14 Avril 2013
     JulieCarree
     
    *****************************************************************
    *    commande compile : gcc -std=c99  -Wall oscil.c -o oscil    *
    *    commande execute : ./oscil                                 *
    *****************************************************************
    */
     
    #include <stdio.h>
    #include <stdbool.h>
     
    bool TAU ( bool bit_0, bool bit_1);      /* Tautologie               */
    bool CTR ( bool bit_0, bool bit_1);      /* Contradiction            */
    void oscilateur_2bits ( bool *bit_0, bool *bit_1, size_t compt );
     
    int main (void)
    {
            const char ligne[] = "----------------\n";
            const char titre[] = "|binaire| deci |\n";
            size_t compt = 0;
            bool bit_0 = false;
            bool bit_1 = false;
     
            printf ( "\n%s%s", ligne, titre );
            for ( compt =0; compt < 8; ++compt )
            {
                    printf ( "%s", ligne );
                    oscilateur_2bits ( &bit_0, &bit_1, compt );
                    printf ( "| %d | %d |  %d   |\n", bit_1, bit_0, compt );
            }
     
            printf ( "%s", ligne );
            return 0;
    }
     
    /********************************/
     
    /****************/
    void oscilateur_2bits ( bool *bit_0, bool *bit_1, size_t compt )
    {
            compt %= 4;
            if ( compt == 3 )
                    *bit_0 = *bit_1 = TAU ( bit_0, bit_1 );   /* 1 1 */
     
            if ( compt == 2 )
            {
                    *bit_0 = CTR ( bit_0, bit_1 );            /* 1 0 */
                    *bit_1 = TAU ( bit_0, bit_1 );
            }
     
            if ( compt == 1 )
            {
                    *bit_0 = TAU ( bit_0, bit_1 );            /* 0 1 */
                    *bit_1 = CTR ( bit_0, bit_1 );
            }
     
            if ( compt == 0 )
                    *bit_0 = *bit_1 = CTR ( bit_0, bit_1 );   /* 0 0 */
     
            return ;
    }
     
    /****************/
    bool TAU ( bool bit_0, bool bit_1)   /*   (A NAND B) OR (A AND B)   toujours vrai   */
    {
            return ( bit_0 && bit_1 ) || !( bit_0 && bit_1 );
    }
     
    /****************/
    bool CTR ( bool bit_0, bool bit_1)   /*   (A OR B) AND (A NOR B)   toujours faux    */
    {
            return ( bit_0 || bit_1 ) && !( bit_0 || bit_1 );
    }
     
    /****************/

  2. #2
    Membre Expert
    Avatar de Metalman
    Homme Profil pro
    Enseignant-Chercheur
    Inscrit en
    Juin 2005
    Messages
    1 049
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Hauts de Seine (Île de France)

    Informations professionnelles :
    Activité : Enseignant-Chercheur
    Secteur : Enseignement

    Informations forums :
    Inscription : Juin 2005
    Messages : 1 049
    Par défaut
    Si c'est pour représenter des portes logiques... la solution... s'en rapproche en effet....

    C'est dommage la "bidouille" du compteur incrémenté avec un gros switch sur un modulo 4...
    Mais en même temps... pour descendre au bit près... je ne suis pas sûr que le C soit le plus adapté... donc ta méthode me parait correcte.

    Et évidemment... sans vraiment lire que tu veux simuler des portes logiques... on pourrait dire : "bah... fais que TAU renvoie true, et CTR false ! Pourquoi écrire des conditions si tu connais déjà les réponses ?!"
    Mais au moins... tu as du code qui exécute vraiment une logique !

    Bref : le C bosse plutôt sur du byte que du bit, et si tu veux VRAIMENT faire du low level "pratique", c'est plutôt côté VHDL et son équivalent européen (ou ricain) dont j'ai oublié le nom...
    Je suis fatigué, mais il est peut être possible de faire des trucs du genre si on réfléchit précisément à la formule :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
    compt  = compt & (bit1 * 2) & bit0;
    compt  = compt | (bit1 * 2) | bit0;
    --
    Metalman !

    Attendez 5 mins après mes posts... les EDIT vont vite avec moi...
    Les flags de la vie : gcc -W -Wall -Werror -ansi -pedantic mes_sources.c
    gcc -Wall -Wextra -Werror -std=c99 -pedantic mes_sources.c
    (ANSI retire quelques fonctions comme strdup...)
    L'outil de la vie : valgrind --show-reachable=yes --leak-check=full ./mon_programme
    Et s'assurer que la logique est bonne "aussi" !

    Ma page Developpez.net

  3. #3
    Membre éclairé Avatar de JulieCarree
    Homme Profil pro
    Inscrit en
    Juin 2012
    Messages
    50
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Juin 2012
    Messages : 50
    Par défaut
    merci Metalman
    tu as parfaitement saisis mon intention,
    mon idée était d'utiliser les opérateurs !, &&, || et oui j'ai reécrit NAND XOR etc ... avec les lois de la logique booleenne .

    pour les operateurs binaires, je compte implementer ça direct en asm (NASM) et m'inspirant de mon source en C. C'est le coté demonstration des theoremes qui m'interesse, malgrés mon petit niveau en math.

  4. #4
    Membre Expert
    Avatar de Metalman
    Homme Profil pro
    Enseignant-Chercheur
    Inscrit en
    Juin 2005
    Messages
    1 049
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Hauts de Seine (Île de France)

    Informations professionnelles :
    Activité : Enseignant-Chercheur
    Secteur : Enseignement

    Informations forums :
    Inscription : Juin 2005
    Messages : 1 049
    Par défaut
    Dans ce cas... si tu veux VRAIMENT vérifier ta logique et te faciliter le travail, tout en gardant du C...

    Refais des fonctions NAND, XOR, etc... en C (c'est chiant, pas très lisible... mais la logique suivra !)

    genre :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    bool my_nand(bool bit_a, bool bit_b)
    Et pour ton compteur qui fait varier les bits.... pffff... je me souviens avoir aidé un ami à refaire la multiplication et la division en VHDL (ou l'autre truc)... et on pouvait contrôler chaque bit, ce qui facilitait grandement la gestion du signe et tout....
    Mais dans ton cas... je "pense" qu'il faudrait faire une structure du genre :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    struct my_byte
    {
      bool bit_0;
      [...]
      bool bit_7;
    };
    Ou un tableau de bool... tu as testé bool[8] ? xD
    (je ne bosse pas en C99 personnellement)

    + implémenter les fonctions pour transformer un char en cette structure/tableau, un int en 4/8 structures/tableaux, etc... et l'inverse.
    Et bosser directement avec tout ça pour faire ta logique !
    (j'avais refais le chiffrement/déchiffrement DES avec un tableau d'int pour pouvoir bien suivre les explications de la FIPS)

    EDIT : je dis ça.... mais c'est sortir l'artillerie lourde pour écraser une mouche !
    Surtout que tu veux faire de l'ASM après, ce qui ne permet pas non plus de travailler aisément au bit près... et si tu réfléchis maintenant à la formule travaillant sur un byte, tu auras la réponse pour le C et l'ASM !
    --
    Metalman !

    Attendez 5 mins après mes posts... les EDIT vont vite avec moi...
    Les flags de la vie : gcc -W -Wall -Werror -ansi -pedantic mes_sources.c
    gcc -Wall -Wextra -Werror -std=c99 -pedantic mes_sources.c
    (ANSI retire quelques fonctions comme strdup...)
    L'outil de la vie : valgrind --show-reachable=yes --leak-check=full ./mon_programme
    Et s'assurer que la logique est bonne "aussi" !

    Ma page Developpez.net

  5. #5
    Membre éclairé Avatar de JulieCarree
    Homme Profil pro
    Inscrit en
    Juin 2012
    Messages
    50
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Juin 2012
    Messages : 50
    Par défaut
    Encore merci pour toutes les voies que tu me proposes, là j'ai du boulot pour au moins 6 mois, je fais ça juste pour apprendre, je ne prevois pas de reecrire un langage complet ( cocq ou prolog ) , VHDL ça c'est la grosse artillerie il me semble, mais qui sait, peut être un jour ...

    voilà ce que j'ai fais pour le moment, mais pas du tout interactif, pas encore .

    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
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    /*    logic_box_b.c
    lundi 12 Avril 2013 05:55:38
     
    ********************************
    ********************************
    *****************************************************************************
    *    commande compile : gcc -std=c99  -Wall logic_box_b.c -o logic_box_b    *
    *    commande execute : ./logic_box_b                                       *
    *****************************************************************************
    */
     
    #include <stdio.h>
    #include <stdbool.h>
     
    void oscilateur_1bits ( bool *aaa, size_t compt );
    void oscilateur_2bits ( bool *aaa, bool *bbb, size_t compt );
    bool YES ( bool aaa );              /* Buffer                   */
    bool NOT ( bool aaa );              /* Negation                 */
    bool AND ( bool aaa, bool bbb);     /* Conjontion               */
    bool NAND ( bool aaa, bool bbb);
    bool OR ( bool aaa, bool bbb);      /* Disjonction              */
    bool NOR ( bool aaa, bool bbb);
    bool XOR ( bool aaa, bool bbb);
    bool XNOR ( bool aaa, bool bbb);    /* coincidence, identité    */
    bool TAU ( bool aaa, bool bbb);     /* Tautologie               */
    bool CTR ( bool aaa, bool bbb);     /* Contradiction            */
     
    int main (void)
    {
            const char ligne[] = "----------------\n";
            size_t compt = 0;
            bool aaa = false;
            bool bbb = false;
     
            printf ( "\n" );
            for ( compt =0; compt < 4; ++compt )
            {
                    printf ( "%s", ligne );
                    oscilateur_2bits ( &aaa, &bbb, compt );
                    printf ( "| %d | %d |  %d   |\n", aaa, bbb, NAND ( aaa, bbb ) );
            }
     
            for ( compt =0; compt < 2; ++compt )
            {
                    printf ( "%s", ligne );
                    oscilateur_1bits ( &aaa, compt );
                    printf ( "| %d |      %d   |\n", aaa ,YES ( aaa ) );
            }
     
            printf ( "%s", ligne );
            return 0;
    }
     
    /********************************/
     
    /****************/
    void oscilateur_1bits ( bool *aaa, size_t compt )
    {
            compt %= 2;
     
            if ( compt == 1 )
                    *aaa = TAU ( aaa, aaa );
     
            if ( compt == 0 )
                    *aaa = CTR ( aaa, aaa );
     
            return ;
    }
     
    /****************/
    void oscilateur_2bits ( bool *aaa, bool *bbb, size_t compt )
    {
            compt %= 4;
            if ( compt == 3 )
                    *aaa = *bbb = TAU ( aaa, bbb );
     
            if ( compt == 2 )
            {
                    *aaa = CTR ( aaa, bbb );
                    *bbb = TAU ( aaa, bbb );
            }
     
            if ( compt == 1 )
            {
                    *aaa = TAU ( aaa, bbb );
                    *bbb = CTR ( aaa, bbb );
            }
     
            if ( compt == 0 )
                    *aaa = *bbb = CTR ( aaa, bbb );
     
            return ;
    }
     
    /****************/
    bool YES ( bool aaa )
    {
            printf ( "| a |     YES  |\n" );
     
            return aaa;
    }
     
    /****************/
    bool NOT ( bool aaa )
    {
            printf ( "| a |     NOT  |\n" );
     
            return !aaa;
    }
     
    /****************/
    bool AND ( bool aaa, bool bbb)
    {
            printf ( "| a | b | AND  |\n" );
     
            return aaa && bbb;
    }
     
    /****************/
    bool NAND ( bool aaa, bool bbb)
    {
            printf ( "| a | b | NAND |\n" );
     
            return !(aaa && bbb);
    }
     
    /****************/
    bool OR ( bool aaa, bool bbb)
    {
            printf ( "| a | b |  OR  |\n" );
     
            return aaa || bbb;
    }
     
    /****************/
    bool NOR ( bool aaa, bool bbb)
    {
            printf ( "| a | b | NOR  |\n" );
     
            return !(aaa || bbb);
    }
     
    /****************/
    bool XOR ( bool aaa, bool bbb)
    {
            printf ( "| a | b | XOR  |\n" );
     
            return (((!aaa) && bbb) || (aaa && (!bbb)));
    }
     
    /****************/
    bool XNOR ( bool aaa, bool bbb)
    {
            printf ( "| a | b | XNOR |\n" );
     
            return ((aaa && bbb) || ((!aaa) && (!bbb)));
    }
     
    /****************/
    /****************/
    bool TAU ( bool aaa, bool bbb)   /*   (A NAND B) OR (A AND B)   */
    {
            /*printf ( "| a | b | TAU  |\n" );*/
            return ( aaa && bbb ) || !( aaa && bbb );
    }
     
    /****************/
    bool CTR ( bool aaa, bool bbb)   /*   (A OR B) AND (A NOR B)   */
    {
            /*printf ( "| a | b | CTR  |\n" );*/
            return ( aaa || bbb ) && !( aaa || bbb );
    }
     
    /****************/
    /****************/
    /****************/
    à la ligne 40, le troisieme parametre de la fonction printf , c'est la porte logique qui est à l'origine du tableau de vérité, la changer et recompiler pour affichage .

    j'ai utiliser le C99 uniquement pour avoir les valeurs true/false en clair, sinon 0/1 fonctionnent aussi bien en C89.

    la sortie :
    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
    ----------------
    | a | b | NAND |
    | 0 | 0 |  1   |
    ----------------
    | a | b | NAND |
    | 1 | 0 |  1   |
    ----------------
    | a | b | NAND |
    | 0 | 1 |  1   |
    ----------------
    | a | b | NAND |
    | 1 | 1 |  0   |
    ----------------
    | a |     YES  |
    | 0 |      0   |
    ----------------
    | a |     YES  |
    | 1 |      1   |
    ----------------

  6. #6
    Membre Expert
    Avatar de Metalman
    Homme Profil pro
    Enseignant-Chercheur
    Inscrit en
    Juin 2005
    Messages
    1 049
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Hauts de Seine (Île de France)

    Informations professionnelles :
    Activité : Enseignant-Chercheur
    Secteur : Enseignement

    Informations forums :
    Inscription : Juin 2005
    Messages : 1 049
    Par défaut
    C'est bien tout ça !
    La sortie est un peu plus claire dans ton tableau, déjà, et tu dois pouvoir lire "un petit peu" mieux les formules plus complexes :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    OR(OR(AND(aaa,bbb), AND(ccc,bbb)), AND(ccc, ddd))
    Par exemple ça... c'est la "nouvelle" version du (aaa && bbb) || (ccc && bbb) || (ccc && ddd)Tu pourrais peut être regarder les va_list et va_arg pour faciliter ton OR ou ton AND (tu leur mets plusieurs arguments qui seront tous OR/AND). Le résultat donnerait ça "en pratique" :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    OR(AND(aaa,bbb), AND(ccc,bbb), AND(ccc, ddd))
    Ou autant d'arguments au OR que tu le souhaites.
    En gros, tu feras sur chaque argument du OR un || par rapport aux résultats précédents, tant que la va_list n'est pas vide (si je me souviens bien).

    De plus, il reste la transformation un nombre en bools, et réfléchir à comment améliorer le switch. xD
    --
    Metalman !

    Attendez 5 mins après mes posts... les EDIT vont vite avec moi...
    Les flags de la vie : gcc -W -Wall -Werror -ansi -pedantic mes_sources.c
    gcc -Wall -Wextra -Werror -std=c99 -pedantic mes_sources.c
    (ANSI retire quelques fonctions comme strdup...)
    L'outil de la vie : valgrind --show-reachable=yes --leak-check=full ./mon_programme
    Et s'assurer que la logique est bonne "aussi" !

    Ma page Developpez.net

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

Discussions similaires

  1. Règles d'utilisation des forums C
    Par Franck.H dans le forum C
    Réponses: 3
    Dernier message: 26/01/2008, 17h35
  2. [CR8.5] Utilisation des codes barre
    Par Robert dans le forum SAP Crystal Reports
    Réponses: 4
    Dernier message: 20/01/2005, 16h13
  3. utilisation des sockets sous windows
    Par Tupac dans le forum Réseau
    Réponses: 2
    Dernier message: 21/12/2002, 18h24
  4. [Crystal Report] Utilisation des vues de sql serveur
    Par Olivierakadev dans le forum SAP Crystal Reports
    Réponses: 2
    Dernier message: 15/11/2002, 17h44
  5. [BCB5] Utilisation des Ressources (.res)
    Par Vince78 dans le forum C++Builder
    Réponses: 2
    Dernier message: 04/04/2002, 16h01

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