Comparación de soluciones

01 · Punto de partida

La exacta es el juez, no el rival

Antes de soltar el integrador sobre el SIR (sin exacta), hay que probarlo donde sí la hay: logístico, tanque, exponencial. Si con dt = 1 no reproduce la exacta con error ≤ tolerancia, el bug está en el paso, no en el modelo. Comparar es validar.

El protocolo tiene tres pasos: exacta testigo, barrido de dt y veredicto con costo. Este tema lo deja instalado para todo el resto del curso.

• ¿Contra qué exacta comparo (testigo)?
• ¿Qué error y qué costo tiene cada método?
• ¿El error converge con el orden esperado?
• ¿El elegido cumple la tolerancia siendo estable?

02 · Definición

¿Qué es comparar soluciones?

El ritual de validación en tres actos:

Las cuatro condiciones son conjuntas: precisa pero inestable no vale; estable pero fuera de tol no vale; sin costo no se decide.

03 · Anatomía

Testigo, banda y convergencia

Comparar bien pide tres miradas:

Testigo del mismo palo

Curva S → logístico; convergencia → tanque; joroba → SIR no tiene: usar logístico igual.

Banda error(t)

Dónde duele, no solo cuánto al final: la subida miente, el techo perdona.

Convergencia del cociente

Partir dt y verificar 2/4/16: si no converge, hay bug o evento.

Costo en f

Pasos × etapas: el veredicto incluye la factura.

04 · Comparar en el curso

El ritual antes de cada estreno

Cada método nuevo debutó contra una exacta:

1. 1
   Euler (Tema 30).

   Contra exponencial: overshoot medido y orden 1 firmado.

2. 2
   RK (Tema 31).

   Podio 1,42/0,10/0,00 con costo 10/20/40 f.

3. 3
   Paso (Tema 32).

   dt* por método para tol 0,1: el borde óptimo.

4. 4
   Error (Tema 33).

   Curva error(t) + cociente: convergencia, no suerte.

5. 5
   Sistemas (Tema 36).

   Sin exacta: convergencia entre dts + conservación como testigo.

05 · Representación en Python

Validador en una función

En Python, validar es una función que devuelve error, cociente y veredicto: el ritual automatizado para cada método nuevo.

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(f, x0, t_final, dt):
    x, t = x0, 0.0
    while t < t_final - 1e-9:
        h = min(dt, t_final - t)
        x, t = x + f(x, t) * h, t + h
    return x


def rk2(f, x0, t_final, dt):
    x, t = x0, 0.0
    while t < t_final - 1e-9:
        h = min(dt, t_final - t)
        x, t = x + f(x + f(x, t) * h / 2, t + h / 2) * h, t + h
    return x


f = lambda p, t: 0.5 * p * (1 - p / 100)
ex = exacta(10)
for nombre, m in [("euler", euler), ("rk2", rk2)]:
    print(nombre, round(abs(ex - m(f, 10, 10, 1.0)), 3))

euler ≈ 1,42 · rk2 ≈ 0,10: con tol 0,1 pasa RK2 y Euler queda afuera.

Veredicto automático

La tolerancia decide sin discusiones:

def veredicto(metodo, tol=0.1):
    e = abs(ex - metodo(f, 10, 10, 1.0))
    return f"error {e:.3f} → {'✓ cumple' if e <= tol else '✗ no cumple'}"


print("euler:", veredicto(euler))
print("rk2:", veredicto(rk2))

06 · Exploración

Laboratorio: elegir con números

Logístico con tu método (Euler/RK2/RK4), tu dt y tu r (P₀ = 10, K = 100, T = 10). Dorada: exacta. Color: tu método con nodos. La banda sombreada es el error. La línea de tolerancia dice si pasás: movela y observá quién queda adentro.

La banda entre exacta y método es el error en cada t: si se ensancha en la subida y se cierra en el techo, es convergencia sana.

Preguntas para explorar

1. Con Euler y dt = 1, ¿pasás tol 0,10? ¿Y tol 1?
2. Con tol 0,01, ¿qué combinaciones (método, dt) cumplen? ¿La más barata?
3. Si la banda es gruesa al final pero fina en el pico, ¿el método sirve para alertas?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: veredicto a mano

Con errores Euler 1,42, RK2 0,10 y RK4 0,001, ¿quiénes cumplen tol 0,1? ¿Y tol 0,01?

errores = {"euler": 1.42, "rk2": 0.10, "rk4": 0.001}
for tol in [0.1, 0.01]:
    print(tol, [m for m, e in errores.items() if e <= tol])

Ejercicio 2: rival más barato

Con costos Euler-140 (dt 0,07), RK2-20 (dt 1) y RK4-40 (dt 1) para tol 0,1, ¿quién gana?

costos = {"euler": 140, "rk2": 20, "rk4": 40}
print(min(costos, key=costos.get))

Ejercicio 3: validador completo

Escribí validar(metodo, tol) que devuelva error, costo y veredicto. Probalo con Euler y RK2.

def validar(metodo, etapas, tol=0.1, dt=1.0, t_final=10.0):
    e = abs(ex - metodo(f, 10, t_final, dt))
    costo = int(t_final / dt) * etapas
    return round(e, 4), costo, "cumple" if e <= tol else "no cumple"


print(validar(euler, 1))
print(validar(rk2, 2))

09 · Síntesis

Ideas para recordar

En el próximo tema acoplaremos todo: simulación de sistemas con varios estados juntos.