Cómo se representan los decimales: números de punto flotante e IEEE 754

En esta lección entenderás: cómo se representan los decimales en un mundo de solo 0 y 1, y por qué los números de punto flotante tienen errores de precisión.


Analogía cotidiana: notación científica

Seguramente has visto la notación científica en clase de física:

Velocidad de la luz = 3.0 x 108m/s, masa del electrón = 9.1 x 10-31 kg。

De esta forma, con muy pocos dígitos se pueden representar números muy grandes o muy pequeños.

La computadora usa exactamente la misma idea para representar decimales:Notación científica binaria。

Cualquier número decimal en binario puede escribirse como:

1.xxxxxxxxxx x 2yyyyy

Esta forma solo necesita almacenar tres cosas:

  • Signo: ¿positivo o negativo?
  • Mantisa(xxxxxxxxxx): la parte de dígitos significativos
  • Exponente(yyyyy): la posición del punto decimal

El estándar IEEE 754 mete estas tres cosas en 32 bits con un formato fijo.


Estructura de tres partes de IEEE 754 de precisión simple

Los 32 bits (float de precisión simple) se dividen exactamente en tres partes:

Bit de signo 0 1 bit
Bits de exponente 00000000 8 bits
Bits de mantisa (fracción) 00000000000000000000000 23 bits
Bit de signo (1 bit)
Bits de exponente (8 bits)
Bits de mantisa (23 bits)

Primera parte: bit de signo (1 bit)

Es la parte más simple.

0Representa números positivos,1Representa números negativos.

Segunda parte: bits de exponente (8 bits)

El exponente determina la posición del punto decimal (de ahí viene el nombre de 'punto flotante': el punto decimal puede 'flotar').

Pero el exponente no se almacena directamente; se almacena el 'exponente real + 127'.

Este 127 se llamasesgo (Bias)。

¿Por qué agregar el sesgo?

Porque 8 bits solo pueden representar de 0 a 255 (sin signo), pero el exponente real necesita ser negativo (para representar números menores que 1).

Al agregar el sesgo de 127:

  • El valor almacenado 127 corresponde al exponente real 0 (127 - 127 = 0)
  • El valor almacenado 0 corresponde al exponente real -127
  • El valor almacenado 255 corresponde al exponente real +128

Tercera parte: bits de mantisa (23 bits)

La mantisa almacena la parte 'xxxxx' de '1.xxxxx', omitiendo el 1 inicial.

Porque en la notación científica binaria, la forma normalizada siempre es 1.xxx, por lo que el 1 inicial no necesita almacenarse.

Esto ingeniosamente ahorra 1 bit adicional de precisión.

La clave para entender la estructura de tres partes: número de punto flotante = (-1)^signox 1.mantisa x 2(exponente - 127). Eso es toda la esencia de IEEE 754.


Demostración interactiva: desglosador de números de punto flotante de 32 bits

Ingresa un número de punto flotante y observa su estructura de tres partes en el formato IEEE 754 de precisión simple.

La barra segmentada resaltará qué bits corresponden a cada una de las tres partes.

Desglosador de precisión simple IEEE 754

Ingresa el número de punto flotante:

Prueba ingresar 0.1 y observa la parte de la mantisa.

La mantisa binaria de 0.1 es un decimal periódico infinito: 23 bits no son suficientes para almacenarlo.

Esto da lugar a un famoso fenómeno informático.


Por qué 0.1 + 0.2 no es igual a 0.3

Si ejecutas en Python o JavaScript0.1 + 0.2 == 0.3, el resultado esFalse。

Esto no es un bug, sino una consecuencia inevitable de la representación de punto flotante.

La razón es muy simple:0.1 no se puede representar exactamente en binario。

Así como en decimal, 1/3 = 0.33333... es un decimal periódico infinito.

En binario, 0.1 (decimal) = 0.000110011001100110011... (binario), que también es un decimal periódico infinito.

IEEE 754 solo tiene 23 bits de mantisa para almacenar este decimal periódico infinito.

La parte que excede los 23 bits solo puede truncarse (redondearse), lo que genera un error de redondeo.

El valor realmente almacenado de 0.1 en float32 es aproximadamente 0.100000001490116119384765625.

El valor realmente almacenado de 0.2 en float32 es aproximadamente 0.20000000298023223876953125.

Al sumarlos y truncarlos, el resultado no es igual al 0.3 exacto.

Los cálculos de montos deben evitar los números de punto flotante

En escenarios que involucran montos, se deben usar enteros (en unidades de 'centavos') o un tipo Decimal especializado.

El de PythonDecimal, el de JavaBigDecimal, el de C#decimalestán diseñados para esto.

Si almacenas montos con punto flotante, cuando descubras que el error acumulado de 0.01 se convierte en 0.010000000000000002, el problema ya lleva mucho tiempo sembrado.


Rango de valores y valores especiales de los números de punto flotante

IEEE 754 reserva varias combinaciones especiales para el exponente y la mantisa:

CategoríaBit de signoExponente (almacenado)MantisaSignificado
Cero0 o 10 (todos 0)Todos 0+0 o -0
Número no normalizado0 o 10 (todos 0)No todos 0Valores muy cercanos a 0
Número normalizado0 o 11 ~ 254CualquieraNúmeros de punto flotante normales
Infinito0 o 1255 (todos 1)Todos 0+Infinito o -Infinito
NaNCualquiera255 (todos 1)No todos 0No es un número (por ejemplo, 0/0)

Rango aproximado del float de precisión simple (32 bits):

  • Valor positivo máximo: aproximadamente 3.4 x 1038
  • Valor positivo mínimo (normalizado): aproximadamente 1.2 x 10-38
  • Valor positivo mínimo (no normalizado): aproximadamente 1.4 x 10-45
  • Precisión efectiva: aproximadamente 7 dígitos decimales significativos

El double de doble precisión (64 bits) tiene un rango mayor y mayor precisión:

  • 11 bits de exponente (sesgo 1023)
  • 52 bits de mantisa
  • Precisión efectiva: aproximadamente 15 a 16 dígitos decimales significativos

Tres casos de pérdida de precisión en punto flotante

Caso 1: error de conversión de decimal a binario

Como el ejemplo anterior de 0.1.

Cualquier decimal que es 'limpio' en base decimal puede ser periódico infinito en binario.

Solo las fracciones cuyo denominador es una potencia de 2 (como 0.5, 0.25, 0.125) se pueden representar exactamente en binario.

Caso 2: sumar un número grande y uno pequeño

La precisión de los números de punto flotante no está distribuida uniformemente: cuanto mayor es el valor, mayor es la mínima diferencia distinguible.

Por ejemplo, 16777216.0 + 1.0 = 16777216.0 (el resultado no cambia en float32).

Porque un número de punto flotante de 32 bits solo puede representar con precisión unos 7 dígitos significativos, y 16777216 ya ocupa 8 dígitos.

El cambio producido al sumar 1 cae dentro del rango de precisión que la mantisa no puede representar, y se «traga» directamente.

Caso 3: restar números cercanos

Restar dos números de punto flotante muy cercanos puede provocaruna pérdida catastrófica de dígitos significativos。

Por ejemplo, 1.2345678 - 1.2345677 = 0.0000001, pero el cálculo real puede dar un resultado con gran error como 0.000000099999...

Conocer las limitaciones de precisión de los números de punto flotante no es para que tengas «miedo» de usarlos, sino para que elijas la herramienta adecuada en el escenario adecuado. Cálculo científico, renderizado gráfico, aprendizaje automático: los números de punto flotante son más que suficientes en estos campos. Pero finanzas, contabilidad, conteo preciso: mantente alejado de los números de punto flotante.


Demostración de código: el secreto de los números de punto flotante

Ejemplo

# Demostración completa del problema de precisión de punto flotante (demostración de ejemplo)
import struct

def float_to_ieee754_binary(num):
    """Convierte un número de punto flotante a la representación de tres partes de precisión simple IEEE 754"""
    # Usa struct para empaquetar el número de punto flotante en 4 bytes (big-endian)
    packed = struct.pack('>f', num)
    # Convierte a una cadena binaria de 32 bits
    bits = ''.join(f'{b:08b}' for b in packed)

    sign = bits[0]
    exponent = bits[1:9]
    mantissa = bits[9:32]

    exp_stored = int(exponent, 2)
    exp_actual = exp_stored - 127

    # Calcula el valor decimal de la mantisa
    frac = 0
    for i, bit in enumerate(mantissa):
        if bit == '1':
            frac += 2 ** -(i + 1)

    value = (-1 if sign == '1' else 1) * (1 + frac) * (2 ** exp_actual)

    return {
        'bits': bits,
        'sign': sign,
        'exponent': exponent,
        'mantissa': mantissa,
        'exp_stored': exp_stored,
        'exp_actual': exp_actual,
        'fraction': frac,
        'reconstructed': value
    }

# =============================================
# Demostración 1: Comparar la representación de 0.5 y 0.1
# =============================================
print("=" * 60)
print(Demostración 1: Por qué 0.5 es exacto y 0.1 no)
print("=" * 60)

for num in [0.5, 0.1]:
    r = float_to_ieee754_binary(num)
    print(f"\nNúmero de punto flotante: {num})
    print(fBit de signo: {r['sign']} ({'Positivo' if r['sign'] == '0' else 'Negativo'}))
    print(fBit de exponente: {r['exponent']} (almacenado={r['exp_stored']}, real={r['exp_actual']}))
    print(fBits de mantisa: {r['mantissa']})
    print(fValor realmente almacenado: {r['reconstructed']})

# =============================================
# Demostración 2: El clásico 0.1 + 0.2 != 0.3
# =============================================
print("\n" + "=" * 60)
print(Demostración 2: 0.1 + 0.2 != 0.3)
print("=" * 60)

# Usa mayor precisión para mostrar
import decimal
ctx = decimal.getcontext()
ctx.prec = 50

a = decimal.Decimal(0.1)
b = decimal.Decimal(0.2)
c = decimal.Decimal(0.3)

print(fValor real de 0.1: {a})
print(fValor real de 0.2: {b})
print(fValor real de 0.3: {c})
print(f"0.1 + 0.2  = {a + b}")
print(f"0.1 + 0.2 == 0.3 ? {0.1 + 0.2 == 0.3}")

# =============================================
# Demostración 3: Los números grandes «se tragan» a los pequeños
# =============================================
print("\n" + "=" * 60)
print(Demostración 3: Un número grande más uno pequeño se ve engullido)
print("=" * 60)

big = 16777216.0
small = 1.0
result = big + small
print(f"{big} + {small} = {result}")
print(f¿El resultado es igual al número original? {result == big})

# Muestra que este número alcanza el límite de precisión de float32
print(f"\nRazón: {big} en float32 necesita {len(format(struct.unpack('>I', struct.pack('>f', big)))
print(fEl intervalo mínimo entre dos valores float32 adyacentes es aproximadamente 2^24 / 2^23 = 2.0)

# =============================================
# Demostración 4: Técnica correcta de conversión entre mayúsculas y minúsculas
# =============================================
print("\n" + "=" * 60)
print(Demostración 4: Caso EJEMPLO - Manejo correcto de cantidades de dinero)
print("=" * 60)

from decimal import Decimal

# Método incorrecto: usar float
float_total = 0.1 + 0.2
print(fError (punto flotante): 0.1 + 0.2 = {float_total})

# Método correcto: usar Decimal
decimal_total = Decimal('0.1') + Decimal('0.2')
print(fCorrecto (Decimal): Decimal('0.1') + Decimal('0.2') = {decimal_total})

# O usa enteros (en céntimos)
cents_total = 10 + 20  # 0.1 yuan = 10 céntimos, 0.2 yuan = 20 céntimos
print(fCorrecto (céntimos enteros): 10 céntimos + 20 céntimos = {cents_total} céntimos = {cents_total/100} yuanes)

# =============================================
# Demostración 5: Valores especiales de los números de punto flotante
# =============================================
print("\n" + "=" * 60)
print(Demostración 5: Valores especiales de los números de punto flotante)
print("=" * 60)

import math

# Infinito
print(f"float('inf')    = {float('inf')}")
print(f"1.0 / 0.0       = {1.0 / 0.0}")
print(f"float('inf') > 1e1000000 = {float('inf') > 1e1000000}")

# NaN
print(f"float('nan')     = {float('nan')}")
print(f"0.0 / 0.0        = {0.0 / 0.0}")
print(f"float('nan') == float('nan') ? {float('nan') == float('nan')}")
print(f(NaN no es igual a ningún valor, ¡ni siquiera a sí mismo!))

# Comprobar NaN
print(f"math.isnan(float('nan')) = {math.isnan(float('nan'))}")

Recomendaciones prácticas: qué usar y cuándo

EscenarioTipo recomendadoMotivo
Cálculo científico, renderizado gráficofloat o doublePrecisión suficiente, buen soporte de aceleración por hardware
Cálculo de montos financierosDecimal / BigDecimalOperaciones decimales exactas, sin errores de redondeo
Contadores, índicesint / longEnteros exactos, sin problemas de precisión
Comparar números de punto flotanteComparar con toleranciaNo se debe usar ==, sino abs(a-b) < epsilon
Almacenamiento/transmisión de monedaEnteros (en céntimos)Evitar errores de punto flotante al serializar
Otras extensiones