Precisión de punto flotante

01 · Punto de partida

0,1 + 0,2 = 0,30000000000000004

Probalo en Python, en JS, en tu calculadora de programador: da 0,30000000000000004. No es un bug de tu código ni del lenguaje: es que 0,1 en binario es periódico (como 1/3 en decimal) y el double de 64 bits lo trunca a 53 bits. Toda tu simulación vive sobre esa grilla finita: conviene conocer sus reglas antes de que te muerdan (Temas 40–42).

Este tema abre el bloque numérico final (Temas 39–43): del bit al algoritmo estable.

• ¿Cómo se arma un double (signo, exponente, mantisa)?
• ¿Qué es el épsilon de máquina y cuánto vale?
• ¿Por qué 0,1 no existe en binario finito?
• ¿Cómo comparo decimales sin ==?

02 · Definición

Signo, exponente y 53 bits

03 · Fenómenos básicos

Representación, absorción y == roto

Tres caras del mismo bit finito: el valor guardado no es el escrito (representación), sumar poco a mucho no suma nada (absorción) y comparar con == falla por 1 ulp (unidad de último lugar).

Error de representación

0.1 se guarda como 0,1000000000000000055511…: error ≈ 5,5e−18 relativo. Invisible solo, visible al acumular (Tema 42).

Absorción

Si |y| < |x|·ε/2, entonces x + y == x: 1e16 + 1 == 1e16 da True. El sumando chico desaparece.

Comparación con tolerancia

Nunca a == b con floats: math.isclose(a, b, rel_tol=1e-9). El == exige el mismo bit, no el mismo valor matemático.

04 · Ejemplos

Tres clásicos de entrevista

1. 1
   0,1 + 0,2.

   Dos truncamientos + redondeo de la suma = …004. Error ≈ 4e−17: irrelevante solo, mortal acumulado un millón de veces.

2. 2
   Bucle x += 0,1 10 veces.

   Termina en 0,9999999999999999, no en 1,0: el while x != 1,0 itera de más o de menos.

3. 3
   1e16 + 1 == 1e16.

   True: el paso de la grilla cerca de 1e16 es 2,0. Contadores grandes + incrementos chicos = estancamiento.

05 · Demostración en Python

Ver el bit de cerca

Tres líneas que todo programador debe ejecutar una vez: la suma famosa, el épsilon y la absorción.

import math
import sys

print(repr(0.1 + 0.2))
print("== 0.3:", (0.1 + 0.2) == 0.3)
print("isclose:", math.isclose(0.1 + 0.2, 0.3))
print("epsilon:", sys.float_info.epsilon)

…004, False, True, 2,22e−16: el resumen del tema en 4 líneas.

Absorción en vivo

grande = 1e16
print(grande + 1 == grande)
print(grande + 100 == grande)
x = 0.0
for _ in range(10):
    x += 0.1
print(repr(x), x == 1.0)

06 · Exploración

Laboratorio: el error que crece sumando

Sumá un paso chico N veces (x += paso) y mirá el error |acumulado − N·paso|: con paso 0,1 el error oscila y crece; con paso 0,5 (exacto) es siempre 0. El panel lo mide en ulps y en valor absoluto.

La curva es el error absoluto en función de N. Con paso exacto es una línea en 0; con inexacto, deriva.

Preguntas para explorar

1. Con paso 0,1 y N = 5000: ¿el error supera 1 ulp? ¿Cuántos?
2. Con paso 0,5: ¿hay algún N con error ≠ 0? ¿Por qué?
3. Si este acumulado fuera tu reloj simulado, ¿qué creés que pasa con los eventos programados?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: el bucle que nunca llega

Mostrá que x += 0,1 10 veces no da 1,0 exacto y arreglalo iterando con enteros.

x = 0.0
for _ in range(10):
    x += 0.1
print(repr(x), x == 1.0)
print([i / 10 for i in range(11)][-1] == 1.0)

Ejercicio 2: épsilon en acción

Verificá que 1 + ε/2 == 1 y que 1 + ε == 1 es False.

import sys

eps = sys.float_info.epsilon
print(eps, 1 + eps / 2 == 1, 1 + eps == 1)

Ejercicio 3: comparar bien

Escribí cerca(a, b) con tolerancia y probala con 0,1+0,2 frente a 0,3 y con 1e16+1 frente a 1e16.

import math

def cerca(a, b, tol=1e-9):
    return math.isclose(a, b, rel_tol=tol, abs_tol=tol)


print(cerca(0.1 + 0.2, 0.3))
print(cerca(1e16 + 1, 1e16))

09 · Síntesis

Ideas para recordar

En el próximo tema, el primo del formato: el error de redondeo en cada operación.