Error numérico

01 · Punto de partida

Cada paso miente un poco

Euler con dt = 1 en la exponencial erra 26 al final: ¿de dónde salieron? Cada paso aporta un error local (la tangente no es la curva) que los pasos siguientes arrastran y amplifican. La suma es el error global: el que mide el laboratorio.

Entender la cadena local → acumulación → global permite predecir el error sin conocer la exacta: basta partir dt y mirar el cociente.

• ¿Cuánto miente un paso solo (local ∝ dt²)?
• ¿Cómo se suman los locales (global ∝ dt)?
• ¿El redondeo flotante compite ya?
• ¿Partir dt confirma el orden con el cociente?

02 · Definición

¿De qué está hecho el error?

Tres ingredientes:

El cociente de globales al partir dt delata el orden sin exacta: 2 en Euler, 4 en RK2, 16 en RK4.

03 · Anatomía

Local, global y redondeo

El error en tres tiempos:

Local (un paso)

Euler supone recta donde hay curva: ∝ f''·dt²/2. En la subida logística es grande.

Global (T entero)

Suma arrastrada: ∝ dt^p. Crece con T y con la sensibilidad del modelo.

Redondeo (flotante)

1e−16 por f: con 1e6 pasos suma 1e−10. Solo manda con dt ridículo.

Cociente sin exacta

error(dt)/error(dt/2) → 2^p: estima el orden con dos corridas, sin fórmula.

04 · Errores del curso

La misma suma en cada modelo

Cada laboratorio acumuló igual:

1. 1
   Exponencial.

   Local siempre del mismo signo: el global se suma sin piedad (overshoot).

2. 2
   Logístico.

   Local cambia de signo en la inflexión: el final puede cancelar parte.

3. 3
   Resorte.

   El error cambia amplitud y fase: duele en forma, no solo en número.

4. 4
   SIR.

   El error mueve el pico en altura y día: dos números sensibles.

5. 5
   RK.

   Local ∝ dt⁵, global ∝ dt⁴: la suma también se achica rapidísimo.

05 · Representación en Python

Curva de error y cociente de orden

En Python, el error es una curva error(t) contra la exacta, y el orden un cociente entre dos dts.

import math


def exacta(t, p0=10.0, r=0.5, k=100.0):
    return k / (1 + (k - p0) / p0 * math.exp(-r * t))


def euler_hist(f, x0, t_final, dt):
    x, t, hist = x0, 0.0, [(0.0, x0)]
    while t < t_final - 1e-9:
        h = min(dt, t_final - t)
        x, t = x + f(x, t) * h, t + h
        hist.append((round(t, 2), x))
    return hist


f = lambda p, t: 0.5 * p * (1 - p / 100)
hist = euler_hist(f, 10, 10, 1.0)
print(hist[0], "…", (hist[-1][0], round(hist[-1][1], 2)))

La historia guarda cada nodo: restar la exacta en cada t dibuja error(t).

Cociente que firma el orden

Dos corridas bastan para estimar p sin exacta teórica:

def error_final(dt):
    h = euler_hist(f, 10, 10, dt)
    return abs(h[-1][1] - exacta(10))


e1, e2 = error_final(1.0), error_final(0.5)
print(round(e1, 3), round(e2, 3), "cociente:", round(e1 / e2, 2))

06 · Exploración

Laboratorio: el error nace y se suma

Euler en el logístico con tu dt (teal) y con tu dt/2 (naranja): curvas de error |Euler − exacta|(t) hasta T = 10. La de dt/2 va casi a la mitad en todo t: el cociente final confirma orden 1. Subí r y observá que ambas crecen (más curvatura, más local).

El error nace en la subida (máxima curvatura) y se arrastra: la curva no baja después del pico de pendiente.

Preguntas para explorar

1. ¿Dónde nace el error: al inicio, en la inflexión o en el techo?
2. Con r = 1,0, ¿los errores suben? ¿El cociente sigue ≈ 2?
3. Si el cociente diera 1,2 con dt/2, ¿qué sospecharías?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: local de un paso

Desde P = 10 con f logística (r = 0,5) y dt = 1, compará Euler contra la exacta en t = 1. ¿Cuánto miente un paso?

import math


def exacta1(t=1.0):
    return 100 / (1 + 9 * math.exp(-0.5 * t))


print("euler:", 10 + 0.5 * 10 * 0.9 * 1)
print("exacta:", round(exacta1(), 3))

Ejercicio 2: cociente de orden

Con errores 1,42 (dt = 1) y 0,68 (dt = 0,5), estimá el orden con log2 del cociente.

import math


print(round(math.log(1.42 / 0.68, 2), 2))

Ejercicio 3: curva error(t)

Construí error(t) = |Euler − exacta|(t) con dt = 1 hasta T = 10. ¿Dónde es máximo?

import math


def exacta(t):
    return 100 / (1 + 9 * math.exp(-0.5 * t))


def curva_error(dt=1.0, t_final=10.0):
    p, t, errs = 10.0, 0.0, []
    while t < t_final - 1e-9:
        h = min(dt, t_final - t)
        p = p + 0.5 * p * (1 - p / 100) * h
        t += h
        errs.append((round(t, 1), round(abs(p - exacta(t)), 2)))
    return errs


e = curva_error()
print(max(e, key=lambda q: q[1]))

09 · Síntesis

Ideas para recordar

En el próximo tema veremos cuándo el método explota: la estabilidad numérica.