Runge-Kutta

01 · Punto de partida

Euler mira una vez, RK mira varias

Euler congela f del inicio y salta: si la pendiente cambia en el camino, se pasa. Runge-Kutta prueba f al inicio (k₁), a la mitad (k₂, k₃) y al final (k₄) y promedia: el paso dobla con la curva en vez de seguir la tangente vieja.

El precio son más evaluaciones por paso; el premio es error muchísimo menor con el mismo dt.

• ¿Cuántas etapas pruebo por paso (1, 2, 4)?
• ¿Cómo promedio k₁–k₄ (pesos)?
• ¿Qué orden gano (1, 2, 4)?
• ¿El costo extra se paga con menos pasos?

02 · Definición

¿Qué son los métodos de Runge-Kutta?

La escalera de promedios:

Orden 4 significa: partir dt a la mitad divide el error por 16. Por eso RK4 con dt = 1 supera a Euler con dt = 0,1.

03 · Anatomía

Etapas, pesos y orden

Cómo se construye el promedio:

Etapa kᵢ

Una evaluación de f en un punto de prueba: inicio, medio con k₁, medio con k₂, final con k₃.

Pesos 1-2-2-1

RK4 pondera el medio doble: k₁ + 2k₂ + 2k₃ + k₄ sobre 6. El medio manda.

Orden p

Error ∝ dt^p: partir dt divide el error por 2^p (2, 4, 16). Anticipa el Tema 33.

Costo honesto

Pasos × etapas: comparar a igual f totales, no a igual dt.

04 · RK en el curso

Dónde el promedio paga

Cada curva sensible agradece etapas:

1. 1
   Logístico.

   Curva que se dobla: RK2/RK4 la siguen, Euler se pasa.

2. 2
   Resorte.

   Oscilación: RK conserva amplitud y fase mucho mejor.

3. 3
   SIR.

   Pico agudo: RK ubica altura y día con menos pasos.

4. 4
   Exponencial.

   Despegue: RK4 casi clava con dt = 1.

5. 5
   Sistemas.

   Todas las etapas avanzan el vector junto: kᵢ son vectores.

05 · Representación en Python

RK2 y RK4 genéricos

En Python, los tres comparten firma metodo(f, x0, T, dt): solo cambia el interior del paso.

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 rk2(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)
        x, t = x + k2 * h, t + h
    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, t = 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(rk2(f, 10, 10, 1.0), 2), round(rk4(f, 10, 10, 1.0), 4))

Exacta ≈ 94,28 · RK2 ≈ 94,18 · RK4 ≈ 94,277: el promedio paga.

Errores comparados

Los tres errores en una línea deciden:

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


ex = exacta(10)
for nombre, m in [("euler", euler), ("rk2", rk2), ("rk4", rk4)]:
    print(nombre, round(abs(ex - m(f, 10, 10, 1.0)), 4))

06 · Exploración

Laboratorio: el podio Euler / RK2 / RK4

Logístico con tu dt y tu r (P₀ = 10, K = 100, T = 10). Dorada: exacta. Teal: Euler (se pasa). Naranja: RK2 (casi). Blanca fina: RK4 (pegada). Bajá dt y mirá el podio colapsar: con dt = 0,25 hasta Euler se porta.

El resaltado engrosa un método para seguirlo entre los demás. RK2 ya gana por 14× con solo el doble de f.

Preguntas para explorar

1. Con dt = 2, ¿RK2 sigue cerca? ¿Euler se dispara?
2. Con r = 1,0, ¿los errores crecen parejo o Euler sufre más?
3. ¿Qué método elegirías con f cara (1 s por evaluación) y error 0,1?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: un paso RK2 a mano

Desde P = 10 con f = 0,5·P·(1 − P/100) y dt = 1, calculá k₁, k₂ y el salto RK2.

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

Ejercicio 2: podio con números

Calculá los tres errores finales con dt = 1 en el logístico (r = 0,5, T = 10). ¿El podio cierra?

import math


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

Ejercicio 3: orden en vivo

Partí dt de 1 a 0,5 en los tres y medí por cuánto se divide cada error. ¿Da 2, 4 y 16?

f2 = lambda p, t: 0.5 * p * (1 - p / 100)
for dt in [1.0, 0.5]:
    ee = abs(exacta(10) - euler(f2, 10, 10, dt))
    e2 = abs(exacta(10) - rk2(f2, 10, 10, dt))
    e4 = abs(exacta(10) - rk4(f2, 10, 10, dt))
    print(dt, round(ee, 3), round(e2, 4), round(e4, 6))

09 · Síntesis

Ideas para recordar

En el próximo tema negociaremos el tamaño del paso: error contra costo.