IEEE 754-converter voor drijvende-kommagetallen

Wat is IEEE 754 drijvende-kommanotatie?

// 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

Belangrijkste functies

Voorbeelden van IEEE 754-omrekening

0.1

0x3DCCCCCD — daadwerkelijk opgeslagen als 0.100000001490116119384765625

3.14159

0x40490FD0

65504

0x7BFF — de grootste eindige FP16-waarde

-0

0x80000000 (FP32), terwijl +0 0x00000000 is

Zo reken je IEEE 754-getallen om

1. 1

   Kies een drijvende-kommaformaat

   Enkele precisie (FP32) is vooraf geselecteerd. Schakel over naar dubbele precisie (FP64) voor getallen in JavaScript/Python-stijl, of naar halve precisie (FP16) en bfloat16 voor de 16-bit-formaten uit machine learning en graphics.

2. 2

   Typ een decimaal getal

   Voer een willekeurige waarde in — 0.1, -2.5e3, 65504 — of gebruik de knoppen voor speciale waarden: ±0, ±Infinity, NaN, het kleinste subnormale getal en de grootste eindige waarde. De omrekening gebeurt terwijl je typt.

3. 3

   Lees de bitindeling met kleurcodering

   De tekenbit, het exponentveld en de mantisse zijn in verschillende kleuren gemarkeerd, en de tabel met de veldopbouw toont de ruwe bits, de biasberekening en de impliciete voorloopbit.

4. 4

   Controleer de exact opgeslagen waarde en de fout

   Het nauwkeurigheidspaneel toont de waarde die daadwerkelijk wordt opgeslagen — elk cijfer, exact berekend — naast de afrondingsfout ten opzichte van wat je typte, plus de vorige en volgende representeerbare buurwaarden en het ULP-verschil.

5. 5

   Wissel bits om, plak hex, kopieer resultaten

   Klik op een bit om die om te wisselen, of plak hex- (3DCCCCCD) en binaire strings om ze terug te decoderen naar decimaal. Kopieer de hex, het binair, de exacte waarde of een deelbare link die het exacte bitpatroon reproduceert.

Veelgemaakte fouten met drijvende komma

print(0.1)  # 0.1 — oogt exact, is het niet

0.1 opgeslagen (FP64) = 0.1000000000000000055511151231257827021181583404541015625

if (0.1 + 0.2 === 0.3) { … }   // wordt nooit uitgevoerd

if (Math.abs(a - b) < 1e-9) { … }   // tolerantie afgestemd op je data

fp16(65520)   → Infinity (0x7C00) — stille overflow

bf16(65520)   → eindig (bfloat16 behoudt 8 exponentbits)

if (x === NaN) { … }        // altijd false, ook wanneer x WEL NaN is

if (Number.isNaN(x)) { … }  // de juiste test

Wat je kunt doen met de IEEE 754-converter

Debug geserialiseerde binaire data

Plak de hex die je vond in een netwerkcapture, GPU-buffer, registerdump of bestandsformaat en decodeer die naar de exacte decimale waarde — of ga de andere kant op om testfixtures te schrijven. Let op de bytevolgorde: de getoonde hex is het big-endian-bitpatroon; als je dump little-endian is, draai dan de bytevolgorde om voordat je plakt.

Begrijp ML-kwantisatie

Controleer of je waarden het 65504-plafond van FP16 overleven, vergelijk het precisieverlies van FP16 en bfloat16 cijfer voor cijfer en inspecteer het subnormale bereik waarin gradiënten door underflow naar nul zakken.

Leg een drijvende-kommabug uit

Wanneer een collega vraagt waarom twee 'gelijke' getallen verschillen, stuur je een permalink met beide bitpatronen en de exact opgeslagen waarden — de discussie beslecht zichzelf. Combineer met de Text Diff-tool voor langere dumps.

Leer of onderwijs de codering

Colleges computerarchitectuur worden concreet wanneer studenten op de exponentbits kunnen klikken en de biasberekening zien bijwerken. De tabel met de veldopbouw weerspiegelt hoe studieboeken het formaat tekenen.

Decodeer embedded en industriële registers

Modbus-, CAN- en sensorpayloads bevatten geregeld FP32-waarden als ruwe hexwoorden. Plak het woord hier om de fysieke waarde af te lezen zonder een wegwerpscript te schrijven.

IEEE 754-formaten & speciale waarden

De vier binaire formaten in één oogopslag

binary16 (FP16): 1 teken- + 5 exponent- + 10 mantissebits, bias 15, max 65504, ~3,3 decimale cijfers. bfloat16: 1 + 8 + 7, bias 127, max ≈ 3,39 × 10³⁸, ~2,3 cijfers. binary32 (FP32): 1 + 8 + 23, bias 127, max ≈ 3,40 × 10³⁸, ~7,2 cijfers. binary64 (FP64): 1 + 11 + 52, bias 1023, max ≈ 1,80 × 10³⁰⁸, ~15,9 cijfers. Het patroon: exponentbits kopen bereik, mantissebits kopen precisie, en bfloat16 ruilt bewust al zijn precisie in voor het bereik van FP32.

Hoe een waarde wordt opgebouwd

Een normaal getal decodeert als (−1)^teken × 1.mantisse × 2^(exponent − bias). De voorloop-1 is impliciet — die wordt niet opgeslagen, en daarom levert een mantisseveld van 23 bits toch 24 bits precisie. De opgeslagen exponent is de werkelijke exponent plus de bias (127 in FP32), dus 2⁰ wordt opgeslagen als 01111111. De tabel met de veldopbouw in deze tool toont elke stap van die berekening voor de huidige waarde.

Speciale waarden: de gereserveerde exponentpatronen

Exponent louter enen met mantisse nul is ±Infinity; met een mantisse ongelijk aan nul is het NaN (de canonieke quiet NaN zet de bovenste mantissebit). Exponent louter nullen met mantisse nul is ±0; met een mantisse ongelijk aan nul is het een subnormaal getal, gedecodeerd als 0.mantisse × 2^(1 − bias) — zonder impliciete voorloop-1. Deze regels zijn identiek in alle vier de formaten, en daarom werken dezelfde knoppen in elk formaat.

Afronding: naar dichtstbijzijnde, bij gelijke afstand naar even

Wanneer een waarde tussen twee representeerbare getallen valt, rondt de standaardmodus van IEEE 754 af naar het dichtstbijzijnde getal; bij een exact gelijke afstand kiest hij het getal waarvan de laatste mantissebit 0 is (ties to even), wat systematische drift voorkomt. Deze converter past exact die regel toe bij het versmallen van je decimale invoer naar het doelformaat, en het foutpaneel toont het resulterende verschil met teken exact.

ULP: de rasterafstand van floats

Representeerbare floats liggen niet gelijkmatig verspreid — het gat tussen buurwaarden (één unit in the last place) verdubbelt bij elke macht van twee. Nabij 1.0 is de ULP van een double 2⁻⁵² ≈ 2,22 × 10⁻¹⁶; nabij 2⁵³ bereikt de ULP 1.0 en beginnen gehele getallen over te slaan. Het paneel met buurwaarden toont de huidige ULP exact — het eerlijke antwoord op 'hoe precies is mijn getal hier?'.

Aanbevolen aanpak voor drijvende komma

Vergelijk floats nooit met ==

Na elke rekenbewerking kunnen twee wiskundig gelijke expressies één ULP uit elkaar liggen. Vergelijk tegen een tolerantie die past bij je magnitudes — of tel de ULP's tussen de bitpatronen, die je in deze tool rechtstreeks kunt inspecteren.

Houd geld buiten binaire floats

Geen enkel macht-van-twee-raster bevat 0.10 exact, dus valuta in floats stapelt zichtbare fouten op. Gebruik gehele centen of een decimaal type; het paneel met de exact opgeslagen waarde is hier het staande bewijs waarom.

Kies het 16-bit-formaat op bereik, niet uit gewoonte

Kunnen je waarden 65504 overschrijden — verliezen, gradiënten, fysicapieken — dan loopt FP16 over naar Infinity waar bfloat16 gewoon doorvaart. Is alles genormaliseerd naar een smalle band, dan geven de extra mantissebits van FP16 zichtbaar betere precisie.

Pas op voor de dubbele-afrondingsval bij versmallen

Decimaal → double → half omrekenen kan in zeldzame randgevallen één ULP verwijderd landen van decimaal → half rechtstreeks. Deze tool rondt je decimale invoer in één stap af naar het doelformaat, dus wat je ziet is het eerlijke IEEE 754-antwoord.

Verwacht dat gehele getallen groter dan 2⁵³ breken

Een double slaat elk geheel getal tot en met 2⁵³ exact op en begint daarna over te slaan — 2⁵³ + 1 is niet representeerbaar. Werk je met ID's of tellers rond die schaal, gebruik dan 64-bit-integers of strings, en controleer verdachte waarden hier op bitniveau.

Veelgestelde vragen over de IEEE 754-converter