====== Logique sur les entiers ======

===== Entiers comme booléens =====

<WRAP important>Je reprends ici ce qui a été dit dans [[nsi:premiere:logique:aspect_sequentiel|Aspect séquentiel des opérateurs logiques]] afin de faire la transition vers ce qui nous intéresse.</WRAP>


''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'[[nsi:premiere:logique:aspect_sequentiel|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''.

<code python>
>>> 12 and 26
26
</code>

===== 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'' -> ''%%~%%''

<WRAP info>**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.</WRAP>

==== Cas du ET ====

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

<code lang-none>
12      = 0b 00000000 00000000 00000000 00001100
26      = 0b 00000000 00000000 00000000 00011010
12 & 26 = 0b 00000000 00000000 00000000 00001000 = 8
</code>

On peut tester en console :

<code python>
>>> 12 & 26
8
</code>

==== Cas du OU ====

Il en va de même pour le OU bitwise -- ''%%|%%''.

<code lang-none>
12      = 0b 00000000 00000000 00000000 00001100
26      = 0b 00000000 00000000 00000000 00011010
12 | 26 = 0b 00000000 00000000 00000000 00011110 = 30
</code>

En console :

<code python>
>>> 12 | 26
30
</code>

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

<code lang-none>
12  = 0b 00000000 00000000 00000000 00001100
~12 = 0b 11111111 11111111 11111111 11110011 = -13
</code>

Ce qui se vérifie en console :

<code python>
>>> ~12
-13
</code>

<WRAP tip>
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 [[nsi:premiere:ca2|entiers négatifs]] que ce mot binaire sert à stocker un nombre négatif.
</WRAP>

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