Aller au contenu
Encyclopédie informatique Édition 2026

La représentation des nombres

Partie 2 sur 3

Niveau de lecture :
Vidéo de cette partieenviron une minute et demie, avec voix et texte à l’écran

4Les nombres à virgule : le défi

Comment écrire 5,25 en binaire ? Comme en décimal, on utilise une virgule, mais les positions situées à droite valent des moitiés : 1/2, 1/4, 1/8, 1/16… Le nombre binaire 101,01 vaut donc 4 + 1 + 0 + 1/4 = 5,25. Attention : il ne se lit pas « cent un virgule zéro un », puisque c’est un nombre binaire, mais bien 5,25 en décimal.

4.1La virgule fixe

Une première approche consiste à décider, une fois pour toutes, que la virgule se trouve à une place fixe : par exemple, sur 32 bits, 16 bits pour la partie entière et 16 bits pour la partie fractionnaire. C’est la virgule fixe. Elle est simple, rapide, et utilisée dans certains petits systèmes (traitement du son, microcontrôleurs). Son défaut : l’étendue est limitée. Avec 16 bits pour la partie entière, on ne dépasse pas 65 535, et on ne distingue pas de valeurs plus petites que 1/65 536. Impossible d’écrire à la fois la masse d’un électron (10−30 kg) et celle du Soleil (1030 kg).

4.2La virgule flottante : la notation scientifique

La solution retenue par les ordinateurs reprend la notation scientifique des physiciens, où l’on écrit 12 300 sous la forme 1,23 × 104. On sépare deux informations : les chiffres significatifs (la mantisse, 1,23) et l’ordre de grandeur (l’exposant, 4). La virgule « flotte » : on la déplace en changeant l’exposant. En binaire, c’est la même idée avec des puissances de 2 : 101,01 s’écrit sous la forme 1,0101 × 22. En se donnant une mantisse et un exposant de tailles fixes, on couvre à la fois les très grands et les très petits nombres, avec une précision relative constante.

4.3Pourquoi 0,1 est un problème

Il y a un obstacle fondamental. Les nombres qui s’écrivent avec un nombre fini de chiffres après la virgule en décimal n’ont pas forcément cette propriété en binaire. En décimal, 1/3 vaut 0,3333… sans fin ; on ne peut pas l’écrire exactement. En binaire, c’est le cas de 1/10 : on trouve 0,000110011001100…, avec le motif 0011 qui se répète indéfiniment. Un nombre binaire de longueur finie ne peut donc écrire que des fractions dont le dénominateur est une puissance de 2 (1/2, 1/4, 3/8…). Tous les autres, dont 0,1, 0,2 et 0,3, sont arrondis au plus proche représentable. De là viennent les résultats surprenants comme 0,1 + 0,2 = 0,30000000000000004 que l’on obtient dans presque tous les langages (voir la partie 5.6).

5La norme IEEE 754

Dans les années 1970, chaque fabricant d’ordinateurs avait sa propre façon de représenter les nombres à virgule, ce qui rendait les résultats différents d’une machine à l’autre. La norme IEEE 754, publiée en 1985 par l’IEEE (Institute of Electrical and Electronics Engineers, grande association de normalisation des techniques électriques et informatiques) à l’initiative notamment du mathématicien William Kahan, a mis fin à cette confusion. Elle a été révisée en 2008 et en 2019. Presque tous les processeurs actuels l’appliquent, ainsi que les cartes graphiques (voir les processeurs graphiques).

5.1Trois composantes

Prenons le format sur 32 bits, dit « simple précision ». Le nombre est découpé en trois champs :

  • le signe, représenté par un seul bit, le bit de poids fort (le plus à gauche) : 0 pour positif, 1 pour négatif ;
  • l’exposant, codé sur les 8 bits suivants ;
  • la mantisse (la partie qui suit la virgule), sur les 23 bits restants.

On écrit la forme ainsi : s eeeeeeee mmmmmmmmmmmmmmmmmmmmmmm, où s désigne le bit de signe, les e les bits de l’exposant et les m ceux de la mantisse.

UN NOMBRE SUR 32 BITS (SIMPLE PRÉCISION) : L’EXEMPLE 525,5 signe (1 bit) 0 exposant (8 bits) 10001000 mantisse (23 bits) 00000110110000000000000 Lecture, champ par champ : signe 0 : le nombre est positif exposant 10001000 vaut 136 ; on retire le biais 127 : 136 − 127 = 9 mantisse les bits après la virgule : 1,0000011011 (le 1 de gauche est implicite) valeur 1,0000011011 en binaire × 2 puissance 9 = 1000001101,1 = 525,5 en hexadécimal 0100 0100 0000 0011 0110 0000 0000 0000 = 44036000
Figure 2. Un nombre sur 32 bits : 1 bit de signe, 8 bits d’exposant, 23 bits de mantisse. L’exemple est le nombre 525,5.

5.2La formule

La valeur du nombre se calcule par la formule suivante :

(−1)S × 2(E − 127) × (1 + F)

où S est le bit de signe (on comprend ainsi pourquoi 0 signifie positif : (−1)0 = 1), E la valeur de l’exposant lu comme un entier naturel, et F la partie fractionnaire, la seule que l’on stocke, que l’on ajoute à 1 pour obtenir la mantisse complète.

Deux détails méritent explication.

  • Le « 1 » implicite. Après normalisation (mettre la virgule après le premier chiffre significatif), la mantisse binaire commence toujours par 1 : on l’écrit 1,XXXX. Comme ce 1 est toujours là, inutile de le stocker : on gagne un bit de précision. Les 23 bits stockés donnent en réalité 24 bits de précision.
  • Le biais de 127. L’exposant peut être négatif (pour les nombres inférieurs à 1). Plutôt que d’utiliser le complément à deux, la norme stocke l’exposant avec un décalage (un « biais ») de 127 : on lui ajoute 127 avant de le stocker. Un exposant réel de 0 est stocké 127 (01111111), un exposant de 9 est stocké 136, un exposant de −1 est stocké 126. Avantage : en comparant les codes comme des naturels, on compare correctement les nombres positifs.

5.3Premier exemple : 525,5

Suivons le calcul, étape par étape.

  1. 525,5 est positif : le bit de signe est 0.
  2. En binaire, 525,5 s’écrit 1000001101,1 (512 + 8 + 4 + 1 + 1/2).
  3. On normalise : 1,0000011011 × 29 (on a déplacé la virgule de 9 positions vers la gauche).
  4. On ajoute le biais à l’exposant : 9 + 127 = 136, soit 10001000 en binaire.
  5. La mantisse est la partie qui suit la virgule : 0000011011, complétée par des zéros jusqu’à 23 bits : 00000110110000000000000.

Le résultat est 0 10001000 00000110110000000000000. Regroupé par paquets de quatre bits : 0100 0100 0000 0011 0110 0000 0000 0000, soit 44036000 en hexadécimal.

Une coquille fréquente. On trouve parfois le résultat hexadécimal écrit sous la forme « 4403600 » (sept chiffres), ce qui est incorrect : un nombre de 32 bits s’écrit avec huit chiffres hexadécimaux. La bonne valeur est 44036000.

5.4Second exemple : −0,625

  1. Le nombre est négatif : le bit de signe vaut 1.
  2. 0,625 s’écrit 0,101 en binaire (1/2 + 1/8).
  3. On normalise : 1,01 × 2−1.
  4. L’exposant stocké est −1 + 127 = 126, soit 01111110.
  5. La mantisse est 01, complétée de zéros : 01000000000000000000000.

Le résultat est 1 01111110 01000000000000000000000, soit 1011 1111 0010 0000 0000 0000 0000 0000, c’est-à-dire BF200000 en hexadécimal.

Une erreur fréquente. On trouve parfois l’exposant écrit sous la forme « 1111110 » (7 bits seulement, le zéro de gauche ayant été oublié), puis un résultat « FF 20 00 00 ». Avec l’exposant correct sur 8 bits (01111110), le résultat est BF 20 00 00. Le premier chiffre vaut B (1011) et non F (1111).

5.5Les valeurs spéciales

On lit souvent deux conditions sur l’exposant : l’exposant 00000000 serait « interdit » et l’exposant 11111111 serait interdit, mais servirait à signaler des erreurs, la configuration étant alors appelée NaN, pour Not a Number, c’est-à-dire « pas un nombre ». On lit aussi que les exposants pourraient aller de −254 à 255. Ces affirmations demandent à être précisées et corrigées.

La norme réserve effectivement les deux valeurs extrêmes de l’exposant pour des cas particuliers, mais ils ne sont pas « interdits » : ils servent. Les autres valeurs (de 1 à 254) correspondent aux nombres ordinaires, ce qui donne, une fois le biais retiré, des exposants réels de −126 à +127 (et non de −254 à 255).

Tableau 3. Les cas particuliers du format 32 bits.
Exposant stockéMantisseSignification
00000000nullezéro, positif (+0) ou négatif (−0) selon le signe
00000000non nullenombre « dénormalisé » : très proche de zéro, sans le 1 implicite
1 à 11111110quelconquenombre ordinaire (exposant réel de −126 à 127)
11111111nullel’infini, positif ou négatif (+∞, −∞)
11111111non nulleNaN : résultat qui n’est pas un nombre

Ce qu’il faut en retenir :

  • Le zéro ne peut pas s’écrire avec un « 1 » implicite : on lui réserve donc l’exposant 0 et une mantisse nulle. Le format a un zéro positif et un zéro négatif, qui se comparent comme égaux.
  • Les nombres dénormalisés comblent le trou entre zéro et le plus petit nombre normal, ce qui évite qu’une soustraction entre deux nombres proches donne brutalement zéro.
  • L’infini est le résultat d’un dépassement de capacité ou d’une division d’un nombre non nul par zéro : le programme n’est pas interrompu, il continue avec la valeur infinie.
  • Le NaN est le résultat d’une opération sans réponse : 0/0, la racine carrée d’un négatif, ∞ − ∞. Il a une propriété particulière : il n’est égal à rien, pas même à lui-même. C’est le seul cas où x == x peut être faux, et on s’en sert pour le détecter.

5.6La précision et les arrondis

Avec 24 bits de précision, un nombre en simple précision a environ 7 chiffres décimaux significatifs. Au-delà, il est arrondi. Les nombres représentables ne sont pas répartis uniformément : ils sont serrés près de zéro et de plus en plus espacés quand leur valeur grandit, car l’écart entre deux nombres voisins double chaque fois que l’exposant augmente de 1 (figure 3).

LES NOMBRES REPRÉSENTABLES S’ESPACENT QUAND ILS GRANDISSENT Illustration avec 3 bits de mantisse : 8 valeurs dans chaque intervalle entre deux puissances de 2 de 1 à 2 pas de 1/8 de 2 à 4 pas de 1/4 de 4 à 8 pas de 1/2 1 2 4 8 Même nombre de valeurs par intervalle, mais chaque intervalle double de largeur (l’axe est dessiné en échelle logarithmique). En simple précision (24 bits de précision), au-delà de 16 777 216 l’écart dépasse 1 : on ne distingue plus deux entiers voisins. En double précision, cette limite est 9 007 199 254 740 992 (2 puissance 53).
Figure 3. Chaque intervalle entre deux puissances de 2 contient autant de valeurs, mais les écarts doublent d’un intervalle au suivant.

Conséquences concrètes :

  • En simple précision, au-delà de 224 = 16 777 216, on ne peut plus représenter tous les entiers : 16 777 217 est arrondi à 16 777 216. Ajouter 1 à ce nombre ne change rien.
  • Le nombre 0,1 est arrondi à environ 0,100000001490116 (en simple précision : 3DCCCCCD). Ce n’est pas exactement 0,1.
  • Additionner un très grand et un très petit nombre fait disparaître le petit : 108 + 1 vaut 108 en simple précision.
  • L’addition n’est plus tout à fait associative : (a + b) + c peut différer de a + (b + c), à cause des arrondis intermédiaires.

Voilà pourquoi 0,1 + 0,2 donne 0,30000000000000004 en double précision, et pourquoi la comparaison 0.1 + 0.2 == 0.3 est fausse dans la plupart des langages. La règle d’or du calcul en virgule flottante : ne jamais comparer deux nombres à virgule avec l’égalité stricte. On vérifie plutôt que leur écart est inférieur à une tolérance choisie.

5.7Les autres formats

La simple précision (32 bits) n’est que l’un des formats de la norme. Les autres répondent à des besoins différents.

Tableau 4. Les principaux formats à virgule flottante.
FormatTailleExposant / mantissePrécision et usage
Demi-précision16 bits5 / 10environ 3 chiffres ; images, cartes graphiques, IA
bfloat1616 bits8 / 7même étendue que le 32 bits, moins de précision ; apprentissage des réseaux de neurones
Simple précision32 bits8 / 23environ 7 chiffres ; graphisme, jeux
Double précision64 bits11 / 52environ 16 chiffres ; calcul scientifique, valeur par défaut de nombreux langages
Quadruple précision128 bits15 / 112environ 34 chiffres ; calculs très exigeants
FP8 (8 bits)8 bits4 / 3 ou 5 / 2quelques chiffres ; accélération des modèles d’IA

Ces formats courts sont devenus essentiels avec l’intelligence artificielle (voir l’IA et l’apprentissage automatique) : un réseau de neurones contient des milliards de nombres, et réduire chacun de 32 à 16 ou à 8 bits divise la mémoire et accélère le calcul, au prix d’un peu de précision que ces modèles tolèrent bien. Le choix du bon format pour une tâche donnée est devenu un vrai sujet d’ingénierie.

Pour s’exercer

Exercice 5 : coder un nombre à virgule

Codez 6,5 en simple précision IEEE 754 et donnez le résultat en hexadécimal.

Voir la réponse

Signe positif : 0. 6,5 = 4 + 2 + 0,5 = 110,1. On normalise : 1,101 × 22. Exposant stocké : 2 + 127 = 129 = 10000001. Mantisse : 101 complétée de zéros sur 23 bits. Le mot est 0 10000001 10100000000000000000000, soit 0100 0000 1101 0000 0000 0000 0000 0000 = 40D00000.

Exercice 6 : décoder un nombre à virgule

Quelle valeur représente le mot de 32 bits C1200000 ?

Voir la réponse

En binaire : 1100 0001 0010 0000 …. Le premier bit est 1 : négatif. Les 8 bits suivants sont 10000010 = 130, donc l’exposant réel est 130 − 127 = 3. La mantisse commence par 01 : 1 + 0/2 + 1/4 = 1,25. La valeur est −1,25 × 23 = −10.

Exercice 7 : pourquoi 0,1 + 0,2 ≠ 0,3 ?

Expliquez en quelques phrases pourquoi le test 0.1 + 0.2 == 0.3 échoue, et proposez une façon correcte de comparer.

Voir la réponse

En binaire, 0,1, 0,2 et 0,3 ont une écriture infinie périodique ; l’ordinateur les arrondit au représentable le plus proche. L’addition de deux valeurs arrondies produit une troisième valeur arrondie, qui diffère de quelques unités du dernier chiffre de la valeur arrondie de 0,3 (en double précision : 0,30000000000000004 contre 0,3). Une comparaison correcte teste l’écart : abs(a − b) < ε, avec une tolérance ε adaptée au problème (par exemple 10−9), ou emploie un type décimal si l’on manipule de l’argent.

Sécurité de l’information

Le coin cyber

C.1Idée reçue

« Un ordinateur ne se trompe jamais en calculant. » Il applique exactement ses règles, mais ces règles ne sont pas celles des mathématiques : les nombres y sont finis, arrondis, parfois « circulaires ». Le résultat d’un calcul est juste au sens de la machine, pas toujours au sens de l’arithmétique. L’erreur vient presque toujours de ce que le programmeur a supposé.

C.2Ne comptez pas l’argent en nombres à virgule

En virgule flottante, 0,1 n’est pas représenté exactement, et de petites erreurs s’accumulent. Sur des millions d’opérations, cela donne des écarts de comptes, parfois exploités par des fraudeurs qui jouent sur les arrondis. Le bon réflexe : calculer les montants en centimes avec des entiers ou avec un type décimal exact, et contrôler régulièrement que les totaux concordent.

C.3Le « NaN » qui passe les contrôles

La norme IEEE 754 prévoit une valeur « NaN » (« pas un nombre »), qui n’est égale à rien, pas même à elle-même. Un test du genre « si la valeur est au-dessus du seuil » peut alors se comporter de façon inattendue et laisser passer une donnée invalide. Le bon réflexe : rejeter explicitement les NaN et les infinis dès la lecture des données.