Chapitre 8 : Flottants

Partie A - Rappels sur l'écriture scientifique des nombres décimaux

L'écriture scientifique d'un nombre décimal est composée de trois parties :

• un signe, qui peut être plus ou moins,
• une mantisse, qui un nombre décimal compris entre \(1\) (inclus) et \(10\) (exclu),
• un exposant, qui est un nombre entier positif ou négatif.

Par exemple, l'écriture scientifique du nombre \(2030\) est : \(+ 2,03 \times 10^3\).

Le signe est plus, la mantisse est \(2,03\) et l'exposant est \(3\).

En Python, une façon d'afficher l'écriture scientifique d'un nombre n est d'utiliser la commande suivante :

print("{:e}".format(n))

La mantisse s'affiche par défaut avec six chiffres après la virgule, mais il est possible d'en afficher davantage ou moins :

print("{:.2e}".format(n))  # 2 chiffres après la virgule pour la mantisse
print("{:.10e}".format(n))  # 10 chiffres après la virgule pour la mantisse

\(0\) n'a pas d'écriture scientifique

On remarque qu'un nombre ne peut pas être écrit dans ce format : le nombre \(0\). En effet, la mantisse devrait être égale à \(0\), ce qui est exclu par définition.

Exercice 8-01 : Écriture scientifique décimale

Objectif : Déterminer l'écriture scientifique décimale de nombres, à la main et avec Python.

Carnet Jupyter à télécharger ici

Carnet Jupyter accessible sur CAPYTALE

Partie B - Écriture binaire des nombres

Rappel concernant les nombres entiers positifs

Donner l'écriture binaire d'un nombre entier positif, cela revient à écrire ce nombre sous la forme d'une somme de puissances positives de \(2\).

Par exemple, pour le nombre \(2030\) :

\(2030 = 1024 + 512 + 256 + 128 + 64 + 32 + 8 + 4 + 2\) c'est-à-dire :

\(2030 = 2^{10} + 2^9 + 2^8 + 2^7 + 2^6 + 2^5 + 2^3 + 2^2 + 2^1\) et l'écriture binaire de \(2030\) est donc :

\(2030 = (11111101110)_2\).

On peut vérifier le résultat obtenu grâce à la fonction bin, qui renvoie l'écriture binaire sous la forme d'une chaîne de caractères qui commence par 0b :

print(bin(2030))  # affiche "0b11111101110"

Exercice 8-02 : Écriture binaire de nombres entiers positifs

Objectif : Déterminer l'écriture binaire de nombres entiers positifs, à la main et avec Python.

Carnet Jupyter à télécharger ici

Carnet Jupyter accessible sur CAPYTALE

Écriture binaire des nombres compris entre 0 et 1

Le principe est le même pour obtenir l'écriture binaire des nombres à virgule. On s'autorise simplement d'utiliser aussi des puissances négatives de \(2\).

Par exemple, pour le nombre \(0,6875\) :

\(0,6875 = 0,5 + 0,125 + 0,0625\) c'est-à-dire :

\(0,6875 = 2^{-1} + 2^{-3} + 2^{-4}\) et l'écriture binaire de \(0,6875\) est donc :

\(0,6875 = (0,1011)_2\).

Exercice 8-03 : Écriture binaire de nombres à virgule

Objectif : Déterminer à la main l'écriture binaire de nombres non entiers.

Énoncé

Donner l'écriture binaire des nombres \(0,3125\) et \(0,515625\).

Remarquons que les nombres réels qui ont une écriture décimale infinie ont aussi une écriture binaire infinie. Par exemple :

\(1/3 = 0,33333333... = (0,01010101...)_2\).

Il existe par contre des nombres réels qui ont une écriture décimale finie mais qui ont une écriture binaire infinie. Par exemple :

\(1/5 = 0,2 = (0,00110011...)_2\).

Exercice 8-04 : Écriture binaire infinie

Objectif : Déterminer à la main l'écriture binaire infinie d'un nombre.

Énoncé

Donner les 10 premiers bits après la virgule de l'écriture binaire des nombres \(0,1\) et \(0,3\).

Partie C - Représentation des flottants en machine (norme IEEE 754)

La norme informatique la plus couramment utilisée pour représenter les nombres flottants est la norme IEEE 754 mise au point en 1985. Il s'agit d'une variante de l'écriture scientifique en base 2, dans laquelle la mantisse est un nombre compris entre \(1\) (inclus) et \(2\) (exclu).

Les flottants peuvent être représentés sur 32 bits (format dit de simple précision) ou sur 64 bits (format dit de double précision).

Format	Signe s	Exposant e	Mantisse m	Total
simple précision	1 bit	8 bits	23 bits	32 bits
double précision	1 bit	11 bits	52 bits	64 bits

Principe de la représentation

Le bit le plus à gauche (bit de poids fort) correspond au signe du flottant :

• 0 pour un flottant positif,
• 1 pour un flottant négatif.

Les 8 ou 11 bits suivants correspondent à l'exposant e. Comme e peut être positif ou négatif, on ne représente pas directement l'entier e mais :

• l'entier e + 127 sur 8 bits pour le format simple précision,
• l'entier e + 1023 sur 11 bits pour le format double précision.

Les 23 ou 52 derniers bits correspondent à la mantisse m. Comme m est par définition compris entre \(1\) et \(2\), c'est uniquement la partie fractionnaire (partie située après la virgule) du nombre m - 1 qui est représentée sur 23 ou 52 bits.

Exemple

Représentons par exemple sur 32 bits le nombre flottant -0,2. Il est négatif donc le bit le plus à gauche de sa représentation est un 1.

De plus, nous avons vu précédemment que \(0,2 = (0,00110011...)_2 = (1,10011001...)_2 \times 2^{-3}\). L'exposant e est donc \(-3\) et la mantisse m est $1,10011001 ... $.

On écrit sur 8 bits le nombre e + 127 (c'est-à-dire 124) ce qui donne 01111100.

Enfin, on écrit sur 23 bits la partie fractionnaire de m-1 (c'est-à-dire \(0,10011001...\)) ce qui donne 10011001100110011001100(1), arrondi à 10011001100110011001101.

La représentation sur 32 bits obtenue pour le flottant -0,2 est donc 1 01111100 10011001100110011001101.

Représentation du nombre \(0\)

Nous avons dit que le nombre \(0\) n'a pas d'écriture scientifique. Il est par convention représenté par 0 00000000 00000000000000000000000 sur 32 bits.

Exercice 8-05 : Représentation de flottants sur 32 bits

Objectif : Déterminer à la main la représentation sur 32 bits d'un nombre flottant.

Carnet Jupyter à télécharger ici

Carnet Jupyter accessible sur CAPYTALE

Partie D - Problème du test d'égalité de deux flottants

La représentation des nombres flottants en machine est approximative lorsque leur écriture binaire est infinie ou composée de trop de bits après la virgule.

Par exemple, les nombres \(0,1\) et \(0,2\) ont une écriture binaire infinie, d'où les problèmes d'arrondis qui font que l'expression booléenne 0.1 + 0.2 == 0.3 vaut False.

C'est la raison pour laquelle il faut absolument éviter d'utiliser des conditions dans lesquelles on teste l'égalité entre deux flottants.

Il est fortement recommandé de remplacer un test d'égalité flottant1 == flottant2 par un test du type abs(flottant1 - flottant2) < 10**-n qui est un test d'égalité approchée (avec n chiffres après la virgule de précision).

Exercice 8-06 : Problèmes d'arrondis lors du calcul sur les flottants

Objectifs :

• Constater sur des exemples les problèmes provoqués par la représentation approximative des flottants en machine.
• Utiliser des tests d'égalité approchée.

Carnet Jupyter à télécharger ici

Carnet Jupyter accessible sur CAPYTALE

Partie E - Exercices

Exercices 8-07 et 8-08

Exercice 8-07 : Représentation sur 32 bitsExercice 8-08 : Arrondis sur les flottants

Énoncé

1. Donner la valeur décimale du nombre flottant dont la représentation sur 32 bits est : 1 01111110 11110000000000000000000.

2. Même question pour le nombre flottant dont la représentation sur 32 bits est : 0 10000011 11100000000000000000000.

Carnet Jupyter à télécharger ici

Carnet Jupyter accessible sur CAPYTALE

Ce qu'il faut savoir et savoir faire

• Donner l'écriture scientifique décimale d'un nombre.
• Afficher l'écriture scientifique décimale d'un nombre n avec la commande print("{:e}".format(n))
• Déterminer l'écriture binaire d'un entier positif.
• Afficher l'écriture binaire d'un entier avec la fonction bin.
• Déterminer l'écriture binaire d'un nombre décimal positif.
• Déterminer la représentation d'un nombre flottant sur 32 bits.
• Retrouver un flottant à partir de sa représentation sur 32 bits.
• Ne pas utiliser de test d'égalité sur les flottants, mais des tests d'égalité approchée.