Convertisseur IEEE 754 virgule flottante

Qu'est-ce que la virgule flottante IEEE 754 ?

// Float ↔ hex through the raw IEEE 754 bits (works in any browser / Node.js)
const buf = new DataView(new ArrayBuffer(8));

function floatToHex32(value) {
  buf.setFloat32(0, value); // rounds to nearest even
  return '0x' + buf.getUint32(0).toString(16).toUpperCase().padStart(8, '0');
}

function hexToFloat32(hex) {
  buf.setUint32(0, parseInt(hex, 16));
  return buf.getFloat32(0);
}

floatToHex32(0.1);        // '0x3DCCCCCD'
floatToHex32(3.14159);    // '0x40490FD0'
hexToFloat32('3DCCCCCD'); // 0.10000000149011612

Fonctionnalités clés

Exemples de conversion IEEE 754

0.1

0x3DCCCCCD — stocké en réalité comme 0.100000001490116119384765625

3.14159

0x40490FD0

65504

0x7BFF — la plus grande valeur finie en FP16

-0

0x80000000 (FP32), tandis que +0 vaut 0x00000000

Comment convertir des nombres IEEE 754 en virgule flottante

1. 1

   Choisissez un format en virgule flottante

   Simple (FP32) est présélectionné. Passez en Double (FP64) pour les nombres de type JavaScript/Python, ou en Demi (FP16) et bfloat16 pour les formats 16 bits utilisés en machine learning et en graphisme.

2. 2

   Saisissez un nombre décimal

   Entrez n'importe quelle valeur — 0.1, -2.5e3, 65504 — ou utilisez les puces de valeurs spéciales pour ±0, ±Infinity, NaN, le plus petit subnormal et la plus grande valeur finie. La conversion se fait pendant la frappe.

3. 3

   Lisez la disposition des bits codée par couleur

   Le bit de signe, le champ d'exposant et la mantisse sont surlignés dans des couleurs différentes, et le tableau de décomposition des champs montre les bits bruts, le calcul du biais et le bit de tête implicite.

4. 4

   Vérifiez la valeur stockée exacte et l'erreur

   Le panneau de précision imprime la valeur réellement stockée — chaque chiffre, calculé exactement — à côté de l'erreur d'arrondi par rapport à votre saisie, plus les voisins représentables précédent et suivant et l'écart en ULP.

5. 5

   Inversez des bits, collez de l'hex, copiez les résultats

   Cliquez sur n'importe quel bit pour l'inverser, ou collez des chaînes hexadécimales (3DCCCCCD) et binaires pour les décoder en décimal. Copiez l'hex, le binaire, la valeur exacte ou un lien partageable qui reproduit le motif de bits exact.

Erreurs courantes en virgule flottante

print(0.1)  # 0.1 — paraît exact, ne l'est pas

0.1 stocké (FP64) = 0.1000000000000000055511151231257827021181583404541015625

if (0.1 + 0.2 === 0.3) { … }   // ne s'exécute jamais

if (Math.abs(a - b) < 1e-9) { … }   // tolérance adaptée à vos données

fp16(65520)   → Infinity (0x7C00) — débordement silencieux

bf16(65520)   → fini (bfloat16 conserve 8 bits d'exposant)

if (x === NaN) { … }        // toujours faux, même quand x EST NaN

if (Number.isNaN(x)) { … }  // le test correct

Ce que vous pouvez faire avec le convertisseur IEEE 754

Déboguer des données binaires sérialisées

Collez l'hex trouvé dans une capture réseau, un buffer GPU, un dump de registres ou un format de fichier et décodez-le vers la valeur décimale exacte — ou faites l'inverse pour écrire des fixtures de test. Note sur l'ordre des octets : l'hex affiché est le motif de bits big-endian ; si votre dump est en little-endian, inversez l'ordre des octets avant de coller.

Comprendre la quantification ML

Vérifiez si vos valeurs survivent au plafond de 65504 de FP16, comparez chiffre par chiffre la perte de précision entre FP16 et bfloat16, et inspectez la plage subnormale où les gradients passent en underflow.

Expliquer un bug de virgule flottante

Quand un collègue demande pourquoi deux nombres « égaux » diffèrent, envoyez un permalien montrant les deux motifs de bits et les valeurs stockées exactes — le débat se règle de lui-même. Associez-le à l'outil de comparaison de texte pour les dumps plus longs.

Apprendre ou enseigner l'encodage

Les cours d'architecture des ordinateurs deviennent concrets quand les étudiants peuvent cliquer sur les bits d'exposant et voir le calcul du biais se mettre à jour. Le tableau de décomposition des champs reflète la façon dont les manuels dessinent le format.

Décoder des registres embarqués et industriels

Les trames Modbus, CAN et les charges utiles de capteurs transportent couramment des valeurs FP32 sous forme de mots hexadécimaux bruts. Collez le mot ici pour lire la valeur physique sans écrire de script jetable.

Formats IEEE 754 et valeurs spéciales

Les quatre formats binaires en un coup d'œil

binary16 (FP16) : 1 bit de signe + 5 bits d'exposant + 10 bits de mantisse, biais 15, max 65504, ~3.3 chiffres décimaux. bfloat16 : 1 + 8 + 7, biais 127, max ≈ 3.39 × 10³⁸, ~2.3 chiffres. binary32 (FP32) : 1 + 8 + 23, biais 127, max ≈ 3.40 × 10³⁸, ~7.2 chiffres. binary64 (FP64) : 1 + 11 + 52, biais 1023, max ≈ 1.80 × 10³⁰⁸, ~15.9 chiffres. Le schéma : les bits d'exposant achètent de l'étendue, les bits de mantisse achètent de la précision, et bfloat16 échange délibérément toute sa précision contre l'étendue de FP32.

Comment une valeur est assemblée

Un nombre normal se décode comme (−1)^signe × 1.mantisse × 2^(exposant − biais). Le 1 de tête est implicite — il n'est pas stocké, c'est pourquoi un champ de mantisse de 23 bits fournit 24 bits de précision. L'exposant stocké est l'exposant réel plus le biais (127 en FP32), donc 2⁰ est stocké comme 01111111. Le tableau de décomposition des champs de cet outil montre chaque étape de ce calcul pour la valeur courante.

Valeurs spéciales : les motifs d'exposant réservés

Exposant tout à un avec mantisse nulle : ±Infinity ; avec n'importe quelle mantisse non nulle : NaN (le NaN silencieux canonique active le bit de poids fort de la mantisse). Exposant tout à zéro avec mantisse nulle : ±0 ; avec une mantisse non nulle : un subnormal, décodé comme 0.mantisse × 2^(1 − biais) — sans 1 de tête implicite. Ces règles sont identiques dans les quatre formats, c'est pourquoi les mêmes puces fonctionnent dans chacun.

Arrondi : au plus proche, égalité vers le pair

Quand une valeur tombe entre deux nombres représentables, le mode par défaut d'IEEE 754 arrondit vers le plus proche ; en cas d'égalité exacte, il choisit celui dont le dernier bit de mantisse est 0 (égalité vers le pair), ce qui évite toute dérive systématique. Ce convertisseur applique exactement cette règle en réduisant votre saisie décimale vers le format cible, et le panneau d'erreur montre exactement la différence signée résultante.

ULP : l'espacement de la grille des flottants

Les flottants représentables ne sont pas répartis uniformément — l'écart entre voisins (une unité à la dernière place) double à chaque puissance de deux. Près de 1.0, l'ULP d'un double vaut 2⁻⁵² ≈ 2.22 × 10⁻¹⁶ ; près de 2⁵³, l'ULP atteint 1.0 et les entiers commencent à sauter. Le panneau des voisins imprime l'ULP courant exactement — la réponse honnête à « quelle est la précision de mon nombre ici ? ».

Bonnes pratiques en virgule flottante

Ne comparez jamais des flottants avec ==

Après n'importe quelle arithmétique, deux expressions mathématiquement égales peuvent se retrouver à un ULP l'une de l'autre. Comparez avec une tolérance adaptée à vos ordres de grandeur — ou comptez les ULP entre les motifs de bits, que cet outil vous laisse inspecter directement.

Tenez l'argent à l'écart des flottants binaires

Aucune grille en puissances de deux ne contient 0.10 exactement, donc une devise stockée en flottants accumule des erreurs visibles. Utilisez des centimes entiers ou un type décimal ; le panneau de valeur stockée exacte de cet outil en est la preuve permanente.

Choisissez le format 16 bits selon l'étendue, pas l'habitude

Si vos valeurs peuvent dépasser 65504 — pertes, gradients, pics physiques — FP16 débordera vers Infinity là où bfloat16 continue sans broncher. Si tout est normalisé dans une bande étroite, les bits de mantisse supplémentaires de FP16 donnent une précision visiblement meilleure.

Attention au piège du double arrondi lors du rétrécissement

Convertir décimal → double → demi peut atterrir à un ULP du résultat de la conversion directe décimal → demi dans de rares cas limites. Cet outil arrondit votre saisie décimale vers le format cible en une seule étape, donc ce que vous voyez est la réponse IEEE 754 honnête.

Attendez-vous à ce que les entiers cassent au-delà de 2⁵³

Un double stocke exactement chaque entier jusqu'à 2⁵³, puis commence à en sauter — 2⁵³ + 1 n'est pas représentable. Si vous manipulez des identifiants ou des compteurs proches de cette échelle, utilisez des entiers 64 bits ou des chaînes, et vérifiez ici les valeurs suspectes au niveau du bit.

FAQ du convertisseur IEEE 754