La représentation des nombres

Cours · informatique (tronc commun des prépas scientifiques), chapitre 11 · prépas scientifiques, tronc commun · le début du chapitre, la suite sur Adloun

La représentation d'un nombre flottant : un bit de signe, un exposant et une mantisse.

11.1 Introduction et motivation

Le chapitre 1 l'avait promis en passant : 0.1 + 0.2 ne vaut pas 0.3, et il faudrait un jour comprendre pourquoi. Ce jour est arrivé. Une machine ne manipule que des suites finies de bits — des $0$ et des $1$ par paquets de taille fixe — et tout nombre doit s'y loger : les entiers, qui y tiennent exactement mais pas tous ; les réels, qui n'y tiennent presque jamais et qu'on y approche par les flottants. De cette finitude découlent des phénomènes que tout programmeur scientifique rencontre : le débordement des entiers à taille fixe (que Python masque, mais pas les autres langages ni les bibliothèques numériques), l'impossibilité de représenter $0, 1$ , l'absorption des petits nombres par les grands, l'annulation catastrophique des soustractions — et l'interdiction, déjà décrétée au chapitre 1, de comparer des flottants par ==.

L'objectif du chapitre est fixé par le programme : sans formalisation théorique, comprendre les enjeux de la représentation pour expliquer les difficultés rencontrées et les précautions à prendre. On saura, à la fin, répondre en connaissance de cause aux trois questions du calcul numérique : que peut contenir un mot machine ? qu'est-ce qu'un flottant, exactement ? et que vaut une égalité entre deux résultats de calcul ?

11.2 Les entiers positifs sur des mots de taille fixe

11.2.1 Le mot machine

Définition 11.1Bit, mot, écriture binaire

Le bit est l'unité d'information : $0$ ou $1$ . Un mot de taille $k$ est une suite de $k$ bits $b_{k - 1} b_{k - 2} \dots b_{1} b_{0}$ ; il représente naturellement l'entier positif

$n = i = 0 \sum k - 1 b_{i} 2^{i}$

— l'écriture en base deux, où chaque position vaut une puissance de $2$ (comme chaque position décimale vaut une puissance de $10$ ). Exemple sur $8$ bits : $1101001 1_{2} = 128 + 64 + 16 + 2 + 1 = 211$ .

Proposition 11.2Plage représentable

Un mot de $k$ bits représente exactement les entiers de $[[0, 2^{k} - 1]]$ : $2^{k}$ valeurs distinctes, ni une de plus ni une de moins — il y a précisément $2^{k}$ suites de $k$ bits. Repères : $8$ bits $\to 0$ à $255$ (les pixels du chapitre 8 !), $32$ bits $\to$ environ $4, 3 \cdot 1 0^{9}$ , $64$ bits $\to$ environ $1, 8 \cdot 1 0^{19}$ .

Exemple 11.3Le débordement

Que vaut $255 + 1$ sur $8$ bits ? L'addition binaire propage une retenue qui sort du mot : $11111111 + 1 = 100000000$ — un bit de trop, qui est perdu. Résultat stocké : $00000000 = 0$ . C'est le débordement (overflow) : sur $k$ bits, l'arithmétique est silencieusement modulo $2^{k}$ . Le bogue du milieu de la dichotomie (chapitre 5) en était une manifestation : $g + d$ peut déborder même quand le résultat final tiendrait ; le compteur kilométrique qui repasse à zéro en est l'image fidèle.

iRemarque

La conversion de base n'est pas un objectif du programme — mais savoir lire une écriture binaire courte et retrouver les puissances de $2$ ( $2^{10} = 1024 \approx 1 0^{3}$ , déjà rencontré au chapitre 5) reste indispensable pour raisonner sur les plages et les débordements. En Python, bin(211) affiche '0b11010011' et int("11010011", 2) revient — utile pour expérimenter.

Exercices du chapitre

Mesurer l'epsilon machine corrigé
La somme dans le bon ordre corrigé
Le trou à $2^{53}$ corrigé
Quantité conjuguée et annulation catastrophique corrigé
Le coût réel des grands entiers corrigé
L'égalité des flottants, version raisonnée corrigé

La suite du cours · Tous les exercices du chapitre