Addition binaire et hexadécimale

On additionne en binaire et en hexadécimal exactement comme en décimal, colonne par colonne en partant de la droite, avec une retenue dès que la somme d'une colonne atteint la base : 2 en binaire, 16 en hexadécimal. Ce chapitre détaille l'addition et la soustraction à la main dans ces deux bases, la multiplication et la division par une puissance de 2 (un simple décalage des bits), le dépassement de capacité et le lien entre calcul binaire et calcul booléen.

L'addition en binaire

En binaire, il n'y a que quatre additions de base à connaître :

Calcul	Résultat	Explication
0 + 0	0
0 + 1	1
1 + 0	1
1 + 1	10	On écrit 0 et on retient 1, comme 5 + 5 = 10 en décimal

Avec une retenue, une colonne peut aussi contenir 1 + 1 + 1 = 3 = (11)₂ : on écrit 1 et on retient 1.

Exemple 1 : (1011)₂ + (110)₂.

text

 retenues 1 1 1
            1 0 1 1      (11)
          +   1 1 0      ( 6)
          ---------
          1 0 0 0 1      (17)

Colonne par colonne, de droite à gauche :

1 + 0 = 1 : on écrit 1.
1 + 1 = 10 : on écrit 0, retenue 1.
0 + 1 + 1 (retenue) = 10 : on écrit 0, retenue 1.
1 + 0 + 1 (retenue) = 10 : on écrit 0, retenue 1.
La retenue descend : on écrit 1.

(1011)₂ + (110)₂ = (10001)₂. Vérification en décimal : 11 + 6 = 17 = 16 + 1.

Exemple 2 : deux octets. (10110110)₂ + (01101101)₂, soit 182 + 109.

text

 retenues  1 1 1 1 1 1
             1 0 1 1 0 1 1 0     (182)
           + 0 1 1 0 1 1 0 1     (109)
           -----------------
           1 0 0 1 0 0 0 1 1     (291)

Le résultat, (100100011)₂ = 256 + 32 + 2 + 1 = 291, a 9 bits : il ne tient plus dans un octet.

Le dépassement de capacité

Un ordinateur additionne sur un nombre fixe de bits. Si le résultat a besoin d'un bit de plus, ce bit est perdu : c'est un dépassement de capacité (overflow).

Sur 8 bits, 182 + 109 donne (1 0010 0011)₂ ; seuls les 8 bits de droite sont gardés, (00100011)₂ = 35. On a perdu 2⁸ = 256 : 291 − 256 = 35. Le résultat est faux, et le processeur se contente de lever un indicateur de retenue.

Les conséquences sont réelles. Un compteur sur 8 bits repasse à 0 après 255. Un compteur de secondes signé sur 32 bits, utilisé par de nombreux systèmes pour stocker la date (nombre de secondes écoulées depuis le 1ᵉʳ janvier 1970), dépassera sa valeur maximale le 19 janvier 2038 : c'est le « bug de l'an 2038 », que les systèmes modernes évitent en passant à 64 bits. En Python, les entiers n'ont pas de taille maximale et ne débordent jamais ; en Java et en C#, un int qui déborde repart silencieusement de sa valeur minimale ; en SQL, MySQL ou PostgreSQL refusent la valeur avec une erreur « out of range » sur une colonne TINYINT ou INT.

L'addition en hexadécimal

Même méthode, mais la retenue intervient quand la somme d'une colonne atteint 16. Le plus simple : additionne les valeurs en décimal, puis, si la somme dépasse 15, retire 16, écris le reste et retiens 1.

Exemple : (7A9)₁₆ + (4B6)₁₆.

text

 retenues  1
           7 A 9
         + 4 B 6
         -------
           C 5 F

9 + 6 = 15 = F : on écrit F, pas de retenue.
A + B = 10 + 11 = 21 = 16 + 5 : on écrit 5, retenue 1.
7 + 4 + 1 = 12 = C : on écrit C.

(7A9)₁₆ + (4B6)₁₆ = (C5F)₁₆. Vérification : (7A9)₁₆ = 1 961, (4B6)₁₆ = 1 206, et 1 961 + 1 206 = 3 167 = 12 × 256 + 5 × 16 + 15 = (C5F)₁₆.

Deuxième exemple, avec deux retenues : (1A3F)₁₆ + (2E7)₁₆.

F + 7 = 15 + 7 = 22 = 16 + 6 : on écrit 6, retenue 1.
3 + E + 1 = 3 + 14 + 1 = 18 = 16 + 2 : on écrit 2, retenue 1.
A + 2 + 1 = 13 = D : on écrit D.
1 : on écrit 1.

(1A3F)₁₆ + (2E7)₁₆ = (1D26)₁₆. Vérification : 6 719 + 743 = 7 462 = (1D26)₁₆.

La soustraction

On soustrait aussi colonne par colonne. Quand le chiffre du haut est trop petit, on emprunte une unité à la colonne de gauche, ce qui ajoute la base (2 ou 16) au chiffre du haut.

En binaire : (11001)₂ − (1011)₂, soit 25 − 11.

text

 emprunts  1 1 1
           1 1 0 0 1     (25)
         − 0 1 0 1 1     (11)
         -----------
           0 1 1 1 0     (14)

1 − 1 = 0.
0 − 1 : impossible, on emprunte : (10)₂ − 1 = 1, emprunt 1.
0 − 0 − 1 (emprunt) : on emprunte encore : (10)₂ − 1 = 1, emprunt 1.
1 − 1 − 1 : on emprunte : (11)₂ − 1 − 1 = 1, emprunt 1.
1 − 0 − 1 = 0.

Résultat : (1110)₂ = 14. Vérification : 25 − 11 = 14.

En hexadécimal : (B4)₁₆ − (3F)₁₆, soit 180 − 63.

4 − F : impossible, on emprunte : 4 + 16 − 15 = 5, emprunt 1.
B − 3 − 1 = 11 − 4 = 7.

Résultat : (75)₁₆ = 117. Vérification : 180 − 63 = 117.

Multiplier et diviser par une puissance de 2 : les décalages

En décimal, multiplier par 10 revient à ajouter un 0 à droite : 37 × 10 = 370. En binaire, c'est pareil avec 2 : multiplier par 2 ajoute un 0 à droite, et multiplier par 2ᵏ ajoute k zéros. On dit qu'on décale les bits de k rangs vers la gauche.

(1011)₂ × 2 = (10110)₂ : 11 × 2 = 22.
(1011)₂ × 2² = (1011)₂ × (100)₂ = (101100)₂ : 11 × 4 = 44.
(1101)₂ × 8 = (1101)₂ × 2³ = (1101000)₂ : 13 × 8 = 104.

À l'inverse, diviser par 2ᵏ décale les bits de k rangs vers la droite. Les k bits qui « sortent » à droite forment le reste de la division euclidienne par 2ᵏ, et ceux qui restent forment le quotient.

(101101)₂ ÷ 2² : on coupe les 2 derniers bits. Quotient (1011)₂ = 11, reste (01)₂ = 1. Vérification : 45 = 4 × 11 + 1.
(11001000)₂ ÷ 2³ : quotient (11001)₂ = 25, reste (000)₂ = 0. 200 = 8 × 25.

Décaler de k rangs vers la gauche multiplie par 2ᵏ ; vers la droite, cela donne le quotient et le reste de la division par 2ᵏ

Les langages ont des opérateurs pour ces décalages : << (gauche) et >> (droite). En Python, 11 << 2 vaut 44 et 45 >> 2 vaut 11. Un décalage est l'une des opérations les plus rapides d'un processeur : les compilateurs remplacent souvent x * 8 par x << 3.

Le lien avec le calcul booléen

Un bit est un booléen : 1 pour vrai, 0 pour faux. Les opérations logiques s'appliquent donc aux nombres binaires bit à bit, position par position, sans retenue :

Opération	Règle sur deux bits	Python	Exemple sur 8 bits
ET (AND)	1 seulement si les deux bits valent 1	`a & b`	11001010 ET 11110000 = 11000000
OU (OR)	1 si au moins un des deux bits vaut 1	`a \| b`	11001010 OU 11110000 = 11111010
OU exclusif (XOR)	1 si les deux bits sont différents	`a ^ b`	11001010 XOR 11110000 = 00111010
NON (NOT)	Inverse chaque bit	`~a` (attention aux négatifs)	NON 11001010 = 00110101

Compare avec l'addition : 1 + 1 donne 0 avec une retenue, alors que 1 ET 1 = 1, 1 OU 1 = 1 et 1 XOR 1 = 0. Le XOR est l'addition binaire sans la retenue, et le ET donne justement la retenue : c'est ainsi que les circuits d'un processeur additionnent deux bits (le demi-additionneur, construit avec des portes logiques dans le cours de logique).

L'application la plus courante en BTS SIO est le calcul d'une adresse de réseau : adresse IP ET masque, bit à bit. Sous les 1 du masque, le bit de l'adresse est recopié ; sous les 0, il devient 0.

	Dernier octet
Adresse 192.168.10.37	00100101
Masque /27 (255.255.255.224)	11100000
ET bit à bit	00100000 = 32

L'adresse du réseau est 192.168.10.32. Le cours de logique détaille ce calcul (la logique en informatique), et le cours réseaux l'applique au découpage en sous-réseaux.

Pour aller plus loin : le complément à deux

Sur n bits, le complément à deux représente un entier négatif −x par l'entier positif 2ⁿ − x. Sur 8 bits, −5 est stocké comme 256 − 5 = 251 = (11111011)₂. La méthode à la main :

écris x en binaire sur n bits : 5 = 00000101 ;
inverse tous les bits : 11111010 ;
ajoute 1 : 11111011.

Sur 8 bits, on représente ainsi les entiers de −128 à 127 ; le bit de poids fort vaut 1 pour les négatifs. L'intérêt : la soustraction devient une addition. 7 − 5 = 7 + (−5) : 00000111 + 11111011 = 1 00000010, et en gardant 8 bits, 00000010 = 2. C'est aussi la cause d'un bug classique : en complément à deux sur 8 bits, 127 + 1 donne −128.