Resolución numérica

01 · Punto de partida

La mayoría no tiene fórmula

El tanque lineal y el logístico tienen exacta bonita. El SIR, el resorte forzado, la lluvia real por horas: no. Ahí no se despeja: se integra por pasos. Partir de x₀, evaluar f, avanzar dt, repetir hasta T.

Este tema abre el bloque numérico (28–36): cuándo basta Euler, cuándo conviene Runge-Kutta y cómo medir el error contra una exacta conocida.

• ¿Hay exacta o integro desde el inicio?
• ¿Qué método: Euler simple o RK con etapas?
• ¿Qué dt equilibra error y costo?
• ¿Cómo valido el integrador antes de usarlo?

02 · Definición

¿Qué es resolver numéricamente?

Convertir la EDO en una receta de pasos:

El método no cambia la EDO: cambia cómo se recorre. Con el mismo dt, RK4 hace 4 evaluaciones y error muchísimo menor.

03 · Anatomía

Pasos, etapas y costo

El presupuesto numérico tiene tres monedas:

Paso dt

Resolución del recorrido: partirlo a la mitad duplica los nodos y parte el error de Euler a la mitad.

Etapas por paso

Evaluaciones de f: 1 en Euler, 2 en punto medio, 4 en RK4. Más etapas, mejor pendiente media.

Costo total

Pasos × etapas: Euler dt = 0,1 cuesta 100 f; RK4 dt = 1 cuesta 40 f y gana.

Orden del método

Exponente del error: 1 en Euler, 2 en punto medio, 4 en RK4. Anticipa el Tema 33.

04 · Cuándo usar cada uno

La escalera del bloque numérico

Este tema abre; los siguientes detallan:

1. 1
   Discretizar (Tema 29).

   Malla, nodos y recorte del último paso: el andamio.

2. 2
   Euler (Tema 30).

   El integrador mínimo: programarlo dormido.

3. 3
   Runge-Kutta (Tema 31).

   Etapas y promedio: precisión sin achicar dt.

4. 4
   Paso, error y estabilidad (32–34).

   Elegir dt que equilibre costo, error y no-explosión.

5. 5
   Comparar y acoplar (35–36).

   Exacta vs numérica; sistemas juntos.

05 · Representación en Python

Euler y RK4 en veinte líneas

En Python, ambos reciben f, x0, T, dt: la misma firma, distinto interior. La exacta logística los juzga.

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:
        x = x + f(x, t) * dt
        t += dt
    return x


def rk4(f, x0, t_final, dt):
    x, t = x0, 0.0
    while t < t_final - 1e-9:
        h = min(dt, t_final - t)
        k1 = f(x, t)
        k2 = f(x + k1 * h / 2, t + h / 2)
        k3 = f(x + k2 * h / 2, t + h / 2)
        k4 = f(x + k3 * h, t + h)
        x = x + h * (k1 + 2 * k2 + 2 * k3 + k4) / 6
        t += h
    return x


f = lambda p, t: 0.5 * p * (1 - p / 100)
print(round(exacta(10), 2), round(euler(f, 10, 10, 1.0), 2), round(rk4(f, 10, 10, 1.0), 4))

Exacta ≈ 94,3 · Euler ≈ 95,7 (pasa de largo) · RK4 ≈ 94,28 (clava). Mismo dt, otra liga.

Errores que hablan

El error final decide con números, no con fe:

e_euler = abs(exacta(10) - euler(f, 10, 10, 1.0))
e_rk4 = abs(exacta(10) - rk4(f, 10, 10, 1.0))
print(round(e_euler, 3), round(e_rk4, 4))

06 · Exploración

Laboratorio: Euler se pasa, RK4 clava

Logístico r = 0,5, K = 100, P₀ = 10 hasta T = 10 con tu dt. Dorada: exacta. Teal con nodos: Euler (se pasa en la subida). Naranja: RK4 (pegada). Achicá dt y observá que Euler gatea hacia la exacta mientras RK4 ya estaba.

Euler usa la pendiente del inicio del paso y se pasa en la curva; RK4 promedia cuatro pendientes y dobla con ella.

Preguntas para explorar

1. Con dt = 2, ¿Euler se pasa más o menos? ¿RK4 sigue pegada?
2. Con r = 1,0 (más curvatura), ¿el error de Euler crece? ¿Y el de RK4?
3. ¿Qué dt necesita Euler para el error de RK4 con dt = 1?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: un paso a mano

Desde P = 10 con f = 0,5·P·(1 − P/100) y dt = 1, ¿qué dan Euler y el primer k1 de RK4?

f = lambda p: 0.5 * p * (1 - p / 100)
print("euler:", round(10 + f(10) * 1, 2))
print("k1:", round(f(10), 2))

Ejercicio 2: costo honesto

Con T = 10 y dt = 1, ¿cuántas f hace Euler y cuántas RK4? ¿Y Euler con dt = 0,1?

print("euler dt=1:", 10, "· rk4 dt=1:", 40, "· euler dt=0.1:", 100)

Ejercicio 3: barrido de dt

Barré dt en Euler y RK4 sobre el logístico y compará errores finales. ¿Quién converge más rápido?

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:
        x += f(x) * dt
        t += dt
    return x


def rk4(f, x0, t_final, dt):
    x, t = x0, 0.0
    while t < t_final - 1e-9:
        h = min(dt, t_final - t)
        k1 = f(x)
        k2 = f(x + k1 * h / 2)
        k3 = f(x + k2 * h / 2)
        k4 = f(x + k3 * h)
        x += h * (k1 + 2 * k2 + 2 * k3 + k4) / 6
        t += h
    return x


f = lambda p: 0.5 * p * (1 - p / 100)
for dt in [1.0, 0.5, 0.25]:
    print(dt, round(abs(exacta(10) - euler(f, 10, 10, dt)), 3), round(abs(exacta(10) - rk4(f, 10, 10, dt)), 5))

09 · Síntesis

Ideas para recordar

En el próximo tema armaremos el andamio: discretización del tiempo.