Le binaire, depuis le tout débutBits, bases, conversions, nombres négatifs, et les calculs que fait vraiment le processeur.

0Mode d'emploi

Les mots, et où ils sont expliqués

• •Bit, octet, mot
• •Combien de bits faut-il ?
• •Bases 2, 8, 10 et 16
• •Les conversions
• •Addition et soustraction
• •Taille fixe, retenue sortante
• •Signe et valeur absolue
• •Complément à un
• •Complément à deux
• •Calculer avec des signés
• •Retenue ou débordement ?
• •Caractères et nombres à virgule
• •Relecture de tes notes

1Le bit, l'octet, le mot

1.1 Le bit

Un processeur contient des milliards de minuscules interrupteurs électroniques, les transistors. Chacun est dans un état parmi deux. Tes notes le disent ainsi : 0, le courant ne passe pas ; 1, le courant passe. En réalité, on mesure plutôt une tension : basse pour 0, haute pour 1. L'idée reste la même : deux états, faciles à distinguer.

Un chiffre qui ne peut valoir que 0 ou 1 s'appelle un bit (binary digit, chiffre binaire). C'est la plus petite quantité d'information possible : la réponse à une question par oui ou par non.

1.2 Octet et mot

Ton i5-1135G7 est un processeur 64 bits : ses registres de calcul contiennent des mots de 64 bits. En français, un octet fait toujours 8 bits, alors que la taille d'un mot dépend de la machine. C'est pourquoi on précise toujours le nombre de bits.

Attention aux outils x86 (débogueurs, désassembleurs) : par tradition, WORD y désigne 16 bits, DWORD 32 bits et QWORD 64 bits, quel que soit le processeur.

On écrit les bits par paquets de 4 pour les lire plus facilement, comme on écrit 65 536 avec une espace : 1010 0111 plutôt que 10100111.

1.3 Combien de valeurs avec n bits ?

Avec 1 bit, on écrit 2 valeurs : 0 et 1. Avec 2 bits, 4 valeurs : 00, 01, 10, 11. Chaque bit ajouté double le nombre de possibilités : on reprend toutes les combinaisons précédentes, une fois avec un 0 devant, une fois avec un 1 devant.

Pourquoi « − 1 » ? Parce qu'on commence à 0. Avec 3 chiffres décimaux, il y a 10³ = 1 000 combinaisons, de 000 à 999 : la plus grande vaut 1 000 − 1. Pour l'octet, 2⁸ = 256 combinaisons, de 0 à 255 : c'est le « de 0 à 255 » de tes notes.

Les puissances de 2 de ton cours sont à connaître par cœur, au moins jusqu'à 2¹⁰ : 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1 024.

La question inverse : combien de bits faut-il ?

Elle revient sans cesse en TD. Pour représenter N valeurs différentes, il faut le plus petit n tel que 2ⁿ ≥ N.

• Numéroter les 30 étudiants d'un groupe : 2⁴ = 16 ne suffit pas, 2⁵ = 32 suffit. Il faut 5 bits (numéros 0 à 29).
• Écrire tous les entiers de 0 à 200 : cela fait 201 valeurs. 2⁷ = 128 ne suffit pas, 2⁸ = 256 suffit. Il faut 8 bits.
• Distinguer 1 000 valeurs : 2¹⁰ = 1 024, donc 10 bits.

1.4 Laboratoire : l'octet

Clique sur les bits pour les allumer ou les éteindre. Chaque bit allumé ajoute son poids, écrit au-dessus. Essaie d'écrire 167, puis 255, puis 128.

2La numération positionnelle

2.1 Ce que veut dire « 2026 »

Tu as écrit cet exemple dans tes notes. On le reprend, parce que tout le reste en découle.

Chaque chiffre est multiplié par une puissance de 10 qui dépend de sa position. On numérote les positions à partir de la droite, en commençant à 0, comme les indices d'une liste en Python. Le même chiffre 2 vaut 2 000 en position 3, et 20 en position 1. C'est pour ça qu'on parle de numération positionnelle (positional notation). Les chiffres romains, eux, ne sont pas positionnels : dans XXX, chaque X vaut dix, quelle que soit sa place.

2.2 Changer de base

Le nombre 10 n'a rien de spécial : il vient de nos dix doigts. On peut remplacer 10 par n'importe quel entier b ≥ 2, qu'on appelle la base.

En base 16, il faut seize chiffres, et nos chiffres s'arrêtent à 9. On emprunte donc des lettres : A = 10, B = 11, C = 12, D = 13, E = 14, F = 15. Chacune est un seul chiffre : dans (1A)₁₆, le A vaut 10 unités, et le nombre vaut 1 × 16 + 10 = 26.

On écrit la base en indice : (1010)₂ = (10)₁₀. Sans indice, « 10 » est ambigu : dix en décimal, deux en binaire, huit en octal, seize en hexadécimal.

2.3 Compter : le compteur kilométrique

Un compteur kilométrique a des roues numérotées de 0 à 9. Quand une roue passe de 9 à 0, elle fait avancer d'un cran la roue de gauche : c'est la retenue (carry). En base b, c'est pareil, mais chaque roue n'a que b chiffres. En binaire, une roue n'a que 0 et 1 : dès qu'elle dépasse 1, elle repasse à 0 et pousse sa voisine. C'est pourquoi 0111 + 1 = 1000 : trois roues repassent à 0 d'un coup, exactement comme 999 + 1 = 1 000.

Ton tableau de 0 à 21 se lit avec cette image. La colonne de droite alterne 0, 1, 0, 1. La suivante change tous les 2 nombres, la suivante tous les 4, puis tous les 8. Chaque colonne change deux fois moins souvent que sa voisine de droite.

2.4 Pourquoi l'octal et l'hexadécimal ?

Le binaire est long à écrire et facile à mal recopier : 1 495 s'écrit 101 1101 0111. L'octal et l'hexadécimal servent d'abréviations, parce que 8 = 2³ et 16 = 2⁴. Un chiffre octal remplace exactement 3 bits, et un chiffre hexadécimal exactement 4 bits (section 3.4). Un octet s'écrit donc toujours avec 2 chiffres hexadécimaux, de 00 à FF.

C'est pour ça que les adresses mémoire s'écrivent en hexadécimal, comme tu l'as noté. Dans un débogueur, ou sur Root-Me, tu verras des adresses comme 0x7ffd3a2c1e40.

3Les conversions

3.1 D'une base b vers la base 10

On applique la définition : chaque chiffre, multiplié par la base puissance sa position, puis on additionne.

def vers_decimal(chiffres, base):
    valeur = 0
    for c in chiffres:
        valeur = valeur * base + int(c, 16)
    return valeur

3.2 De la base 10 vers une base b : les divisions successives

On divise le nombre par b et on note le reste. On recommence avec le quotient, jusqu'à obtenir un quotient nul. Le résultat s'écrit avec les restes, lus du dernier au premier. Voici ton exemple de 72 en binaire :

On lit la colonne des restes de bas en haut : (72)₁₀ = (1001000)₂, soit 0100 1000 sur 8 bits. Vérification : 64 + 8 = 72.

Pourquoi lire à l'envers ? Fais la même chose en base 10 avec 2026 : 2026 ÷ 10 = 202, reste 6. Le reste, c'est le chiffre le plus à droite, et diviser par 10 décale le nombre d'un cran vers la droite. En base 2, c'est pareil : le premier reste, 72 mod 2, est le chiffre des unités (position 0). Les restes sortent donc de droite à gauche, et il faut les relire dans l'autre sens. En Python :

def vers_base(n, b):
    chiffres = ""
    while n > 0:
        chiffres = "0123456789ABCDEF"[n % b] + chiffres   # on ajoute à GAUCHE
        n = n // b
    return chiffres or "0"

La méthode marche pour toutes les bases. Ton exemple en base 8 : 167 ÷ 8 = 20 reste 7 ; 20 ÷ 8 = 2 reste 4 ; 2 ÷ 8 = 0 reste 2. Donc (167)₁₀ = (247)₈.

3.3 Méthode 2 : retirer les puissances

Imagine que tu dois payer 167 € avec des billets de 128, 64, 32, 16, 8, 4, 2 et 1 €, chaque billet au plus une fois. Tu prends le plus gros billet possible, puis le suivant, et ainsi de suite. C'est ce que tu as fait pour 167 :

Les billets pris donnent les 1 : (167)₁₀ = 1010 0111. Cette méthode est la plus rapide quand tu connais tes puissances de 2. Pour les bases 8 et 16, les divisions sont plus sûres.

3.4 Binaire, octal, hexadécimal : les paquets

Ton exemple, 1 495 = 10111010111. Les zéros ajoutés à gauche sont en gris.

Pourquoi ça marche ? Un paquet de 3 bits vaut de 0 à 7, exactement un chiffre octal. Et les paquets successifs, en partant de la droite, pèsent 2⁰, 2³, 2⁶, c'est-à-dire 1, 8, 64 : les puissances de 8. Le découpage ne change pas le nombre, il le relit seulement par blocs.

Le tableau à connaître par cœur, avec les 16 paquets de 4 bits. Les 8 premiers donnent aussi les paquets de 3 bits de l'octal (on enlève le 0 de tête).

Ton deuxième exemple, 267 = 1 0000 1011 : en paquets de 3, 100 001 011 donne (413)₈ ; en paquets de 4, 0001 0000 1011 donne (10B)₁₆.

3.5 Entre octal et hexadécimal : le binaire sert de pont

8 et 16 ne sont pas des puissances l'une de l'autre, il n'y a donc pas de raccourci direct. On passe par le binaire, comme dans tes notes avec (ACDC)₁₆ :

3.6 Laboratoire : le convertisseur

Tape un nombre et choisis sa base. La page affiche ses quatre écritures, les paquets de bits, et les divisions successives vers la base de ton choix. Fais toujours la conversion à la main d'abord.

4Additionner et soustraire, dans n'importe quelle base

4.1 L'addition binaire

On pose l'addition en colonnes, comme à l'école, en partant de la droite. Il n'y a que quatre cas à connaître :

« 1 + 1 = 10 » se lit « un plus un égale deux », écrit en binaire : j'écris 0, je retiens 1. Les deux additions de tes notes, avec leurs retenues en rouge :

4.2 La même règle dans toutes les bases

Ton addition en octal, colonne par colonne en partant de la droite (les sommes de chaque colonne sont faites en décimal, de tête) : 2 + 4 = 6 ; 7 + 3 = 10, qui dépasse 8, donc j'écris 10 − 8 = 2 et je retiens 1 ; 6 + 3 + 1 = 10, j'écris 2, je retiens 1 ; 5 + 6 + 1 = 12, j'écris 4, je retiens 1 ; 2 + 2 + 1 = 5 ; 1 + 1 = 2.

Ton addition en hexadécimal : A + C = 10 + 12 = 22, j'écris 22 − 16 = 6, je retiens 1 ; B + D + 1 = 11 + 13 + 1 = 25, j'écris 9 ; B + C + 1 = 24, j'écris 8 ; A + A + 1 = 21, j'écris 5, et la dernière retenue donne un chiffre de plus.

4.3 La soustraction : l'emprunt

Quand le chiffre du haut est trop petit, on emprunte 1 à la colonne de gauche. Ce 1 vaut une base entière dans la colonne actuelle : 10 en décimal, 2 en binaire, 8 en octal, 16 en hexadécimal. C'est ta note : « on ajoute 16 à celui qui emprunte, on retire 1 à sa voisine ».

C'est la soustraction qu'on a faite ensemble. Les « −1 » marquent les colonnes qui ont prêté 1 à leur voisine de droite. À la position 3, on emprunte à travers la position 4, qui vaut 0 et devient 1 :

Ton exemple en hexadécimal : 9 − A est impossible, donc 9 + 16 = 25 et 25 − 10 = 15 = F ; le E a prêté, il devient D, et D − 8 = 5 ; enfin 1 − 0 = 1.

4.4 Laboratoire : poser une opération

Choisis une base et une opération, tape deux nombres, et suis le calcul colonne par colonne avec le bouton « Colonne suivante ».

5Taille fixe : ce que fait vraiment la machine

Sur papier, quand une addition dépasse, on ajoute un chiffre à gauche. Une machine ne peut pas : un registre de 8 bits a 8 cases, pas une de plus. Le bit qui devrait sortir à gauche est perdu pour le résultat. On l'appelle la retenue sortante (carry out).

Sur 8 bits, 255 + 1 donne 0. Le compteur kilométrique fait pareil : après 999 999 km, il affiche 000 000.

Autrement dit, sur n bits, la machine calcule modulo 2ⁿ : elle ne garde que le reste de la division par 2ⁿ. 255 + 1 = 256, et 256 modulo 256 = 0. Retiens bien cette idée : c'est elle qui va permettre de représenter les nombres négatifs.

En Python, les entiers n'ont pas de taille fixe : 255 + 1 donne 256. Mais en C, en Java, ou avec NumPy, les entiers ont une taille fixe et ce phénomène arrive vraiment (section 7.6).

6Les nombres négatifs

6.1 Le problème

En mémoire, il n'y a pas de signe « − » : il n'y a que des bits. Il faut donc une convention, une règle fixée à l'avance qui dit quelles suites de bits représentent des nombres négatifs. Tes notes en contiennent trois, présentées dans un ordre logique : chacune corrige un défaut de la précédente.

C'est comme la date 03/04 : le 3 avril en France, le 4 mars aux États-Unis. Les chiffres sont les mêmes, la convention de lecture change tout.

6.2 Signe et valeur absolue

C'est la première idée de tes notes (page 5) : on réserve le bit de gauche, appelé bit de poids fort (most significant bit), au signe. 0 pour +, 1 pour −. Les 7 autres bits donnent la valeur absolue (sign-magnitude).

Sur 8 bits, on va de −127 à +127. C'est simple à lire, mais il y a deux défauts graves.

• Deux zéros : 0000 0000 (+0) et 1000 0000 (−0, dans tes notes). Pour tester si un nombre est nul, il faudrait vérifier deux motifs.
• L'addition ordinaire ne marche plus. Avec l'additionneur de la section 4, 1 + (−1) donne −2 :

Il faudrait un circuit spécial qui compare les signes, puis additionne ou soustrait les valeurs absolues. C'est faisable, mais lourd.

6.3 Complément à un

Deuxième idée, avec ta définition : « je prends la valeur positive et je l'inverse ». Pour obtenir −x, on inverse chaque bit de x : les 0 deviennent 1 et les 1 deviennent 0 (ones' complement).

Le bit de gauche indique toujours le signe, et on va encore de −127 à +127. Il reste deux zéros : 0000 0000 et 1111 1111 (le « −0 = 1111 1111 » de tes notes).

L'addition marche presque, à une correction près, la retenue circulaire (end-around carry) : si une retenue sort à gauche, on ne la jette pas, on la rajoute au résultat. Exemple, 5 + (−3) :

Pourquoi ce + 1 ? Inverser 8 bits, c'est calculer 255 − x : on soustrait x de 1111 1111, colonne par colonne, sans jamais d'emprunt. Donc en complément à un, −3 est codé par 255 − 3. Quand la somme dépasse 255, la retenue qui sort fait perdre 256, soit 1 de trop par rapport aux 255 utilisés. On rend ce 1 en l'ajoutant.

C'est l'exemple sur 16 bits en bas de la page 8 de tes notes : 3 292 + (−1 406) = 1 886.

Restent deux défauts : deux zéros, et une addition qui demande parfois un deuxième passage dans l'additionneur.

6.4 Complément à deux

C'est la convention de tous les processeurs actuels, le tien compris. Pour obtenir −x, on inverse tous les bits, puis on ajoute 1 (two's complement). C'est la ligne de tes notes : « complément à 1, et je rajoute 1 à la fin ».

Les lignes 32 et 58 sont dans tes notes, et elles sont justes.

• Un seul zéro. Comme dans tes notes : on inverse 0000 0000, on obtient 1111 1111, on ajoute 1 et on obtient 1 0000 0000. Sur 8 bits, le 1 de gauche tombe : −0 = 0.
• De −128 à +127 sur 8 bits. En général, de −2ⁿ⁻¹ à 2ⁿ⁻¹ − 1 sur n bits. Il y a un négatif de plus que de positifs, parce que 0 occupe une place du côté où le bit de gauche vaut 0.
• −128 = 1000 0000 est un cas spécial : son opposé est lui-même (inverser donne 0111 1111, + 1 redonne 1000 0000). Sur 8 bits, +128 n'existe pas.

Pourquoi « inverser puis ajouter 1 » donne l'opposé

Reviens à la section 5 : sur 8 bits, la machine calcule modulo 256. Ajouter 256 ne change rien, puisque ce 256 est une retenue qui tombe à gauche. Pour la machine, −7 et 256 − 7 = 249 sont donc le même nombre. On représente −7 par le motif de 249 : 1111 1001.

Ajouté à 7, ce motif donne 0 : il se comporte exactement comme −7. Et « inverser puis + 1 » calcule justement 256 − x : inverser donne 255 − x (section 6.3), et ajouter 1 donne 256 − x.

Lire un nombre négatif

• Méthode 1 : refaire « inverser + 1 ». L'opération est son propre inverse, puisque l'opposé de l'opposé est le nombre de départ. Pour 1100 0110 : inversé 0011 1001, + 1 donne 0011 1010 = 58. Donc 1100 0110 = −58.
• Méthode 2 : le bit de gauche pèse −128. En complément à deux, les poids sont −128, 64, 32, 16, 8, 4, 2, 1. Ainsi 1111 1001 = −128 + 64 + 32 + 16 + 8 + 1 = −7. C'est la méthode la plus rapide, et elle explique pourquoi le bit de gauche donne le signe : les 7 autres bits valent au plus 127, ce qui ne compense jamais −128.

6.5 Les trois conventions côte à côte, sur 4 bits

Les lignes grisées commencent par un 1 : ce sont celles que chaque convention lit comme négatives, ou comme −0 (sauf en non signé, bien sûr).

Regarde la dernière colonne : de 0000 à 0111, on compte de 0 à 7 ; puis à 1000, on saute à −8 et on remonte jusqu'à −1. Les négatifs sont les grands nombres non signés, décalés de 16 : 1001 vaut 9 en non signé et 9 − 16 = −7 en complément à deux.

6.6 Laboratoire : une même suite de bits, plusieurs lectures

C'est un savoir-faire demandé par ta prof : interpréter une même suite de bits selon différentes conventions. Clique sur les bits et compare les lectures.

6.7 Passer de 8 à 16 bits : l'extension de signe

Pour écrire un nombre signé sur plus de bits, on recopie le bit de signe à gauche (sign extension) :

Compléter un négatif avec des zéros changerait sa valeur : 0000 0000 1111 1001 vaut 249. Avec des 1, c'est juste : sur 16 bits, −7 se code par 65 536 − 7 = 65 529, qui s'écrit bien 1111 1111 1111 1001.

7Additionner et soustraire des nombres signés

7.1 La bonne nouvelle

En complément à deux, on additionne exactement comme en non signé, avec le même circuit, et on ignore la retenue qui sort à gauche. Sur 8 bits, elle vaut 256, et l'enlever ne change rien au calcul modulo 256 (section 6.4).

Et la soustraction n'a pas besoin de circuit à elle : A − B se calcule comme A + (−B). C'est la raison pour laquelle tous les processeurs utilisent le complément à deux : un seul additionneur fait les additions et les soustractions, sur les nombres signés comme non signés. Ta note sur l'UAL, « addition seulement », vient de là (on la précise en section 9).

7.2 La méthode, en six étapes

Règle d'or de l'étape 2 : on ne prend l'opposé que des nombres précédés d'un signe −. Dans 32 + (−58), seul 58 est négatif.

7.3 Cinq exemples détaillés

Exemple 1 : 32 + (−58), l'exemple de tes notes

Le bit de gauche vaut 1 : le résultat est négatif. On refait « inverser + 1 » : 0001 1001 + 1 = 0001 1010 = 26. Le résultat est −26, et 32 − 58 = −26.

Exemple 2 : 58 + (−32), avec une retenue qui sort

Une retenue sort à gauche. En complément à deux, ce n'est pas une erreur : on l'ignore, et le résultat 0001 1010 = 26 est juste.

Exemple 3 : (−32) + (−58), le calcul que tu as fait

Lecture : −128 + 32 + 4 + 2 = −90. Deux négatifs donnent un négatif : tout va bien.

Exemple 4 : une soustraction, 45 − 100

Lecture : −128 + 64 + 8 + 1 = −55. Et 45 − 100 = −55.

Exemple 5 : soustraire un négatif, −20 − (−50)

Retenue ignorée, résultat 0001 1110 = 30.

7.4 Retenue ou débordement ?

Ta prof demande de distinguer ces deux phénomènes, que presque tout le monde confond au début.

Ce sens de C vaut pour l'addition. Après une soustraction faite comme A + (−B), la retenue change de sens : sur les processeurs ARM, C = 1 veut dire « pas d'emprunt », et les processeurs x86 l'inversent. Pour une soustraction, retiens surtout V.

Les quatre cas possibles, sur 8 bits. Chaque addition est lue deux fois : en non signé et en signé.

C = 0, V = 0 : 5 + 3

C = 1, V = 0 : (−1) + (−1)

En signé, le résultat −2 est juste. En non signé, ces bits valent 255 + 255 = 510, qui ne tient pas sur 8 bits : la retenue le signale.

C = 0, V = 1 : 100 + 50

Positif + positif donne un nombre qui commence par 1 : négatif. Le vrai résultat, 150, dépasse 127. En non signé, en revanche, 100 + 50 = 150 est juste.

C = 1, V = 1 : (−100) + (−50)

Négatif + négatif donne un positif : −150 est en dessous de −128. Faux dans les deux lectures.

Laboratoire : le cercle des 4 bits

Voici l'horloge de la section 6.4, pour 4 bits. À l'extérieur, la lecture non signée (0 à 15) ; à l'intérieur, le complément à deux (−8 à 7). Clique sur une case pour choisir A, et règle B avec ses 4 bits. L'arc extérieur montre l'addition non signée : s'il franchit la frontière du haut (15 → 0), C = 1. L'arc intérieur montre l'addition signée : s'il franchit la frontière du bas (7 → −8), V = 1. Les deux arcs arrivent sur la même case : ce sont les mêmes bits, lus de deux façons.

7.5 Laboratoire : une mini-UAL sur 8 bits

Tape deux nombres entre −128 et 255, ou deux suites de 8 bits, puis choisis + ou −. La page applique la méthode de la section 7.2 et affiche les indicateurs C et V, avec les deux lectures du résultat.

7.6 Pourquoi ça compte en sécurité

>>> import numpy as np
>>> np.array([127], dtype=np.int8) + 1
array([-128], dtype=int8)

8Aperçu : caractères et nombres à virgule

Le programme de la séance du 28 septembre mentionne un « aperçu » de ces deux codages. Voici l'essentiel.

8.1 Les caractères

Un texte est une suite de nombres : chaque caractère a un numéro, fixé par une table. La plus ancienne, ASCII, numérote 128 caractères sur 7 bits.

• Le caractère '7' n'est pas le nombre 7 : il vaut 55. Pour retrouver le chiffre, on soustrait le code de '0' : 55 − 48 = 7.
• Une minuscule et sa majuscule diffèrent de 32 = 0010 0000 : un seul bit. Changer la casse, c'est inverser ce bit.
• En Python, ord('A') donne 65 et chr(97) donne 'a'.

Aujourd'hui, on utilise Unicode, qui numérote plus de 150 000 caractères, et UTF-8, qui les écrit sur 1 à 4 octets. Les caractères ASCII gardent leur octet unique ; « é » prend 2 octets, C3 A9. Si un texte UTF-8 est relu octet par octet comme un ancien codage (Latin-1), chaque octet devient un caractère, et « é » s'affiche « é ». Tu as sûrement déjà vu ce bug sur des sites mal configurés.

8.2 Les nombres à virgule

Virgule fixe. On prolonge les poids après la virgule : 2⁻¹ = 0,5, 2⁻² = 0,25, 2⁻³ = 0,125… Ainsi (101,1)₂ = 4 + 1 + 0,5 = 5,5.

Virgule flottante (floating point). On écrit le nombre comme en notation scientifique, 6,02 × 10²³, mais en base 2 : un bit de signe, un exposant, et une mantisse (significand) qui contient les chiffres significatifs. La norme IEEE 754 fixe deux formats courants :

Conséquence importante : 0,1 n'a pas d'écriture binaire finie. Il s'écrit (0,000110011001100…)₂, avec une suite qui se répète sans fin, comme 1/3 = 0,333… en décimal. La machine doit arrondir, et :

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1 + 0.2 == 0.3
False

Évite donc de comparer deux flottants avec ==. En Python, utilise plutôt math.isclose.

9Relecture de tes notes

Ce qui est juste

• Toutes tes conversions : (1011011)₂ = 91, 110110 = 54, 72 = 0100 1000, 167 = 1010 0111 = (247)₈, 1 495 = (2727)₈ = (5D7)₁₆, 267 = (413)₈ = (10B)₁₆, (25)₉ = 23, (ACDC)₁₆ = (126334)₈.
• Ton tableau des entiers de 0 à 21, et les règles « paquets de 3 pour l'octal, paquets de 4 pour l'hexadécimal ».
• Les additions binaires (1011 + 0111, 7 + 9, 14 + 15), l'addition ABBA + ACDC en hexadécimal, les soustractions 1E9 − 8A = 15F et 2026 − 1999 = 27.
• Les compléments à deux de −32 et de −58, et le « un seul zéro » du complément à deux.

Ce qu'il faut corriger

1. −7 en complément à un (page 6). 1110 0000 est le miroir de 0000 0111, pas son inversion. Complément à un : 1111 1000 ; complément à deux : 1111 1001 (section 6.3).
2. La liste de −7 à −11 (page 6). Les valeurs 1111 1000, 1111 0111, 1111 0110, 1111 0101, 1111 0100 sont en complément à un. Écris-le à côté. En complément à deux, chaque valeur a 1 de plus : −7 = 1111 1001, −8 = 1111 1000, −9 = 1111 0111, −10 = 1111 0110, −11 = 1111 0101. Complète les lignes −12 à −15, restées vides, dans les deux conventions.
3. 32 + (−58) et 58 + (−32) (page 7). Tu as utilisé −32 au lieu de 32, puis −58 au lieu de 58. Tes additions calculent en fait (−32) + (−58) = −90 (section 7.3).
4. L'addition en octal (page 8). 125672 + 126334 = 254226, pas 154226 : dans la colonne de gauche, 1 + 1 = 2. Vérification : 43 962 + 44 252 = 88 214 = (254226)₈.
5. Un titre inversé (page 7). 1010 1011 1011 1010 → (125672)₈ est la conversion de ABBA, pas de ACDC.
6. Le complément à un sur 16 bits (page 8). La retenue circulaire s'ajoute une seule fois : le résultat est 0000 0111 0101 1110 = 1 886 (section 6.3).
7. « 1000 0000 = −0 », « 1000 0001 = −1 » (page 5) : c'est juste, mais seulement en signe et valeur absolue. « −0 = 1111 1111 » est du complément à un, et « −1 = 1111 1111 » du complément à deux. Écris toujours la convention à côté d'un nombre signé : la même suite de bits change de valeur d'une convention à l'autre.
8. « UAL : addition seulement » (page 5). L'UAL (unité arithmétique et logique, ALU) fait aussi des opérations logiques (ET, OU, XOR…) : c'est le L de UAL. Ce qui est vrai, c'est qu'il n'y a pas de circuit de soustraction séparé (section 7.1).
9. « RAM : donne les instructions au processeur » (page 5). La RAM ne fait rien d'elle-même : elle stocke les instructions et les données, et c'est le processeur qui va les chercher. Tu verras ce cycle le 16 novembre.
10. « 32 cases = 2³¹ » (page 5). Sur 32 bits, il y a 2³² motifs. L'idée de tes notes, c'est qu'un bit sert au signe : en complément à deux, on va de −2³¹ à 2³¹ − 1, soit environ ± 2,1 milliards.

10Bilan

La suite : la page Les portes logiques, depuis le tout début, pour la séance du 5 octobre. Tu y verras comment deux portes suffisent pour additionner deux bits.