Convertisseur IEEE 754 — Décimal vers Bits Flottants (32/64 bits)
Convertit dans les deux sens entre nombres décimaux et motifs binaires IEEE 754 (simple précision 32 bits ou double précision 64 bits). Le signe, l'exposant et la mantisse en couleur permettent de repérer NaN, l'infini et les nombres dénormalisés d'un coup d'œil.
L'exemple classique : pourquoi 0.1 + 0.2 ne donne pas 0.3
En JavaScript, `0.1 + 0.2` donne `0.30000000000000004`, et non `0.3`. L'examen des motifs binaires en double précision explique pourquoi.
| Valeur | Hexadécimal en double précision (64 bits) | Binaire en double précision (64 bits) |
|---|---|---|
| 0.1 | 0x3FB999999999999A | 0011111110111001100110011001100110011001100110011001100110011010 |
| 0.2 | 0x3FC999999999999A | 0011111111001001100110011001100110011001100110011001100110011010 |
| 0.3 | 0x3FD3333333333333 | 0011111111010011001100110011001100110011001100110011001100110011 |
| 0.1 + 0.2 | 0x3FD3333333333334 | 0011111111010011001100110011001100110011001100110011001100110100 |
0.1, 0.2 et 0.3 sont tous des fractions périodiques infinies en binaire, si bien qu'aucun d'eux ne tient exactement dans la mantisse de 52 bits et que chacun est arrondi. Comme les erreurs d'arrondi de 0.1 et de 0.2 ne s'annulent pas par hasard, leur somme finit par différer d'un seul bit du motif exact de 0.3 (0x3FD3333333333334). Essayez de saisir ces valeurs dans le convertisseur ci-dessus et comparez vous-même les derniers bits.
Qu'est-ce qu'IEEE 754 ? Voir les nombres à virgule flottante sous forme de bits
Lorsqu'un ordinateur stocke un nombre décimal, il ne conserve pas les chiffres que vous avez saisis : il encode la valeur dans un nombre fixe de bits selon la norme IEEE 754, répartis en signe, exposant et mantisse. Cet outil vous montre précisément quels bits sont stockés pour toute valeur saisie, en simple précision (32 bits) comme en double précision (64 bits), et fonctionne aussi dans l'autre sens : collez un motif hexadécimal ou binaire brut pour découvrir à quelle valeur décimale il correspond.
La programmation quotidienne ne nécessite presque jamais de réfléchir à ce niveau, et pourtant c'est lui qui explique pourquoi `0.1 + 0.2` ne donne pas `0.3`, pourquoi de très grands entiers perdent en précision une fois stockés en flottant, et pourquoi NaN et l'infini se comportent ainsi dans les comparaisons. Voir le signe, l'exposant et la mantisse détaillés pour une valeur réelle transforme ces règles abstraites en quelque chose de concret.
Comment utiliser cet outil
- Choisir un sens et une précision Sélectionnez « Décimal → Motif binaire » ou « Motif binaire → Décimal », puis simple précision (32 bits) ou double précision (64 bits).
- Saisir une valeur En entrée décimale, saisissez un nombre quelconque ou « NaN »/« Infinity »/« -Infinity ». En entrée binaire, utilisez une chaîne hexadécimale précédée de `0x` ou une chaîne binaire du nombre de chiffres correspondant à la précision choisie.
- Lire la répartition signe, exposant, mantisse La chaîne de bits en couleur et un tableau détaillé affichent l'exposant brut, l'exposant après suppression du biais et la représentation hexadécimale complète.
- Consulter le badge de classification L'outil classe automatiquement le résultat en zéro, dénormalisé, normalisé, infini ou NaN, avec une brève explication de ce que signifie cette classification.
- Essayer les préréglages et les cas limites Utilisez les boutons 0,1/0,2/0,3, ±0, ±Infinity et NaN, ou testez des valeurs négatives et des nombres extrêmement grands ou petits pour observer leur encodage.
Astuces pour en tirer le meilleur parti
- Convertissez 0.1, 0.2 et 0.3 en bits en double précision et comparez-les au résultat de 0.1+0.2 (0.30000000000000004) — vous pouvez repérer visuellement que seul le dernier bit diffère.
- Saisir « -0 » dans le champ décimal produit un motif binaire où seul le bit de signe est activé (différent de « +0 »). Comme nombres, 0 === -0, mais les représentations binaires sont distinctes.
- Lorsque le champ de l'exposant est entièrement nul, une mantisse nulle signifie zéro, et une mantisse non nulle signifie un nombre dénormalisé — une représentation spéciale utilisée pour atteindre des valeurs extrêmement proches de zéro au prix de la précision.
- Basculer entre simple précision (32 bits) et double précision (64 bits) pour une même valeur comme 0.1 montre à quel point l'erreur d'arrondi est plus importante en simple précision.
- Pour décoder un motif binaire et le reconvertir en valeur décimale, saisissez soit une chaîne hexadécimale précédée de `0x`, soit une chaîne binaire comportant exactement autant de chiffres que la précision sélectionnée (le préfixe `0b` est facultatif).
Dans quels cas utiliser cet outil
Cours d'informatique
Les manuels décrivent la structure du flottant de façon abstraite ; ici, vous pouvez la vérifier sur des nombres réels en révisant ou en préparant un compte rendu de TP.
Déboguer des erreurs de précision numérique
Isolez la raison pour laquelle un calcul précis est légèrement décalé en saisissant la valeur suspecte et en examinant son motif binaire exact, sans écrire de code.
Programmation embarquée et bas niveau
Décodez une valeur flottante en hexadécimal vue dans un dump mémoire ou un registre pour la reconvertir en un nombre décimal lisible.
Préparation d'entretiens techniques
Entraînez-vous à répondre à des questions comme « quelle est la différence entre simple et double précision au niveau des bits » à l'aide d'un exemple concret plutôt que de connaissances apprises par cœur.
Expliquer « 0.1 + 0.2 ≠ 0.3 » à quelqu'un
Montrez les motifs binaires réels côte à côte au lieu de simplement affirmer que l'arrondi en virgule flottante en est la cause.
Glossaire
- IEEE 754
- La norme internationale définissant la façon dont les ordinateurs représentent les nombres à virgule flottante. Publiée en 1985, elle est suivie par le type float/double de presque tous les langages de programmation.
- Bit de signe
- Le bit unique indiquant si une valeur est positive (0) ou négative (1). Il est indépendant de l'exposant et de la mantisse, ce qui explique que « +0 » et « -0 » existent comme motifs binaires distincts.
- Exposant
- Les bits codant l'échelle (l'ordre de grandeur) de la valeur — 8 bits en simple précision, 11 en double précision — stockés avec un biais ajouté.
- Mantisse (significande)
- Les bits codant les chiffres significatifs de la valeur — 23 bits en simple précision, 52 en double précision — normalement interprétés avec un 1 implicite en tête.
- Biais
- Un décalage fixe (127 en simple précision, 1023 en double précision) ajouté à l'exposant afin qu'il puisse être stocké et comparé comme un simple entier non signé.
- Nombre dénormalisé (subnormal)
- Un motif binaire à exposant entièrement nul et mantisse non nulle. En omettant le 1 implicite, il permet de représenter des valeurs plus proches de zéro qu'un nombre normalisé, au prix de la précision.
- NaN (n'est pas un nombre)
- Un motif binaire à exposant entièrement à un et mantisse non nulle, produit par des opérations indéfinies comme 0/0 ou ∞-∞.
- Infini
- Un motif binaire à exposant entièrement à un et mantisse entièrement nulle, généralement produit lorsqu'un calcul dépasse la plage représentable.
Questions fréquentes
Anecdote — Comment IEEE 754 est devenu un langage commun
Avant 1985, chaque fabricant d'ordinateurs utilisait sa propre représentation en virgule flottante. IBM, DEC, Cray et d'autres pouvaient calculer la même valeur, disons « 0.1 », et obtenir un comportement d'arrondi et des plages représentables subtilement différents, si bien que porter un programme numérique d'une machine à une autre produisait souvent des résultats légèrement différents. Pour résoudre ce chaos, un groupe de travail dirigé par William Kahan, de l'université de Californie à Berkeley — qui avait également participé à la conception du coprocesseur numérique Intel 8087 —, a mené la création d'une norme à l'échelle de toute l'industrie, publiée en 1985 sous le nom d'IEEE 754.
L'idée centrale d'IEEE 754 consiste à répartir un nombre fini de bits (32 ou 64) en trois rôles — signe, exposant et mantisse — afin d'approximer l'ensemble infini des nombres réels. L'exposant gère l'échelle (la grandeur du nombre), tandis que la mantisse gère la précision (le nombre de chiffres significatifs), ce qui permet à un nombre fixe de bits de couvrir avec souplesse aussi bien des grandeurs très petites que très grandes. L'exposant est stocké avec un biais ajouté (127 en simple précision, 1023 en double précision) afin que la simple comparaison de deux motifs binaires en tant qu'entiers non signés suffise à déterminer quelle valeur est la plus grande, évitant ainsi la complexité supplémentaire d'une représentation signée comme le complément à deux.
Seules les fractions dont le dénominateur est une puissance de deux (1/2, 1/4, 3/8, etc.) peuvent être représentées exactement en binaire. La valeur décimale 0.1 est la fraction 1/10, et comme 10 n'est pas une puissance de deux, elle devient la fraction binaire périodique infinie 0.0001100110011... Avec seulement un nombre fini de bits de mantisse disponibles, il faut la tronquer et l'arrondir à un moment donné — c'est la raison fondamentale pour laquelle un ordinateur ne peut pas représenter 0.1 exactement. C'est aussi pourquoi les systèmes comptables ayant besoin d'une arithmétique décimale exacte évitent généralement les nombres à virgule flottante au profit de l'arithmétique entière ou d'un type décimal dédié (comme le BCD).
IEEE 754 a ensuite été révisé en 2008 et en 2019, ajoutant la demi-précision (16 bits), la précision quadruple (128 bits) et des formats en virgule flottante décimale, mais la division fondamentale en signe, exposant et mantisse, ainsi que ses modes d'arrondi, sont restés inchangés depuis l'édition originale de 1985. Comme presque tous les types float/double de tous les langages de programmation se conforment à cette norme, la question « pourquoi 0.1 + 0.2 n'est pas égal à 0.3 ? » se pose essentiellement sous la même forme, quel que soit le langage utilisé.