IEEE 754

IEEE 754 es el estándar para la aritmética de punto flotante, publicado por primera vez en 1985 y actualizado en 2008 y 2019. Define los formatos de punto flotante binario y decimal, el comportamiento de redondeo, el manejo de excepciones y los valores especiales (NaN, ±Infinito, −0).

El formato estándar de doble precisión es el que usan los Numbers de JavaScript, los floats de Python y la mayoría de los tipos “number” en los lenguajes modernos:

• 64 bits en total
• 1 bit de signo
• 11 bits de exponente
• 52 bits de mantisa
• ~15-17 dígitos decimales significativos de precisión
• Rango aproximado de 4.9e−324 a 1.8e+308

El ejemplo famoso: 0.1 + 0.2 === 0.3 devuelve false en casi todos los lenguajes. La razón: 0.1 y 0.2 no tienen representaciones binarias exactas (igual que 1/3 no tiene representación decimal exacta). Sus valores almacenados son muy cercanos pero no exactamente 0.1 y 0.2, y la suma amplía el pequeño error. El resultado es 0.30000000000000004.

Implicaciones para nuestras herramientas: la mayoría de las conversiones son precisas hasta ~15 dígitos decimales, que es más de lo que acepta cualquier entrada nuestra. Donde esto importa: cantidades de criptomonedas, donde 18 decimales de Wei supera el rango de Number — usamos BigInt allí para mantener la precisión exacta.

Ejemplo práctico

Considera el cálculo 0.1 + 0.2 en JavaScript. El literal 0.1 en binario IEEE 754 es en realidad 0.10000000000000000555111512312578… (el double representable más cercano). 0.2 es 0.20000000000000001110223024625157…. Sumarlos y redondear al double representable más cercano da 0.30000000000000004440892098500626…, mostrado como 0.30000000000000004. La respuesta matemática verdadera 0.3 no es exactamente representable en binario — su representación también es aproximadamente 0.299999…9989…. El error está en el último ulp (unidad en el último lugar), alrededor de 1 en 10¹⁶. Para números visibles es invisible; para sumas de millones de valores pequeños se acumula: sumar 0.1 cien veces en un bucle y comparar con 10.0 devolverá false. Usa la suma de Kahan o la suma compensada cuando la precisión importa en acumulaciones largas.

Dos peculiaridades más de valores especiales que vale la pena conocer: los números subnormales (valores muy pequeños cerca de cero con precisión reducida) intercambian rango representable por desbordamiento inferior gradual, y los NaN de señalización (sNaN) pueden usarse para capturar memoria no inicializada, aunque la mayoría de los lenguajes mapean todos los NaN a NaN silenciosos (qNaN) y nunca exponen esta distinción al código de usuario.

Cuándo y por qué importa

IEEE 754 importa cuando el código compara floats por igualdad, suma muchos números pequeños o maneja valores cerca de los límites del formato. El error financiero clásico es calcular “total = total + 0.01” en un bucle un millón de veces y descubrir que el resultado está ligeramente desfasado como para fallar una reconciliación de balance. La solución es nunca usar floats para dinero — usa BigDecimal, decimal.Decimal de Python, decimal.js de JavaScript, o almacena cantidades como enteros (centavos en lugar de dólares, satoshis en lugar de bitcoin, wei en lugar de ETH). Referencia: Goldberg D. — Lo que todo científico informático debería saber sobre la aritmética de punto flotante.

Los cinco valores especiales que todos olvidan: IEEE 754 define +0 y −0 como distintos (se comparan como iguales pero producen resultados diferentes en la división — 1/+0 es +∞ mientras que 1/−0 es −∞), +Infinity y −Infinity para el desbordamiento, y NaN (Not a Number) para operaciones indefinidas como 0/0 o √−1. NaN es famosamente desigual a sí mismo — NaN === NaN es false — que es cómo IEEE 754 propaga los errores a través del cálculo en lugar de enmascararlos. La comprobación Number.isNaN() existe en todos los lenguajes modernos precisamente porque la comprobación obvia de igualdad no funciona.

Cuándo realmente necesitas decimal exacto — y qué usar en su lugar: para dinero, nunca uses floats. BigDecimal de Java, decimal.Decimal de Python, bibliotecas de JavaScript como decimal.js y el tipo NUMERIC de PostgreSQL implementan aritmética decimal exacta. El costo es aproximadamente 10-100× más lento que las operaciones nativas de float, lo cual está bien para cualquier sistema de transacciones orientado al usuario. Para la computación científica donde el comportamiento de redondeo importa, el redondeo al par más cercano (redondeo del banquero) de IEEE 754 es lo que produce sumas acumuladas estables; el redondeo hacia arriba en empate sesga hacia arriba. La mayoría de los lenguajes usan por defecto el redondeo al par más cercano por esta razón. Referencia: IEEE 754-2019 — Aritmética de punto flotante.