Métodos de Runge-Kutta

01 · Explorar antes de avanzar

La idea de Runge-Kutta

Euler usa una sola pendiente. Los métodos de Runge-Kutta calculan varias pendientes auxiliares —llamadas etapas— en puntos cuidadosamente elegidos dentro del paso y las combinan para producir el nuevo estado.

Para un problema y′=f(t,y), cada etapa consulta el mismo modelo f; no necesitamos obtener y″, y‴ ni otras derivadas analíticas.

02 · Fórmula general explícita

Etapas, nodos y pesos

Un método Runge-Kutta explícito de s etapas tiene la forma:

• cᵢ ubica la etapa dentro del intervalo temporal;
• aᵢⱼ construye el estado donde se evalúa esa etapa;
• bᵢ determina cuánto aporta cada pendiente al avance final.

Es explícito porque la etapa kᵢ depende solo de etapas anteriores. Se calcula en orden, sin resolver sistemas algebraicos.

03 · Notación compacta

El tableau de Butcher

Los coeficientes se organizan en una tabla que describe por completo el método:

Por ejemplo, el método del punto medio del tema anterior utiliza:

La matriz A de un método explícito es triangular inferior estricta: su diagonal y todos los elementos superiores son cero.

Esta notación permite implementar familias completas, estudiar condiciones de orden y comparar métodos sin depender de nombres históricos.

04 · Punto de partida

RK2 como antecedente

Heun y punto medio son métodos Runge-Kutta de dos etapas y orden dos. Ambos calculan una primera pendiente, construyen un estado auxiliar y realizan una segunda evaluación.

Agregar etapas no aumenta el orden automáticamente. Los coeficientes deben satisfacer ecuaciones que hacen coincidir la expansión numérica con la expansión de Taylor. A medida que crece el orden, esas condiciones se multiplican.

RK4 es especialmente popular porque consigue orden cuatro con cuatro evaluaciones y coeficientes sencillos.

05 · El esquema clásico

Runge-Kutta de cuarto orden

Desde (tₙ,yₙ), el RK4 clásico calcula:

y combina las cuatro pendientes:

06 · Leer las cuatro pendientes

Por qué hay dos etapas centrales

k₁ examina el inicio. Con ella se predice un primer estado central para k₂. Luego k₂ genera otra predicción central para k₃, y esta última proyecta el estado final donde se calcula k₄.

Los pesos 1,2,2,1 favorecen la información central:

La semejanza con la regla de Simpson es sugerente, pero RK4 no consiste simplemente en aplicar Simpson: los estados intermedios también son aproximaciones construidas por el propio método.

07 · Un paso completo

RK4 para y′=y

Partimos de y(0)=1 y usamos h=0.2:

El valor exacto es e0.2≈1.221402758. El error de un único paso es aproximadamente 2.76×10⁻⁶.

08 · Implementación escalar

RK4 reutilizable en JavaScript

function pasoRK4(f, t, y, h) {
  const k1 = f(t, y);
  const k2 = f(t + h / 2, y + h * k1 / 2);
  const k3 = f(t + h / 2, y + h * k2 / 2);
  const k4 = f(t + h, y + h * k3);
  return y + h * (k1 + 2 * k2 + 2 * k3 + k4) / 6;
}

function integrarRK4(f, t0, y0, tFinal, hMaximo) {
  if (!(hMaximo > 0) || tFinal < t0) throw new Error("Intervalo inválido");
  const puntos = [{ t: t0, y: y0 }];
  let t = t0;
  let y = y0;
  while (t < tFinal) {
    const h = Math.min(hMaximo, tFinal - t);
    y = pasoRK4(f, t, y, h);
    t += h;
    if (!Number.isFinite(y)) throw new Error("Estado no finito");
    puntos.push({ t, y });
  }
  return puntos;
}

const solucion = integrarRK4((t, y) => y, 0, 1, 1, 0.25);
console.log("RK4:", solucion.at(-1).y);
console.log("exacto:", Math.E);

La función de paso no modifica el modelo ni administra la malla. Esta separación permite probarla aisladamente y reemplazarla por otro integrador.

09 · Tiempo y estado en cada etapa

Ecuaciones no autónomas

Cuando f depende explícitamente de t, cada etapa debe usar el tiempo indicado por la fórmula. En RK4, k₂ y k₃ se evalúan en t+h/2, mientras que k₄ se evalúa en t+h.

function pasoRK4(f, t, y, h) {
  const k1 = f(t, y);
  const k2 = f(t + h / 2, y + h * k1 / 2);
  const k3 = f(t + h / 2, y + h * k2 / 2);
  const k4 = f(t + h, y + h * k3);
  return y + h * (k1 + 2 * k2 + 2 * k3 + k4) / 6;
}

// y′=t-y, y(0)=1; solución exacta: y=t-1+2e^(-t)
const f = (t, y) => t - y;
const exacta = t => t - 1 + 2 * Math.exp(-t);
let t = 0;
let y = 1;
const h = 0.2;
for (let n = 0; n < 5; n++) {
  y = pasoRK4(f, t, y, h);
  t += h;
}
console.log("RK4 en t=1:", y);
console.log("exacta en t=1:", exacta(1));

Usar el mismo tiempo en las cuatro llamadas puede pasar inadvertido en modelos autónomos, pero falla en cuanto hay forzamiento temporal.

10 · Estados vectoriales

RK4 para un sistema

Cada etapa es ahora un vector. Las combinaciones deben crear estados auxiliares nuevos para que todas las componentes de una etapa provengan del mismo estado:

const combinar = (estado, h, terminos) =>
  estado.map((valor, i) =>
    valor + h * terminos.reduce((suma, [peso, k]) => suma + peso * k[i], 0));

function pasoRK4Vector(f, t, estado, h) {
  const k1 = f(t, estado);
  const k2 = f(t + h / 2, combinar(estado, h, [[1 / 2, k1]]));
  const k3 = f(t + h / 2, combinar(estado, h, [[1 / 2, k2]]));
  const k4 = f(t + h, combinar(estado, h, [[1, k3]]));
  return combinar(estado, h, [
    [1 / 6, k1], [1 / 3, k2], [1 / 3, k3], [1 / 6, k4]
  ]);
}

const oscilador = (t, [x, v]) => [v, -x];
let estado = [1, 0];
let t = 0;
const h = 0.1;
for (let n = 0; n < 100; n++) {
  estado = pasoRK4Vector(oscilador, t, estado, h);
  t += h;
}
const energia = 0.5 * (estado[0] ** 2 + estado[1] ** 2);
console.log("estado final:", estado);
console.log("energía final:", energia);

RK4 conserva aproximadamente la energía del oscilador durante este intervalo, pero no es un método simpléctico: en simulaciones muy largas puede aparecer deriva.

11 · Precisión teórica

Error local de orden cinco y global de orden cuatro

Bajo condiciones de suavidad suficientes, RK4 reproduce la expansión exacta hasta términos de grado cuatro:

Si dividimos el paso por dos, el error global debería reducirse aproximadamente por:

Esta tasa aparece cuando el error de truncamiento domina. Con pasos extremadamente pequeños, el redondeo y la acumulación de operaciones pueden impedir que la mejora continúe.

12 · Comprobación experimental

Una tabla de refinamiento

function pasoRK4(f, t, y, h) {
  const k1 = f(t, y);
  const k2 = f(t + h / 2, y + h * k1 / 2);
  const k3 = f(t + h / 2, y + h * k2 / 2);
  const k4 = f(t + h, y + h * k3);
  return y + h * (k1 + 2 * k2 + 2 * k3 + k4) / 6;
}

function resolver(pasos) {
  const h = 1 / pasos;
  let t = 0;
  let y = 1;
  for (let n = 0; n < pasos; n++) {
    y = pasoRK4((tiempo, estado) => estado, t, y, h);
    t += h;
  }
  return y;
}

let errorAnterior;
for (const pasos of [2, 4, 8, 16, 32]) {
  const error = Math.abs(Math.E - resolver(pasos));
  const cociente = errorAnterior === undefined ? "—" : errorAnterior / error;
  console.log(pasos, error.toExponential(5), cociente);
  errorAnterior = error;
}

Los cocientes tienden a 16. Si se conoce una solución exacta, esta prueba detecta errores frecuentes en tiempos, pesos o dependencias de las etapas.

13 · Precisión, costo y estabilidad

Qué se obtiene por cuatro evaluaciones

RK4 requiere cuatro evaluaciones de f por paso. Cuando evaluar el modelo domina el costo, esa es la unidad de trabajo adecuada para comparar integradores.

Para la ecuación de prueba y′=λy, RK4 tiene factor de amplificación:

Sobre el eje real negativo es estable aproximadamente para −2.785<z<0. Su intervalo es mayor que el de Euler y RK2, pero sigue siendo acotado: RK4 explícito tampoco elimina las restricciones de los problemas rígidos.

14 · Exploración interactiva

Laboratorio: precisión frente a evaluaciones

La misma malla se resuelve con Euler, punto medio y RK4. La gráfica permite ver cuánto mejora cada método y los resultados informan tanto el error como el trabajo realizado.

Preguntas para explorar

1. Duplicá la cantidad de pasos y compará cómo decrecen los tres errores.
2. Buscá el menor número de pasos con el que RK4 supera una precisión de 10⁻⁵.
3. Compará métodos con igual presupuesto: por ejemplo, 16 pasos de Euler, 8 de RK2 y 4 de RK4.
4. En el modelo forzado, observá la ventaja de evaluar correctamente los tiempos intermedios.

15 · Comprensión

Confusiones frecuentes

16 · Práctica guiada

Ejercicios

Ejercicio 1: identificar las etapas

Para y′=t+y, y(0)=1 y h=0.2, calculá k₁ y k₂ de RK4.

Ejercicio 2: completar el paso

Continuá el ejercicio anterior y calculá k₃, k₄ e y₁.

Ejercicio 3: orden observado

Los errores para h y h/2 son 1.52×10⁻⁵ y 9.80×10⁻⁷. Estimá el orden.

Ejercicio 4: presupuesto de evaluaciones

¿Cuántas evaluaciones de f realizan 50 pasos de RK4? ¿Cuántos pasos de punto medio usan el mismo presupuesto?

Ejercicio 5: límite estable

Usando el intervalo real de estabilidad de RK4, estimá el máximo paso para y′=−40y.

17 · Síntesis

Ideas para recordar

En el próximo tema estudiaremos con mayor profundidad sistemas, estabilidad y rigidez, donde la elección del método y del paso se vuelve decisiva.