Secrets

Opérations bit à bit

Les opérations bit à bit permettent de manipuler les chiffres individuels des nombres binaires.

Elm fournit plusieurs opérateurs bit à bit dans son module Bitwise

Opérations de base

Modifier individuellement les bits d'un nombre s'appelle le masquage. Un masque est un nombre dans lequel certains bits ont été définis d'une manière particulière afin de manipuler un autre nombre à l'aide d'opérateurs bit à bit tels que and, or et xor.

and

and combine deux nombres en ne conservant que les bits qui valent 1 dans les deux. C'est utile pour vérifier si un bit particulier est défini. Par exemple, pour vérifier si le 4e bit d'un nombre vaut 1, fais un and avec un masque de 01000 (8 en décimal) et regarde si le résultat est différent de zéro :

Bitwise.and 13 8 --> 8
--  13 = 01101
--   8 = 01000
-- and = 01000 = 8

or

or combine deux nombres en mettant chaque bit à 1 s'il vaut 1 dans l'un des deux nombres ou dans les deux. C'est utile pour mettre un bit particulier à 1. Par exemple, pour mettre le 2e bit de 10101 à 1, fais un or avec le masque 00010 :

Bitwise.or 21 2 --> 23
-- 21 = 10101
--  2 = 00010
-- or = 10111 = 23

Ou exclusif (xor)

xor combine deux nombres en mettant chaque bit à 1 s'il vaut 1 dans l'un des nombres mais 0 dans l'autre. C'est utile pour inverser un bit et lui donner la valeur opposée :

Bitwise.xor 20 5 --> 17
--  20 = 10100
--   5 = 00101
-- xor = 10001 = 17

Complément

complement inverse chaque bit d'un nombre (0 devient 1, 1 devient 0).

À noter que les nombres positifs deviennent alors négatifs, et les nombres négatifs deviennent positifs. En effet, en binaire, les nombres négatifs sont représentés par un 1 à la position la plus à gauche.

Bitwise.complement 21 --> -22
--         21 = 00000000000000000000000000010101
-- complement = 11111111111111111111111111101010 = -22

Décalage de bits

Les opérateurs suivants déplacent les bits vers la gauche ou vers la droite d'un nombre donné de positions, ce qui revient à multiplier ou à diviser par des puissances de 2.

shiftLeftBy déplace les bits vers la gauche, en remplissant avec des 0 depuis la droite. Par exemple, pour décaler 21 de 3 positions vers la gauche :

Bitwise.shiftLeftBy 3 21 --> 168
--  21 = 10101
-- shiftLeftBy 3 = 10101000 = 168

Cela revient à dire 21 * 2^3 = 21 * 2 * 2 * 2 = 168

shiftRightBy : déplace les bits vers la droite :

Bitwise.shiftRightBy 2 21 --> 5
--  21 = 10101
-- shiftRightBy 2 = 00101 = 5

Décaler de 2 positions vers la droite revient à une division entière par 4.

À noter que cette fonction duplique la valeur présente dans le bit le plus à gauche. Les nombres négatifs restent donc négatifs :

Bitwise.shiftRightBy 3 -21 --> -3
--  -21 = 111...101011
-- shiftRightBy 3 = 111...11101 = -3

Si tu veux décaler vers la droite en remplissant avec des zéros, utilise shiftRightZfBy :

Bitwise.shiftRightZfBy 3 -21 --> 536870909
--  -21 = 111...101011
-- shiftRightZfBy 3 = 00111...11101 = 536870909