Convertitore IEEE 754 per Numeri in Virgola Mobile

Cos'è la Virgola Mobile 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

Caratteristiche Principali

Esempi di Conversione IEEE 754

0.1

0x3DCCCCCD — memorizzato in realtà come 0.100000001490116119384765625

3.14159

0x40490FD0

65504

0x7BFF — il più grande valore FP16 finito

-0

0x80000000 (FP32), mentre +0 è 0x00000000

Come Convertire Numeri IEEE 754 in Virgola Mobile

1. 1

   Scegli un formato in virgola mobile

   Singola (FP32) è preselezionata. Passa a Doppia (FP64) per numeri in stile JavaScript/Python, oppure a Mezza (FP16) e bfloat16 per i formati a 16 bit usati nel machine learning e nella grafica.

2. 2

   Digita un numero decimale

   Inserisci qualsiasi valore — 0.1, -2.5e3, 65504 — oppure usa i chip dei valori speciali per ±0, ±Infinity, NaN, il più piccolo subnormale e il più grande valore finito. La conversione avviene mentre digiti.

3. 3

   Leggi il layout dei bit codificato per colore

   Il bit di segno, il campo esponente e la mantissa sono evidenziati in colori diversi, con la tabella di scomposizione dei campi che mostra i bit grezzi, l'aritmetica del bias e il bit iniziale implicito.

4. 4

   Controlla il valore memorizzato esatto e l'errore

   Il pannello di precisione stampa il valore effettivamente memorizzato — ogni cifra, calcolata in modo esatto — accanto all'errore di arrotondamento rispetto a ciò che hai digitato, oltre ai valori rappresentabili precedente e successivo e al gap in ULP.

5. 5

   Inverti bit, incolla hex, copia i risultati

   Clicca su qualsiasi bit per invertirlo, oppure incolla stringhe hex (3DCCCCCD) e binarie per decodificarle di nuovo in decimale. Copia l'hex, il binario, il valore esatto o un link condivisibile che riproduce l'esatto pattern di bit.

Errori Comuni in Virgola Mobile

print(0.1)  # 0.1 — sembra esatto, non lo è

0.1 memorizzato (FP64) = 0.1000000000000000055511151231257827021181583404541015625

if (0.1 + 0.2 === 0.3) { … }   // non viene mai eseguito

if (Math.abs(a - b) < 1e-9) { … }   // tolleranza dimensionata sui tuoi dati

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

bf16(65520)   → finito (bfloat16 conserva 8 bit di esponente)

if (x === NaN) { … }        // sempre falso, anche quando x È NaN

if (Number.isNaN(x)) { … }  // il test corretto

Cosa Puoi Fare con il Convertitore IEEE 754

Debug di dati binari serializzati

Incolla l'hex trovato in una cattura di rete, un buffer GPU, un dump di registri o un formato di file e decodificalo nel valore decimale esatto — o procedi nell'altro senso per scrivere fixture di test. Nota sull'ordine dei byte: l'hex mostrato è il pattern di bit big-endian; se il tuo dump è little-endian, inverti l'ordine dei byte prima di incollare.

Capire la quantizzazione ML

Verifica se i tuoi valori sopravvivono al tetto di 65504 di FP16, confronta cifra per cifra la perdita di precisione tra FP16 e bfloat16 e ispeziona l'intervallo subnormale dove i gradienti vanno in underflow.

Spiegare un bug di virgola mobile

Quando un collega chiede perché due numeri 'uguali' differiscono, invia un permalink che mostra entrambi i pattern di bit e i valori memorizzati esatti — la discussione si risolve da sola. Abbinalo allo strumento di confronto testi per dump più lunghi.

Imparare o insegnare la codifica

I corsi di architettura dei calcolatori diventano concreti quando gli studenti possono cliccare sui bit dell'esponente e osservare l'aritmetica del bias aggiornarsi. La tabella di scomposizione dei campi rispecchia il modo in cui i libri di testo disegnano il formato.

Decodificare registri embedded e industriali

I payload Modbus, CAN e dei sensori trasportano abitualmente valori FP32 come word esadecimali grezze. Incolla qui la word per leggere il valore fisico senza scrivere uno script usa e getta.

Formati IEEE 754 e Valori Speciali

I quattro formati binari a colpo d'occhio

binary16 (FP16): 1 bit di segno + 5 di esponente + 10 di mantissa, bias 15, massimo 65504, ~3.3 cifre decimali. bfloat16: 1 + 8 + 7, bias 127, massimo ≈ 3.39 × 10³⁸, ~2.3 cifre. binary32 (FP32): 1 + 8 + 23, bias 127, massimo ≈ 3.40 × 10³⁸, ~7.2 cifre. binary64 (FP64): 1 + 11 + 52, bias 1023, massimo ≈ 1.80 × 10³⁰⁸, ~15.9 cifre. Lo schema: i bit di esponente comprano intervallo, i bit di mantissa comprano precisione, e bfloat16 scambia deliberatamente tutta la sua precisione per l'intervallo di FP32.

Come viene assemblato un valore

Un numero normale si decodifica come (−1)^segno × 1.mantissa × 2^(esponente − bias). L'1 iniziale è implicito — non viene memorizzato, ed è per questo che un campo mantissa a 23 bit fornisce 24 bit di precisione. L'esponente memorizzato è l'esponente vero più il bias (127 in FP32), quindi 2⁰ è memorizzato come 01111111. La tabella di scomposizione dei campi in questo strumento mostra ogni passaggio di quell'aritmetica per il valore corrente.

Valori speciali: i pattern di esponente riservati

Esponente tutto a uno con mantissa zero è ±Infinity; con qualsiasi mantissa diversa da zero è NaN (il NaN quiet canonico imposta il bit più alto della mantissa). Esponente tutto a zero con mantissa zero è ±0; con mantissa diversa da zero è un subnormale, decodificato come 0.mantissa × 2^(1 − bias) — senza 1 iniziale implicito. Queste regole sono identiche in tutti e quattro i formati, ed è per questo che gli stessi chip funzionano in ciascuno.

Arrotondamento: al più vicino, pareggi al pari

Quando un valore cade tra due numeri rappresentabili, la modalità predefinita di IEEE 754 arrotonda al più vicino; in caso di pareggio esatto sceglie quello il cui ultimo bit di mantissa è 0 (pareggi al pari), il che previene derive sistematiche. Questo convertitore applica esattamente quella regola quando restringe il tuo input decimale nel formato di destinazione, e il pannello dell'errore mostra esattamente la differenza con segno risultante.

ULP: il passo della griglia dei float

I float rappresentabili non sono distribuiti in modo uniforme — il gap tra vicini (una unità nell'ultima posizione) raddoppia a ogni potenza di due. Vicino a 1.0 l'ULP di un double è 2⁻⁵² ≈ 2.22 × 10⁻¹⁶; vicino a 2⁵³ l'ULP raggiunge 1.0 e gli interi iniziano a saltare. Il pannello dei vicini stampa l'ULP corrente in modo esatto, che è la risposta onesta a 'quanto è preciso il mio numero qui?'.

Best Practice per la Virgola Mobile

Non confrontare mai i float con ==

Dopo qualsiasi operazione aritmetica, due espressioni matematicamente uguali possono trovarsi a un ULP di distanza. Confronta rispetto a una tolleranza adeguata alle tue grandezze — oppure conta gli ULP tra i pattern di bit, che questo strumento ti permette di ispezionare direttamente.

Tieni il denaro fuori dai float binari

Nessuna griglia in potenze di due contiene 0.10 esattamente, quindi la valuta nei float accumula errori visibili. Usa centesimi interi o un tipo decimale; il pannello del valore memorizzato esatto qui è la prova permanente del perché.

Scegli il formato a 16 bit in base all'intervallo, non all'abitudine

Se i tuoi valori possono superare 65504 — loss, gradienti, picchi nelle simulazioni fisiche — FP16 andrà in overflow a Infinity dove bfloat16 prosegue tranquillo. Se tutto è normalizzato in una banda stretta, i bit di mantissa extra di FP16 danno una precisione visibilmente migliore.

Attenzione alla trappola del doppio arrotondamento quando restringi

Convertire decimale → double → half può atterrare a un ULP di distanza dal convertire decimale → half direttamente, in rari casi a metà strada. Questo strumento arrotonda il tuo input decimale nel formato di destinazione in un solo passaggio, quindi ciò che vedi è la risposta IEEE 754 onesta.

Aspettati che gli interi si rompano oltre 2⁵³

Un double memorizza esattamente ogni intero fino a 2⁵³, poi inizia a saltare — 2⁵³ + 1 non è rappresentabile. Se gestisci ID o contatori vicino a quella scala, usa interi a 64 bit o stringhe, e controlla qui i valori sospetti a livello di bit.

Domande Frequenti sul Convertitore IEEE 754