Logique sur les entiers

and, or et not agissent sur des booléens et seulement sur les booléens.

Donc si on écrit 12 and 26, le 12 et le 26 sont interprétés en tant que booléens.

La règle :

• 0 → False
• Tous les autres entiers → True

On s'attendrait donc à ce que 12 and 26 → True and True → True, mais c'est un peu compliqué. Comme on l'a vu dans la partie sur l'aspect séquentiel des opérateurs, and renvoie le premier élément faux s'il y en a un, sinon le dernier. Puisque 12 et 26 sont compris comme True, alors 12 and 26 renvoie le dernier, 26.

>>> 12 and 26
26

Il y a une autre façon de faire de la logique sur les nombres entiers, et cela va utiliser d'autres opérateurs. Ce sont des opérateurs bitwise :

• and → & – ce caractère s'appelle esperluette
• or → | – ce caractère s'appelle pipe, ce qui signifie tube
• not → ~

Un ET bitwise – & – s'exécutera bit à bit.

12      = 0b 00000000 00000000 00000000 00001100
26      = 0b 00000000 00000000 00000000 00011010
12 & 26 = 0b 00000000 00000000 00000000 00001000 = 8

On peut tester en console :

>>> 12 & 26
8

Il en va de même pour le OU bitwise – |.

12      = 0b 00000000 00000000 00000000 00001100
26      = 0b 00000000 00000000 00000000 00011010
12 | 26 = 0b 00000000 00000000 00000000 00011110 = 30

En console :

>>> 12 | 26
30

Le NON bitwise est ~. Le principe est le même mais le codage des entiers donne un résultat qui peut surprendre.

12  = 0b 00000000 00000000 00000000 00001100
~12 = 0b 11111111 11111111 11111111 11110011 = -13

Ce qui se vérifie en console :

>>> ~12
-13

Il en existe d'autres qui peuvent servir :

• << qui décale à gauche : 0b110011010 << 3 → 0b110011010000
• << qui décale à droite : 0b110011010 >> 3 → 0b110011
• ^ qui exécute un ou-exclusif – je ne détaille pas, vous creuserez si cela vous intéresse

Soit s un nombre 9 bits qui représente les droits d'accès à un fichier.

On sait que le bit de poids fort – MSB = Most Significant Bit, le bit le plus à gauche –représente le droit de lecture.

Deux exemples :

• s = 456 ⇒ s = 0b111001000, le bit de poids fort est 1, le droit de lecture est donc True.
• s = 120 ⇒ s = 0b001111000, le bit de poids fort est 0, le droit de lecture est donc False.

On voudrait obtenir le résultat par un calcul rapide, sans faire la décomposition de s en binaire. Comment faire ?

La technologie couleur des écrans repose sur des pixels composés de 3 points, rouge (R pour red), vert (G pour green) et bleu (B pour blue). On dira que ces 3 points sont les composantes du pixel. Selon l'intensité lumineuse des composantes, on pourra varier la couleur perçue.

Exemples :

• R, G et B à 0 → c'est du noir
• R, G et B à 100 % → c'est du blanc
• R et G à 100 % et B à 0 → c'est un jaune
• etc.

Un choix courant est d'attribuer 8 bits pour chaque composante ce qui fait 24 bits pour un pixel.

c = 0b 11111110 11111111 00000000 = 16711424 correspond au cas de R et G au max, B au min donc à un jaune. Mais, lire 16711424 ne permet pas de se faire facilement une idée de la couleur. On voudrait pouvoir extraire facilement les 8 bits correspondant à R, à G à B.

Par exemple pour R, on voudrait faire ceci :

c = 16711424 = 0b 11111110 11111111 00000000 → 0b11111110 = 254. On a donc R = 254. Comme on sait que le maximum, sur 8 bits, est 255, on a tout de suite l'info que R est quasiment à 100 %.

Quel calcul doit-on faire pour obtenir directement à partir de c la valeur de R sans décomposer c en binaire ?