Logique sur les entiers

Entiers comme booléens

Je reprends ici ce qui a été dit dans Aspect séquentiel des opérateurs logiques afin de faire la transition vers ce qui nous intéresse.

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

Sur les entiers

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

bitwise signifie que les entiers sont considérés comme un ensemble de bits.

Par exemple 12 = 00000000 00000000 00000000 00001100b – je rappelle qu'en Python, les entiers occupent 32 bits en mémoire.

Cas du ET

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

Cas du OU

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

Cas du NON

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 pourrait vous sembler que 0b11111111 11111111 11111111 11110011 devrait correspondre à un entier très grand, comme 4294967283. Mais on voit dans le chapitre sur les entiers négatifs que ce mot binaire sert à stocker un nombre négatif.

D'autres opérateurs

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

Questions

Question 1

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 ?

Question 2

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 ?