Utilisation des operateurs logiques en C99.

**JulieCarree** · 14/04/2013, 02h29

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 );
}
 
/****************/

**Metalman** · 14/04/2013, 02h54

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;

**JulieCarree** · 14/04/2013, 03h14

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.

**Metalman** · 14/04/2013, 03h29

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 !

**JulieCarree** · 14/04/2013, 04h55

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   |
----------------

**Metalman** · 14/04/2013, 12h33

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

Utilisation des operateurs logiques en C99.

C

Vue hybride

Discussions similaires

Partager

Partager