Addition binaire
L’addition de deux nombres binaires est semblable à l’addition en base 10. On commence par additionner les bits de poids faibles. Si les deux bits sont à \(1\), le résultat dépasse la capacité d’un bit et on a alors une retenue qu’on ajoutera au bit suivant. Cette retenue s’appelle carry en anglais. Le tableau ci-dessous représente l’addition de deux bits A et B et donne les valeurs de la somme (Sum) et de la retenue (carry)
| A | B | Sum | Carry |
|---|---|---|---|
| \(0\) | \(0\) | \(0\) | \(0\) |
| \(0\) | \(1\) | \(1\) | \(0\) |
| \(1\) | \(0\) | \(1\) | \(0\) |
| \(1\) | \(1\) | \(0\) | \(1\) |
Cette opération est bien connue et le circuit logique qui l’implémente et le demi-additionneur ou le half-adder en anglais.
A partir du deuxième bit, on doit tenir compte de la retenue. Nous distinguons la retenue entrante (résultant de l’addition du bit précédent) que nous appelons carry in et de la retenue sortante (résultant de l’addition du bit courant) que nous appelons carry out.
Le tableau ci-dessous représente la table de vérité de cette opération :
| A | B | Carry in | Sum | Carry out |
|---|---|---|---|---|
| \(0\) | \(0\) | \(0\) | \(0\) | \(0\) |
| \(0\) | \(1\) | \(0\) | \(1\) | \(0\) |
| \(1\) | \(0\) | \(0\) | \(1\) | \(0\) |
| \(1\) | \(1\) | \(0\) | \(0\) | \(1\) |
| \(0\) | \(0\) | \(1\) | \(1\) | \(0\) |
| \(0\) | \(1\) | \(1\) | \(0\) | \(1\) |
| \(1\) | \(0\) | \(1\) | \(0\) | \(1\) |
| \(1\) | \(1\) | \(1\) | \(1\) | \(1\) |
Le circuit qui implémente cette opération est l’additionneur complet ou full-adder.
Pour additionner deux nombres de 32 bits, il suffit de chaîner 32 additionneurs complets et de laisser entrer un \(0\) comme carry in dans l’additionneur de la première addition. Si le carry out de la dernière addition est à \(1\), ça signifie que le résultat dépasse la capacité du mot de 32 bits.
Note
Les systèmes modernes utilisent une construction plus complexe qu’une suite d’additionneurs complets, car la propagation de la retenue d’un étage à l’autre (ripple-carry) ralentit l’addition. Ces systèmes plus performants s’appellent carry-lookahead adder, mais leur étude sort du cadre de ce cours.
On peut illustrer la retenue (carry out) avec la figure suivante qui représente tous les nombres non signés de 3 bits sur un cercle.
Si l’on additionne deux de ces nombres et qu’on ne repasse pas par le zéro, alors la retenue est à \(0\) et le résultat est correct. Par exemple \(3 + 2 = 5\), on ne repasse pas par zéro, la retenue est à 0 et le résultat est bien \(5\). Si par contre, on repasse par le zéro alors la retenue est à \(1\). Si on fait \(4 + 5\), on repasse par le zéro, la retenue est à \(1\) et le résultat n’est pas \(9\) (car on ne peut pas le représenter avec 3 bits), mais il est tronqué à \(1\).
La retenue est sauvegardée dans un registre spécial du microprocesseur (le registre d’état), plus précisément
dans le “flag” C (pour Carry) de ce registre.