Informatique au lycée Faustin Fleret

Nous avons vu comment sont représentés les entiers relatifs au sein d'un ordinateur. Nous allons maintenant voir comment sont représentés les nombres réels, appelés ici nombres flottants.

Conversion des nombres réels en base B en base 10

Pour pouvoir convertir des nombres à virgules, on va utiliser la même méthode que pour les entiers mais avec des puissances négatives pour les nombres après la virgule.

Exemples :
128,75₁₀ = 1 x 10² + 2 x 10¹ + 8 x 10⁰ + 7 x 10^-1 + 5 x 10^-2
101,01₂= 1 x 2² + 1 x 2⁰ + 1 x 2^-2= 1 x 4 + 1 + 0,25 = 5,25₁₀
AE,1F₁₆= 10 x 16¹ + 14 x 16⁰ + 1 x 16^-1 + 15 x 16^-2 = 160 + 14 + 0,0625 + 0,5859375
AE,1F₁₆ = 174,121093755₁₀

Conversion des nombres à virgule en base B

Cela n'est faisable le plus souvent que de manière approchée, il faudra donc donner la précision voulue.
Pour la partie entière, on fait comme pour les entiers
Pour la partie décimale :

1. On multiplie la partie entière par B
2. On note la partie entière obtenue
3. On recommence avec la partie décimale restante
4. On s'arrête quand la partie décimale est nulle ou quand la précision souhaitée est atteinte

Exemple : Convertir 19,109 en binaire avec 8 bits pour la partie décimale.

• Conversion de 19 : (1 0011)₂
• Conversion de 0,109 :
• 0,109 x 2 = 0,218 + 0
• 0,218 x 2 = 0,436 + 0
• 0,436 x 2 = 0,872 + 0
• 0,872 x 2 = 0,744 + 1
• 0,744 x 2 = 0,488 + 1
• 0,488 x 2 = 0,976 + 0
• 0,976 x 2 = 0,952 + 1
• 0,952 x 2 = 0,904 + 1

19,109 peut être représenté par (0001 0011,0001 1011)₂

Représentation des flottants dans un ordinateur

Les nombres à virgule flottante sont représentés en binaire dans un ordinateur. La représentation des nombres à virgule flottante suit la norme IEEE 754. Cette norme définit deux formats de nombres à virgule flottante : le format simple précision (ou flottant sur 32 bits) et le format double précision (ou flottant sur 64 bits).

Le format simple précision utilise 32 bits pour représenter un nombre à virgule flottante. Le premier bit est le bit de signe, qui indique si le nombre est positif ou négatif. Les 8 bits suivants sont l'exposant, qui indique la puissance de 2 à laquelle le nombre doit être multiplié. Les 23 bits restants sont la mantisse, qui représente la partie fractionnaire du nombre.

Que cela soit en simple précision ou en double précision, la norme IEEE754 utilise :

• 1 bit de signe (1 si le nombre est négatif et 0 si le nombre est positif)
• des bits consacrés à l'exposant (8 bits pour la simple précision et 11 bits pour la double précision)
• des bits consacrés à la mantisse (23 bits pour la simple précision et 52 bits pour la double précision)

Nous pouvons vérifier que l'on a bien 1 + 8 + 23 = 32 bits pour la simple précision.

Le format double précision utilise 64 bits pour représenter un nombre à virgule flottante. Le premier bit est le bit de signe, qui indique si le nombre est positif ou négatif. Les 11 bits suivants sont l'exposant, qui indique la puissance de 2 à laquelle le nombre doit être multiplié. Les 52 bits restants sont la mantisse, qui représente la partie fractionnaire du nombre.

La représentation binaire des nombres à virgule flottante permet de représenter des nombres très grands ou très petits, avec une grande précision. Cependant, elle présente aussi certaines limites, telles que la difficulté de représenter certains nombres exactement (par exemple, 0.1 en base 10 a une représentation infinie en binaire) et la perte de précision lors des opérations mathématiques sur des nombres très grands ou très petits.

Voici un exemple de nombre à virgule flottante en format simple précision :

Prenons le nombre décimal 3,14159.

Pour le représenter en binaire en format simple précision, il faut suivre les étapes suivantes :

1. Convertir la partie entière en binaire : 3 en binaire donne 11.
2. Convertir la partie fractionnaire en binaire : 0,14159 peut être multiplié par 2 pour obtenir la première décimale binaire, soit 0,28318. On multiplie ensuite 0,28318 par 2 pour obtenir la deuxième décimale binaire, soit 0,56636. En continuant ainsi, on obtient la représentation binaire suivante : 0,0010 0001 0001 0010 0111 1101.
3. Normaliser le nombre en déplaçant la virgule à gauche jusqu'à ce qu'il ne reste qu'un seul chiffre avant la virgule, tout en augmentant l'exposant en conséquence. On obtient donc 1,570795 x 2^1.
4. Ajouter le bit de signe : comme le nombre est positif, ce bit vaut 0.

Le nombre à virgule flottante en format simple précision correspondant à 3,14159 est donc représenté en binaire par 0 10000000 01000010010011111011011.

Pour déterminer la représentation au format simple précision de (0,25)10 en binaire et en hexadécimal, nous allons suivre les étapes suivantes :

1. Convertir la partie fractionnaire en binaire : 0,25 multiplié par 2 donne 0,5, on garde le bit 0 avant la virgule. Ensuite, on multiplie 0,5 par 2 donne 1,0, on garde le bit 1 après la virgule. Donc, la partie fractionnaire en binaire est 0,01.
2. Normaliser le nombre en déplaçant la virgule à gauche jusqu'à ce qu'il ne reste qu'un seul chiffre avant la virgule, tout en augmentant l'exposant en conséquence. On obtient donc 1,0 x 2^(-2).
3. Ajouter le bit de signe : comme le nombre est positif, ce bit vaut 0.

Ainsi, la représentation en binaire du nombre (0,25)10 en simple précision est :

0 01111101 00000000000000000000000

En hexadécimal, la représentation est :

0x3E800000

Pour obtenir cette valeur, on doit regrouper les 32 bits en quatre groupes de 8 bits et convertir chacun d'eux en leur valeur hexadécimale. Dans ce cas, les groupes sont 0 01111101 00000000 00000000 00000000, qui en hexadécimal donne 0x3E 0x80 0x00 0x00.

La réponse à la question posée ci-dessus est (0,099999994)₁₀, or, en toute logique, nous devrions trouver (0,1)₁₀. Cette "légère" erreur est logique quand on y réfléchit un peu. N'oubliez qu'à cause de la limitation de la mantisse à 23 bits, nous avons dû "tronquer" notre résultat (de toutes les façons, même avec une mantisse beaucoup plus grande, on aurait aussi eu le problème, car le schéma "0011" se répète à l'infini). Cette représentation avec un nombre limité de bits des nombres flottants est un problème classique en informatique. Cela peut entrainer des erreurs d'arrondi dans les calculs qui peuvent être très gênants si on n'y prend pas garde :