Acumulación de errores numéricos

01 · Punto de partida

Medio ulp × un millón

En los Temas 39–41 viste el error de una operación: como mucho ½ ulp si redondeás (Tema 40), hasta 1 unidad sesgada si truncás (Tema 41). El problema es que una simulación no hace una operación: avanza un reloj con t += dt millones de veces, acumula energía, promedia réplicas, suma histogramas. Cada paso agrega su redondeo al pozo común.

Y el pozo tiene formas de crecer: si los redondeos tiran siempre del mismo lado (truncamiento, pasos todos positivos), el error crece lineal con N; si tiran al azar, crece como √N; y si sumás chicos sobre un gigante, el error es todo: los chicos desaparecen por absorción (Tema 39).

• ¿Cuánto error junto al sumar N veces el mismo paso?
• ¿Por qué 1e16 + 1 + 1 + … queda clavado en 1e16?
• ¿Por qué sumar chicos-primero cambia el resultado?
• ¿Cómo sumo largo sin pagar el sesgo: bloques, Kahan, fsum?

02 · Definición

Tres velocidades del desastre

03 · Anatomía

Por qué el orden cambia la suma

La suma matemática es asociativa; la suma en float no: (a+b)+c ≠ a+(b+c) en general. Cada paréntesis redondea, y redondear temprano sobre un gigante mata a los chicos antes de que se junten entre ellos.

Grande-primero (pierde)

((G + 1) + 1) + …: cada +1 muere solo contra G por absorción. Al final queda G, aunque N valga miles.

Chicos-primero (salva)

G + (1 + 1 + …): los chicos se juntan entre ellos hasta ser grandes frente a G y recién ahí se suman. Se pierde solo el redondeo final.

Suma compensada (Kahan / fsum)

Guarda aparte “lo que se perdió” en cada paso y lo reinyecta en el siguiente: error casi independiente de N. math.fsum es la versión exacta-y-lenta; Kahan, la rápida.

04 · Ejemplos

Tres acumulaciones reales

1. 1
   El reloj que se corre.

   t = 0; for _ in range(10_000): t += 0,1 termina corrido ~1e−12: cada += 0,1 redondea y el sesgo camina. Con enteros (t = i*dt) no deriva.

2. 2
   El contador clavado.

   1e16 + 1 + 1 + … (1000 unos) queda en 1e16: el paso local es 2 y cada uno muere solo. Sumando los unos primero da 10000000000001000.

3. 3
   El promedio mentiroso.

   Promediar 1 M de energías con un outlier gigante ingenuo arrastra el error de la suma al cociente. Con fsum o promedio incremental (Welford, Tema 43) el error no escala con N.

05 · Demostración en Python

Perder mil unos en una línea

El experimento mínimo: un gigante y mil unos. La suma ingenua los pierde todos; fsum y Kahan los recuperan.

import math

vals = [1e16] + [1.0] * 1000
print("naive:", sum(vals))
print("fsum: ", math.fsum(vals))
print("al revés fsum:", math.fsum(reversed(vals)))

Naive ≈ 1e16 clavado; fsum ≈ 10000000000001000: los mil unos reaparecen.

Kahan en 6 líneas

def kahan(vals):
    total = comp = 0.0
    for v in vals:
        y = v - comp
        t = total + y
        comp = (t - total) - y
        total = t
    return total


print(kahan([1e16] + [1.0] * 1000))

06 · Exploración

Laboratorio: el gigante que se come los unos

Gigante fijo G = 1e16 más N unos. La curva naranja suma ingenuo de izquierda a derecha (((G+1)+1)…) y queda clavada; la verde junta los unos primero (G + N) y crece. Movelo y contá cuántos unos se pierden.

El eje x es cuántos unos ya se sumaron; el eje y es cuánto creció el total sobre G. La ingenua queda en 0; la honesta sube en diagonal.

Preguntas para explorar

1. Con N = 1000: ¿cuánto vale la ingenua menos G? ¿Y la chicos-primero menos G?
2. Subí a N = 5000: ¿la ingenua recupera algo? ¿Por qué el paso local (ulp = 2) lo impide?
3. Si G fuera tu energía acumulada y los unos tus eventos, ¿qué orden elegirías para el total?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: el reloj que deriva

Compará t += 0,1 N veces contra i*0,1 y medí la deriva.

N = 10000
t = 0.0
for _ in range(N):
    t += 0.1
print(repr(t), repr(N * 0.1), repr(t - N * 0.1))

Ejercicio 2: contar los perdidos

Medí cuántos unos pierde la suma ingenua sobre 1e16 con N = 2000.

import math

G, N = 1e16, 2000
naive = G
for _ in range(N):
    naive += 1.0
print("naive - G:", naive - G)
print("fsum - G:", math.fsum([G] + [1.0] * N) - G)

Ejercicio 3: ordenar salva

Escribí suma_ordenada (ascendente por |x|) y comparala con sum sobre valores dispares.

import math

def suma_ordenada(vals):
    return math.fsum(sorted(vals, key=abs))


vals = [1e16, 1.0, 1.0, 1.0, -1e16]
print(sum(vals), suma_ordenada(vals), math.fsum(vals))

09 · Síntesis

Ideas para recordar

En el próximo tema convertimos estas curas en método: la estabilidad numérica, o cómo elegir algoritmos que no amplifiquen el error.