Convertidor IEEE 754 de coma flotante

¿Qué es la coma flotante 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

Funciones principales

Ejemplos de conversión IEEE 754

0.1

0x3DCCCCCD — en realidad se almacena como 0.100000001490116119384765625

3.14159

0x40490FD0

65504

0x7BFF — el mayor valor finito de FP16

-0

0x80000000 (FP32), mientras que +0 es 0x00000000

Cómo convertir números IEEE 754 de coma flotante

1. 1

   Elige un formato de coma flotante

   Simple (FP32) viene preseleccionado. Cambia a Doble (FP64) para números al estilo de JavaScript/Python, o a Media (FP16) y bfloat16 para los formatos de 16 bits usados en aprendizaje automático y gráficos.

2. 2

   Escribe un número decimal

   Introduce cualquier valor —0.1, -2.5e3, 65504— o usa los chips de valores especiales para ±0, ±Infinity, NaN, el menor subnormal y el mayor valor finito. La conversión ocurre mientras escribes.

3. 3

   Lee la distribución de bits codificada por colores

   El bit de signo, el campo del exponente y la mantisa se resaltan en colores distintos, y la tabla de desglose de campos muestra los bits en bruto, la aritmética del sesgo y el bit inicial implícito.

4. 4

   Comprueba el valor almacenado exacto y el error

   El panel de precisión imprime el valor realmente almacenado —cada dígito, calculado de forma exacta— junto al error de redondeo respecto a lo que escribiste, además de los vecinos representables anterior y siguiente y la distancia en ULP.

5. 5

   Invierte bits, pega hex, copia resultados

   Haz clic en cualquier bit para invertirlo, o pega cadenas hexadecimales (3DCCCCCD) y binarias para decodificarlas de vuelta a decimal. Copia el hex, el binario, el valor exacto o un enlace compartible que reproduce el patrón de bits exacto.

Errores comunes de coma flotante

print(0.1)  # 0.1 — parece exacto, no lo es

0.1 almacenado (FP64) = 0.1000000000000000055511151231257827021181583404541015625

if (0.1 + 0.2 === 0.3) { … }   // nunca se ejecuta

if (Math.abs(a - b) < 1e-9) { … }   // tolerancia ajustada a tus datos

fp16(65520)   → Infinity (0x7C00) — desbordamiento silencioso

bf16(65520)   → finito (bfloat16 conserva 8 bits de exponente)

if (x === NaN) { … }        // siempre falso, incluso cuando x ES NaN

if (Number.isNaN(x)) { … }  // la comprobación correcta

Qué puedes hacer con el convertidor IEEE 754

Depura datos binarios serializados

Pega el hex que encontraste en una captura de red, un búfer de GPU, un volcado de registros o un formato de archivo y decodifícalo al valor decimal exacto, o ve en sentido contrario para escribir fixtures de prueba. Nota sobre el orden de bytes: el hex mostrado es el patrón de bits big-endian; si tu volcado es little-endian, invierte el orden de bytes antes de pegarlo.

Entiende la cuantización en ML

Comprueba si tus valores sobreviven al techo de 65504 de FP16, compara la pérdida de precisión de FP16 frente a bfloat16 dígito a dígito e inspecciona el rango subnormal donde los gradientes sufren underflow.

Explica un bug de coma flotante

Cuando un colega pregunte por qué difieren dos números 'iguales', envíale un enlace permanente que muestre ambos patrones de bits y los valores almacenados exactos: la discusión se resuelve sola. Combínalo con la herramienta de diferencias de texto para volcados más largos.

Aprende o enseña la codificación

Las asignaturas de arquitectura de computadores se vuelven concretas cuando los estudiantes pueden hacer clic en los bits del exponente y ver actualizarse la aritmética del sesgo. La tabla de desglose de campos refleja cómo dibujan el formato los libros de texto.

Decodifica registros embebidos e industriales

Las cargas útiles de Modbus, CAN y sensores suelen transportar valores FP32 como palabras hex en bruto. Pega aquí la palabra para leer el valor físico sin escribir un script improvisado.

Formatos IEEE 754 y valores especiales

Los cuatro formatos binarios de un vistazo

binary16 (FP16): 1 bit de signo + 5 de exponente + 10 de mantisa, sesgo 15, máximo 65504, ~3.3 dígitos decimales. bfloat16: 1 + 8 + 7, sesgo 127, máximo ≈ 3.39 × 10³⁸, ~2.3 dígitos. binary32 (FP32): 1 + 8 + 23, sesgo 127, máximo ≈ 3.40 × 10³⁸, ~7.2 dígitos. binary64 (FP64): 1 + 11 + 52, sesgo 1023, máximo ≈ 1.80 × 10³⁰⁸, ~15.9 dígitos. El patrón: los bits de exponente compran rango, los bits de mantisa compran precisión, y bfloat16 cambia deliberadamente toda su precisión por el rango de FP32.

Cómo se ensambla un valor

Un número normal se decodifica como (−1)^signo × 1.mantisa × 2^(exponente − sesgo). El 1 inicial es implícito —no se almacena—, y por eso un campo de mantisa de 23 bits ofrece 24 bits de precisión. El exponente almacenado es el exponente real más el sesgo (127 en FP32), así que 2⁰ se almacena como 01111111. La tabla de desglose de campos de esta herramienta muestra cada paso de esa aritmética para el valor actual.

Valores especiales: los patrones de exponente reservados

Un exponente todo unos con mantisa cero es ±Infinity; con cualquier mantisa distinta de cero es NaN (el NaN silencioso canónico activa el bit superior de la mantisa). Un exponente todo ceros con mantisa cero es ±0; con mantisa distinta de cero es un subnormal, decodificado como 0.mantisa × 2^(1 − sesgo), sin 1 inicial implícito. Estas reglas son idénticas en los cuatro formatos, y por eso los mismos chips funcionan en todos.

Redondeo: al más cercano, empates al par

Cuando un valor cae entre dos números representables, el modo por defecto de IEEE 754 redondea al más cercano; en un empate exacto elige el que tiene el último bit de mantisa a 0 (empates al par), lo que evita una deriva sistemática. Este convertidor aplica exactamente esa regla al estrechar tu entrada decimal al formato de destino, y el panel de error muestra la diferencia con signo resultante de forma exacta.

ULP: el espaciado de la cuadrícula de los flotantes

Los flotantes representables no están repartidos de manera uniforme: la distancia entre vecinos (una unidad en el último lugar) se duplica en cada potencia de dos. Cerca de 1.0 el ULP de un double es 2⁻⁵² ≈ 2.22 × 10⁻¹⁶; cerca de 2⁵³ el ULP alcanza 1.0 y los enteros empiezan a saltarse. El panel de vecinos imprime el ULP actual de forma exacta, que es la respuesta honesta a «¿cuán preciso es mi número aquí?».

Buenas prácticas de coma flotante

Nunca compares flotantes con ==

Tras cualquier operación aritmética, dos expresiones matemáticamente iguales pueden quedar a un ULP de distancia. Compara contra una tolerancia adecuada a tus magnitudes, o cuenta los ULP entre los patrones de bits, que esta herramienta te permite inspeccionar directamente.

Mantén el dinero fuera de los flotantes binarios

Ninguna cuadrícula de potencias de dos contiene 0.10 exactamente, así que las divisas en flotantes acumulan errores visibles. Usa céntimos enteros o un tipo decimal; el panel de valor almacenado exacto de esta herramienta es la prueba permanente del porqué.

Elige el formato de 16 bits por rango, no por costumbre

Si tus valores pueden superar 65504 —pérdidas, gradientes, picos físicos—, FP16 se desbordará a Infinity donde bfloat16 sigue funcionando. Si todo está normalizado en una banda estrecha, los bits extra de mantisa de FP16 dan una precisión visiblemente mejor.

Cuidado con la trampa del doble redondeo al estrechar

Convertir decimal → double → half puede caer a un ULP de distancia de convertir decimal → half directamente en raros casos intermedios. Esta herramienta redondea tu entrada decimal al formato de destino en un solo paso, así que lo que ves es la respuesta IEEE 754 honesta.

Espera que los enteros se rompan por encima de 2⁵³

Un double almacena exactamente todos los enteros hasta 2⁵³ y a partir de ahí empieza a saltárselos: 2⁵³ + 1 no es representable. Si manejas IDs o contadores cerca de esa escala, usa enteros de 64 bits o cadenas, y comprueba aquí los valores sospechosos a nivel de bits.

Preguntas frecuentes sobre el convertidor IEEE 754