On souhaite pouvoir représenter un nombre à virgule, positif ou négatif. Pour une raison qui apparaîtra plus loin, on qualifie les nombres à virgule de flottants.

Comme on le sait, on peut écrire n'importe quel nombre entier en binaire, que ce nombre soit positif ou négatif :

• $13 = 2^3 + 2^2 + 2^0$ donc on peut écrire $13 = 1101_b$
• $-13 = - 1101_b$

Il est également possible d'écrire des nombres à virgule :

$$13,625 = 2^3 + 2^2 + 2^0 + 2^{-1} + 2^{-3} \Rightarrow 13,75 = 1101,101_b$$

Voici une technique permettant d'être un peu plus efficace, surtout pour la partie à droite de la virgule.

Prenons $x = 55,40625$.

1. Procéder comme précédemment.
   On obtient : $x = 11 0111,01101_b$
2. Décaler la virgule pour la placer juste après le premier $1$.
   $x = 1,1011101101_b \times 10_b^{5}$
   Je rappelle que $10_b = 2$ donc $\times 10_b^5 = \times 2^5$

Le nombre $1,1011101101_b$ est appelé mantisse et le 5 est l'exposant.

Dans d'autres langages (C, C++, …) le flottant ordinaire est codé en 32 bits. On peut demander des flottants plus longs (64 bits), donc plus précis. On parle de réels en double précision, ce sont des double.

Des nombres comme $\pi$ ou $\sqrt{2}$ ne peuvent pas être écrits avec une écriture décimale finie. On n'est donc pas surpris que le type float ne permette pas non plus de les écrire exactement.

Il est plus surprenant de voir que le nombre 0,1 ne peut pas, lui non plus, être écrit en float sans approximation.

Appliquons la méthode vue plus haut pour 0,1 :

• $0,1 \times 2 = \textbf{0},2$
• $0,2 \times 2 = \textbf{0},4$
• $0,4 \times 2 = \textbf{0},8$
• $0,8 \times 2 = \textbf{1},6$
• $0,6 \times 2 = \textbf{1},2$
• $0,2 \times 2 = \textbf{0},4$
• $0,4 \times 2 = \textbf{0},8$
• $0,8 \times 2 = \textbf{1},6$
• …

On en déduit que $0,1 = 0,00011001100110011..._b$. Cette écriture est infinie et il faudra la tronquer pour l'écrire en float. On approximera donc.

>>> x = 0.1
>>> print(x)
0.1

>>> x = 0.1
>>> print(f"{x:0.60f}")
0.100000000000000005551115123125782702118158340454101562500000

exposant + 1023 est codé sur 11 bits, il pourrait donc aller de 0 à 2047. Mais on interdit ces valeurs, on se limite à la plage 1 à 2046.

Ces cas spéciaux ne sont pas à connaître.

exposant + 1023 correspond aux bits 1 à 12 de la représentation (le bit 0 étant le signe).

Les valeurs 0 et 2047 sont gardées pour des nombres spéciaux.

• Pour 0 on dit que le nombre est dénormalisé.// Dans ce cas, mantisse = 0,[52 bits de la mantisse] et sur les 11 bits précédent on code exposant + 1022.// Cette technique permet d'atteindre 0 ce qui serait impossible autrement.
• 2047 sert pour des cas spéciaux comme $\infty$ ou NaN : not a number.

Les nombres flottants ne sont généralement pas des représentations exactes des nombres. Ils supposent une approximation qui peut avoir des effets surprenants.

Par exemple : 0.1 + 0.2 != 0.3

N'hésitez pas à tester en console les exemples proposés.

>>> 0.1 + 0.1 + 0.1
0.30000000000000004

>>> 1e16 + 1 - 1e16
0.0
>>> 1e16 - 1e16 + 1
1.0

>>> 2**1024
179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216
>>> 2.0**1024
OverflowError: (34, 'Numerical result out of range')

x = 10
while x != 0:
  x -= 0.1
print("fini")