Pour approfondir...

Soit un ensemble ${\sc A} = \{ 0, 1 \}$ pour lequel on a $0 ≤ 1$. On définit alors les opérations suivantes sur $\sc A$ :

• l'addition : $a + b$ dont la sémantique est $max(a,b)$
• la multiplication : $a . b = min(a,b)$
• la complémentation : $\ov 0\ = 1$ et $\ov 1\ = 0$

Une variable complémentée $\ov x \ $ est également dite signée ou négative.

Le résultat des opérations $+$ et $.$ apparaît dans la table ci-dessous d'après la sémantique que nous avons donnée.

Le quadruplet $({\sc A},+,.,\ov x\)$ est appelé algèbre de Boole s'il respecte les axiomes suivants :

• l'addition et la multiplication sont commutatives et associatives : $$ a + b = b + a $$ $$ a . b = b . a $$ $$ (a + b) + c = a + (b + c) $$ $$ (a . b) . c = a . (b . c) $$
• $0$ est élément neutre pour l'addition et $1$ est élément neutre pour la multiplication : $$ 0 + a = a $$ $$ 1 . a = a $$
• l'addition et la multiplication sont distributives l'une par rapport à l'autre : $$ (a + b) . c = a . c + b . c $$ $$ (a . b) + c = (a + c) . (b + c) $$ néanmoins par la suite, on fera en sorte que la multiplication soit prioritaire par rapport à l'addition
• la complémentation est telle que $\ov a↖{-}\ = a$ et vérifie les propriétés suivantes : $$ a + \ov{a}\ = 1 $$ $$ a . \ov{a}\ = 0 $$

Si l'on rapporte ces opérations à la logique, alors :

• $1$ indique le caractère vrai d'une propriété ou d'un énoncé
• $0$ indique le caractère faux
• l'addition ($+$) correspond au ou
• la multiplication ($.$) correspond au et
• la complémentation $ \ov a\ $ correspond à non (noté $¬$ en logique), i.e. le contraire de $a$

Ainsi, l'expression $a + \ov a\ = 1$ peut s'interpréter : dire qu'une chose est vraie ou n'est pas vraie est toujours vrai. Je peux par exemple remplacer $a$ par l'énoncé il pleut, et donc, dans ce cas, il est vrai que : il pleut ou il ne pleut pas.

De la même manière $a . \ov a\ = 0$ signifie qu'on ne peut pas dire une chose et son contraire. Je ne peux pas à la fois être grand et ne pas être grand.

Pour approfondir...

Le ET logique et le OU logique peuvent être étendues pour traiter non plus des valeurs 0 et 1, mais des valeurs sur plusieurs bits. On parle alors de ET binaire et OU binaire.

Le ET et le OU binaires sont deux opérations très utiles qui permettent de faciliter certains traitements.

Par exemple, pour définir des personnages et des monstres dans un jeux ainsi que leurs caractéristiques, on peut utiliser des constantes :

Voici la définition de la structure EtreVivant qui permettra de modéliser des personnages ou des monstres :

typedef struct {
	int force;
	int agilite;
    ...
	int points_de_vie;
	int role; 
} EtreVivant;

On peut alors définir les caractéristiques des personnages et monstres pour le role qu'ils occuperont :

const int PERSONNAGE  = 1
const int ARMES       = 2  // Maîtrise des armes
const int MAGIE       = 3  // Maîtrise de la magie
const int MONSTRE     = 4
const int PETIT       = 5
const int GRAND       = 6
const int ENORME      = 7  

Le système précédent permet de définir un personnage qui maitrise les armes, il suffit d'additionner les constantes PERSONNAGE et ARMES, ce qui donne 3, mais ce code correspond à MAGIE ! De la même manière un PETIT MONSRE (5 + 4 = 9) correspond également à ENORME ARMES (2 + 7). On a donc un problème pour identifier de manière unique une caractéristique d'un personnage ou d'un monstre.

Un système plus intelligent va se baser sur une représentation par puissances de 2, donc du binaire :

Voici donc comment il faut procéder :

const int PERSONNAGE  = 1
const int ARMES       = 2  // Maîtrise des armes
const int MAGIE       = 4  // Maîtrise de la magie
const int MONSTRE     = 8
const int PETIT       = 16
const int GRAND       = 32
const int ENORME      = 64  

A partir de cette modélisation, on peut alors définir différents êtres vivants pour le rôle qu'ils occuperont :

Guerrier =  PERSONNAGE | ARMES | GRAND
Magicien =  PERSONNAGE | MAGIE | GRAND
Elfe     =  PERSONNAGE | MAGIE | MAITRISE_ARMES | GRAND
Nain     =  PERSONNAGE | ARMES | PETIT
Gobelin  =  MONSTRE | PETIT
Troll    =  MONSTRE | GRAND
Dragon   =  MONTRE | ENORME | MAGIE 

Par exemple un Guerrier est un personnage de grande taille qui possède une maîtrise des armes.

On voit sur le tableau précédent que tout personnage ou monstre qui maitrise la magie comme les magiciens, les elfes ou les dragons, possèdera le bit 2 positionné à 1 ($2^2 = 4$) dans la valeur de son role.

On peut alors utiliser :

• le ET-binaire (AND) afin de sélectionner certains bits
• le OU-binaire (OR) permet quant à lui de positionner à 1 des bits choisis

4.4.0.a  Sélectionner un monstre

Pour vérifier si un être vivant (p) est un monstre, il faut vérifier que son champ role contient la valeur 8 (=MONSTRE). Si on écrit :

if (p.role == MONSTRE) {
    ...
}

cela ne fonctionne pas car un monstre possède d'autres caractéristiques. Les monstres (Gobelin, Troll et Dragon) ont des valeurs de role différentes de 8, mais possèdent le bit 3 positionné à 1 ($2^3 = 1$). On doit donc écrire :

if ((p.role & MONSTRE) != 0) {
    ...
}

ou encore :

if ((p.role & MONSTRE) == MONSTRE) {
    ...
}

Pour un guerrier, on obtient :

Pour un dragon, on obtient :

4.4.0.b  Sélectionner un personnage qui maitrise les armes

Pour vérifier si on a à faire à un personnage qui maitrise les armes, il faut choisir :

• le bit 0 ($2^0=1$) qui correspond à PERSONNAGE
• et le bit 1 ($2^1=2$) qui correspond à ARMES

if ((p.role & (PERSONNAGE | ARMES)) == (PERSONNAGE | ARMES)) {
   ...
}

PERSONNAGE | ARMES représente un masque de sélection, tout comme MONSTRE dans l'exemple précédent.

4.4.0.c  Mettre à jour un personnage qui maitrise à présent la magie

Imaginons maintenant qu'un personnage découvre le pouvoir maitrise de la magie, il faut donc ajouter le bit 2 soit la valeur 4 ($=2^2$) à son rôle et on fait cela grâce au OU-binaire (OR) :

p.role = p.role | MAGIE;

Par exemple, avec un guerrier, on obtient :