Représentation des nombres entiers

Nombres positifs

Principe

Représentation d’un nombre entier positif ou nul : binaire de base

Nombres négatifs

Problème

comment représenter le signe -

• avec uniquement des bits
• dans un nombre de bits fixé

Bit de signe

1 bit indique le signe, le reste = le nombre en valeur absolue

exemples sur 8 bits :

• $0\ 000\ 0101\ =\ +5$
• $1\ 000\ 0101\ =\ -5$

inconvénients :

• comment représenter zéro ? $1\ 000\ 0000$ et $0\ 000\ 0000$
• l’addition ne marche plus : $-5 + 3$

$$1\ 000\ 0101 + 0\ 000\ 0011 = 1\ 000\ 1000 = -8$$

Complément à deux

• ne change rien pour les nombres positifs
• on obtient les nombres négatifs en
  • inversant tous les bits de la valeur absolue (= complément à 1)
  • on ajoute 1 au résultat (sans s’occuper des dépassements)

Complément à deux : exemples

• pour coder -5 sur 8 bits
  1. $0000\ 0101$
  2. $1111\ 1010$
  3. $1111\ 1011$
• coder -3 sur 16 bits
  1. $0000\ 0000\ 0000\ 0011$
  2. $1111\ 1111\ 1111\ 1100$
  3. $1111\ 1111\ 1111\ 1101$
  vérification dans RISC simulator 1111 1111 1111 1101

Complément à deux : zéro et addition

• pour coder -0
  1. $0000\ 0000$
  2. $1111\ 1111$
  3. $0000\ 0000$

avantage : l’addition fonctionne correctement

$$-5 + 8 = 1111\ 1011 + 0000\ 1000 = 0000\ 0011 = 3$$

(la retenue qui sort à gauche est ignorée)

Complément à deux : décodage et plage

Lire un nombre en complément à deux :

• premier bit à 0 : nombre positif, on lit le binaire normalement
• premier bit à 1 : nombre négatif, on refait le chemin du codage à l’envers pour obtenir sa valeur absolue : on retire 1, puis on inverse tous les bits (complément à 1)

exemple pour $1111\ 1011$ :

1. on retire 1 : $1111\ 1010$
2. complément à 1 : $0000\ 0101 = 5$
3. donc $1111\ 1011 = -5$

Sur $n$ bits, on représente les entiers de $-2^{n-1}$ à $2^{n-1}-1$ :

• 8 bits : de $-128$ à $127$
• 16 bits : de $-32\ 768$ à $32\ 767$

Complément à deux : exos conversion

Complément à deux : exos opérations

Représentation des nombres décimaux

Représentation en virgule fixe

Principe

lorsque le nombre de chiffres en base 10 après la virgule est fixé, on peut simplement décaler tous les nombres d’un facteur donné

exemple opérations financières en 64 bits :

• on ne se préoccupe pas des millièmes de centimes
• on a rarement à traiter des opérations dépassant plusieurs milliers de milliards d’euros (en complément à deux sur 64 bits, on va jusqu’à $2^{63} - 1 = 9\ 223\ 372\ 036\ 854\ 775\ 807$)

=> on code les montants en centimes, ou en décicentimes, ou en centicentimes

Exercices

Conversion décimal à virgule - binaire à virgule

Principe

Conversion en binaire à virgule :

• on fait des divisions successives pour la partie entière
• on fait des multiplications successives par 2 pour la partie à virgule

Exemple : conversion de 28,8625 en binaire

• conversion de 28 : $11100_2$

• conversion de 0,8625 :

• $0,8625 \times 2 = 1,725 = 1 + 0,725$

• $0,725 \times 2 = 1,45 = 1 + 0,45$

• $0,45 \times 2 = 0,9 = 0 + 0,9$

• $0,9 \times 2 = 1,8 = 1 + 0,8$

• $0,8 \times 2 = 1,6 = 1 + 0,6$

• $0,6 \times 2 = 1,2 = 1 + 0,2$

• $0,2 \times 2 = 0,4 = 0 + 0,4$

• $0,4 \times 2 = 0,8 = 0 + 0,8$

==> $11100,11011100..._2$

Exercices

Représentation en virgule flottante

Principe

pour les calculs scientifiques (la mole :) on peut avoir besoin de nombres très grands ou très petits => notation scientifique

pour représenter un nombre en notation scientifique dans un nombre fixé de bits, on utilise une représentation normalisée (IEEE 754)

en gros

• 1er bit = le signe
• e bits suivants = l’exposant
• le reste des bits = la mantisse

l’exposant peut être positif ou négatif; on pourrait le représenter en complément à deux, mais ce n’est pas pratique pour les comparaisons => on décale sa valeur de $2^{e-1}-1$

Flottant 32 bits (float32)

• 1 bit de signe (1 pour négatif)
• 8 bits pour l’exposant
• 23 bits pour la mantisse (la partie après la virgule)

==> on décale l’exposant de $2^{8-1}-1=127$

• exposant réel 3 → exposant stocké 130
• exposant réel 0 → exposant stocké 127
• exposant réel 10 → exposant stocké 137

Valeur du nombre

$$v = s \times 2^{e-127} \times 1{,}m_2$$

• s = 1 ou -1 selon le bit de signe
• e est l’exposant stocké
• m est la mantisse : $1{,}m_2$ se lit en binaire (le 1 avant la virgule est implicite)

Exemple : $-118,625$ en float32

• le signe (1er bit) : nombre négatif, le premier bit est $1$

• écriture du nombre (sans le signe) en binaire : $111\ 0110,101$

• décalage de la virgule vers la gauche, de façon à ne laisser qu’un 1 sur sa gauche : $1110110,101_2 = 1,110110101_2 \times 2^6$. C’est un nombre flottant normalisé : la mantisse est la partie à droite de la virgule, remplie de 0 vers la droite pour obtenir 23 bits. Cela donne $110\ 1101\ 0100\ 0000\ 0000\ 0000$ (on omet le 1 avant la virgule, qui est implicite).

• l’exposant est égal à $6$, il faut le décaler et le convertir. Pour le format 32-bit IEEE 754, le décalage est $2^{8-1}-1 = 127$. Donc $6 + 127 = 133$ et $133_{10} = 1000\ 0101_2$.

Résultat : $$-118,625_{10} = 1100\ 0010\ 1110\ 1101\ 0100\ 0000\ 0000\ 0000_2 = C2ED4000_{16}$$

Exercices

Aide : vérification et entraînement sur

https://www.h-schmidt.net/FloatConverter/IEEE754.html

Conséquences

Les valeurs stockées en virgule flottante ne sont pas exactes, idem pour les calculs

• on ne teste pas l’égalité de deux flottants (en Python, 0.1 + 0.2 == 0.3 vaut False, voir l’exercice $0,1 + 0,2$)
• on fait attention aux erreurs qui s’accumulent dans les calculs