Utilisation des operateurs logiques en C99.

Version imprimable

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:

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

:aie: pas taper SVP :aie:

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

14/04/2013, 02h54
Metalman
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... :P
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:

1 2 3 compt = compt & (bit1 * 2) & bit0; compt = compt | (bit1 * 2) | bit0;
14/04/2013, 03h14
JulieCarree

merci Metalman :oops:
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.
14/04/2013, 03h29
Metalman
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:

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:

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 !

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:

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:

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

14/04/2013, 12h33
Metalman

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:

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:

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
14/04/2013, 23h56
JulieCarree

bonsoir,
alors ça,

Code:

OR(OR(AND(aaa,bbb), AND(ccc,bbb)), AND(ccc, ddd))

j'avais deja vu que ça marchait ( à ma grande surprise ) par contre les va_list de stdarg.h je ne connaissais pas du tout, mais je pensais reinventer la roue avec des pointeurs sur fonctions. je viens juste de donner un coup d'oeil sur le man de stdarg.h et ça devrais coller.
La doc sur la libC est tellement vaste que j'ai du mal à chercher dedans les choses dont j'aurai besoin mais dont je ne connais pas le nom . J'ai depuis longtemps en tête, un projet dans le genre colonnie de fourmis ( juste deux ) qui echangerais des informations sur leurs connaissances du milieu (un tableau 2D), à un niveau tres basique, et en C. j'avais essayé en python mais le C me convient mieux pour comprendre (le fonctionnement d'un ordinateur).les couches d'abstraction des langages de plus haut niveau rendent opaque le fonctionnement de la machine, à mon avis,ce n'est pas toujours utile.
Mais ceci est un autre debat et surtout je n'ai pas de contrainte de production.
15/04/2013, 12h49
Metalman

C'est le problème de la LibC : beaucoup de choses pour faire plein de choses !...
Mais pas vraiment de résumé, et des noms parfois bizarres.
Bon courage pour la suite !

PS : merci à celui/celle qui met des pouces rouges... si c'est juste pour dire "c'est nul", merci d'expliquer pourquoi j'ai tord, et pourquoi JulieCarree ne devrait pas faire ce que je propose.
17/04/2013, 11h57
JulieCarree

ça part en troll ...

re MetalMan,
à mon humble avis, le pouceur rouge n'a meme pas compris de quoi il s'agit, parce que Metalman a au minimum 4 qualités :
-il maitrise la logique
-il maitrise le C
-il repond vite et ses reponses sont plus que pertinentes
-il a un avatar rigolo

parce qu'entre nous, j'ai posé deux topics ayant pour sujet la logique sur developpez ( math et C ) , ben je peux vous dire qu'il n'y a pas foule qui m'a repondu .

et un coucou à JCVD qui crie haut et fort que 1 + 1 ça peut faire 11, ou 10, ou 2.
encore merci de tes conseils Metalman .
17/04/2013, 14h12
Bktero

Je me transforme en pouceur vert pour compenser le pouceur rouge ;)
18/04/2013, 05h20
JulieCarree

merci Bktero mais n'en profite pas :ccool:

pour être plus serieux j'ai trouvé ce site http://infoindustrielle.free.fr/ pour des infos sur la logique (et beaucoup plus )qui me semble tres serieux et complet.
19/04/2013, 14h04
Obsidian
Citation:

Envoyé par JulieCarree

et un coucou à JCVD qui crie haut et fort que 1 + 1 ça peut faire 11, ou 10, ou 2.

Il a raison ! :-) « 1 + 1 = »
- 11 si on les concatène ;
- 10 si on compte en binaire ;
- 2 si on compte en décimal ;
Jean-Claude van Damme est probablement informaticien sans le savoir…
19/04/2013, 14h25
Metalman

Hmmm... je sais que ça va être du post facile et pas constructif... mais ça devient lourdingue de voir des pouces rouges à chaque réponse, y compris celles ajoutées après.

Merci de faire les remarques par texte, et pas seulement en vote, car je ne vois pas mes erreurs et je suis ouvert aux critiques quelles qu'elles soient.