Nombres flottants : exercices corrigés de Première NSI

Une unité contient 1000 millièmes, donc $52$ unités valent $52\,000$ millièmes.

On ajoute les $308$ millièmes : $52\,000 + 308 = 52\,308$. C'est l'entier à stocker, exactement comme « 1234,567 » correspond à 1234567 millièmes ².

En virgule fixe, le pas entre deux valeurs est toujours le même (un millième). Avec le même nombre de bits, la virgule flottante peut couvrir un intervalle numérique plus large ².

Partie entière : $110_2 = 1\times 4 + 1\times 2 + 0\times 1 = 6$.

Partie fractionnaire : $0{,}101_2 = 1\times\frac12 + 0\times\frac14 + 1\times\frac18 = 0{,}5 + 0{,}125 = 0{,}625$.

On additionne : $6 + 0{,}625 = 6{,}625$.

On déplace la virgule de 3 rangs vers la gauche : $1011{,}01_2 = 1{,}01101_2\times 2^3$.

La mantisse est donc $1{,}01101$ et l'exposant vaut $3$. La mantisse commence par un chiffre non nul, ici 1 ².

Valeur : $1011_2 = 8+2+1 = 11$ et $0{,}01_2 = \frac14 = 0{,}25$. Le nombre vaut $11{,}25$.

Vérification : $1{,}01101_2 = 1 + \frac14 + \frac18 + \frac1{32} = 1{,}40625$ et $1{,}40625\times 8 = 11{,}25$.

$0{,}1\times2=0{,}2$ (chiffre 0) ; $0{,}2\times2=0{,}4$ (0) ; $0{,}4\times2=0{,}8$ (0) ; $0{,}8\times2=1{,}6$ (1, reste $0{,}6$) ; $0{,}6\times2=1{,}2$ (1, reste $0{,}2$) ; $0{,}2\times2=0{,}4$ (0) ; $0{,}4\times2=0{,}8$ (0) ; $0{,}8\times2=1{,}6$ (1).

Les 8 premiers chiffres sont donc $00011001$. Le reste $0{,}6$ puis $0{,}2$ revient : le motif $0011$ se répète à l'infini.

Valeur tronquée : $\frac{16}{256}+\frac{8}{256}+\frac{1}{256} = \frac{25}{256} = 0{,}09765625$.

Erreur : $0{,}1 - 0{,}09765625 = 0{,}00234375$.

Pour $1{,}1$, la documentation indique que son écriture binaire est infinie : $1{,}0001100110011\ldots$ ³. Le format double précision coupe ce développement à 52 chiffres binaires, ce qui crée une erreur d'arrondi ³. Le principe est le même qu'ici, avec une erreur bien plus petite.

Chaque chiffre $b_i$ a 2 choix, donc il y a $2^3 = 8$ mantisses. Il y a 4 exposants ($-1,0,1,2$). Au total : $8\times4 = 32$ nombres, ce qui illustre que l'ensemble des flottants est fini ².

Le plus grand a la mantisse $1{,}111_2 = 1+\frac12+\frac14+\frac18 = 1{,}875$.

On la multiplie par $2^2 = 4$ : $1{,}875\times4 = 7{,}5$.

Le suivant de $1{,}010_2\times2^2$ est $1{,}011_2\times2^2$, soit $1{,}375\times4 = 5{,}5$.

L'écart est $5{,}5-5 = 0{,}5$, ce qui vaut aussi $2^2\times\frac18$.

Le réel $5{,}3$ se trouve entre $5$ et $5{,}5$. Sa distance à $5$ est $0{,}3$, à $5{,}5$ elle est $0{,}2$.

Il est donc remplacé par $5{,}5$. Un flottant représente en fait un ensemble de réels voisins, dont les règles d'arrondi fixent les limites ².

Le nombre $1{,}1$ s'écrit en binaire $1{,}0001100110011\ldots$, avec une infinité de chiffres ³.

Le format binaire double précision, le plus courant, coupe ce développement à 52 chiffres binaires ³. Python stocke donc une valeur très proche de $1{,}1$, mais pas égale.

Le produit par 3 multiplie cette petite erreur et subit un nouvel arrondi. Le résultat peut alors différer de $3{,}3$ : la documentation parle de résultats parfois surprenants pour ce calcul ³.

À l'entrée et à la sortie, les langages manipulent des nombres sous forme décimale, mais les calculs passent par des flottants binaires qui sont des approximations ³. C'est pourquoi 1.1 s'affiche correctement alors que la valeur stockée n'est pas exactement $1{,}1$.

Pour $e=3$, l'écart entre deux flottants vaut $2^3\times\frac18 = 1$. Entre $8$ et $16$, les flottants sont donc les entiers $8, 9, 10,\ldots$.

$a+b = 8{,}375$, plus proche de $8$ que de $9$ : le résultat est arrondi à $8$. Ensuite $8+0{,}375 = 8{,}375$ est de nouveau arrondi à $8$. Donc $(a+b)+c = 8$.

$b+c = 0{,}75$, qui s'écrit $1{,}100_2\times2^{-1}$ : il est représentable exactement. Puis $a+0{,}75 = 8{,}75$, plus proche de $9$ (distance $0{,}25$) que de $8$ (distance $0{,}75$). Donc $a+(b+c) = 9$.

La différence vaut $9-8 = 1$. L'associativité de l'addition est mise en défaut, comme le signale la documentation sur les flottants ².

Les calculs flottants travaillent sur des valeurs approchées ². Deux calculs qui donnent le même résultat mathématique peuvent différer d'un tout petit écart, donc a == b peut renvoyer faux à tort.

On teste la proximité : def presque_egaux(a, b, eps): return abs(a - b) <= eps.

Une valeur comme eps = 1e-9 convient pour des nombres proches de 1. Pour des nombres de l'ordre de dix milliards, l'écart entre deux flottants consécutifs (environ $2\times10^{-6}$) est bien plus grand que cette valeur : le test revient alors presque à une égalité stricte. Pour des nombres minuscules, la tolérance serait trop large. On préfère alors une tolérance relative, par exemple abs(a - b) <= eps * max(abs(a), abs(b)).