Historia

Método de Euler: Leonhard Euler desarrolló su método en el siglo XVIII como una de las primeras técnicas para resolver ecuaciones diferenciales ordinarias. Este método utiliza una aproximación lineal para avanzar paso a paso en la solución de la ecuación diferencial, siendo sencillo pero con limitaciones en precisión y estabilidad.

Métodos de Runge-Kutta: A principios del siglo XX, Carl Runge y Wilhelm Kutta desarrollaron una familia de métodos que mejoran la precisión del método de Euler al considerar múltiples evaluaciones de la función en cada paso. Estos métodos, especialmente el de cuarto orden, se han convertido en herramientas estándar para la resolución numérica de ecuaciones diferenciales ordinarias. Wikipedia

Funciones Fundamentales del Método de Runge-Kutta

Función de la Ecuación Diferencial $f(x, y)$

El método de Runge-Kutta se aplica a ecuaciones diferenciales de la forma:

donde $f(x, y)$ define la relación entre la variable dependiente $y$ y la independiente $x$.
Ejemplo:

Aquí, la función diferencial es:

Esta expresión se evalúa en distintos puntos para estimar la solución.

Función para el Cálculo de los Coeficientes de Runge-Kutta

El método de Runge-Kutta de orden 4 (RK4) utiliza cuatro coeficientes intermedios para calcular la próxima estimación de $y$. Estos coeficientes son:

donde $h$ es el tamaño del paso utilizado para avanzar en la solución.

Cada coeficiente aproxima la pendiente de la ecuación diferencial en distintos puntos dentro del intervalo.

Función para el Cálculo del Nuevo Valor de $y$

La nueva estimación de $y$ se obtiene mediante la combinación ponderada de los coeficientes calculados:

Este promedio ponderado mejora la precisión de la aproximación en comparación con otros métodos más básicos.

Función de Iteración para Resolver el Problema en un Rango de Valores

Para encontrar la solución en un intervalo, se ejecuta la siguiente iteración:

1. Evaluar $k_1$, $k_2$, $k_3$ y $k_4$ en cada paso.
2. Calcular $y_{n+1}$ con la fórmula de actualización.
3. Repetir el proceso hasta llegar al valor deseado de $x$.

Función Global: Algoritmo del Método de Runge-Kutta

Aquí tienes el pseudocódigo para aplicar el método:

function runge_kutta(f, x0, y0, h, n):
    for i from 1 to n:
        k1 = h * f(x0, y0)
        k2 = h * f(x0 + h/2, y0 + k1/2)
        k3 = h * f(x0 + h/2, y0 + k2/2)
        k4 = h * f(x0 + h, y0 + k3)
        
        y0 = y0 + (1/6) * (k1 + 2*k2 + 2*k3 + k4)
        x0 = x0 + h
        
    return y0

Este código sigue la metodología del Runge-Kutta de orden 4, garantizando una aproximación precisa para la solución de ecuaciones diferenciales.

Pasos para Resolver una Ecuación Diferencial con el Método de Runge-Kutta

El Método de Runge-Kutta de orden 4 (RK4) es una técnica numérica que proporciona una aproximación precisa a la solución de ecuaciones diferenciales ordinarias. Aquí te explico cómo aplicarlo paso a paso.

Paso 1: Definir la ecuación diferencial

Se parte de una ecuación diferencial de primer orden:

donde $f(x, y)$ es una función que describe la tasa de cambio de $y$ con respecto a $x$.

Ejemplo:

Paso 2: Establecer las condiciones iniciales

Se define un valor inicial para $x$ y $y$:

• $x_0$: Punto inicial en el dominio de la ecuación.
• $y_0$: Valor de la función en $x_0$.
• $h$: Tamaño del paso, que define la distancia entre iteraciones.
• $N$: Número de pasos para alcanzar el valor deseado de $x$.

Ejemplo:
Si queremos aproximar $y(x)$ en $x = 1.5$, con $x_0 = 1$, $y_0 = 2$ y un tamaño de paso $h = 0.1$, avanzaremos iterativamente hasta llegar al punto deseado.

Paso 3: Calcular los coeficientes de Runge-Kutta

En cada iteración, se calculan cuatro coeficientes basados en la ecuación diferencial:

Calcular $k_1$

Calcular $k_2$

Calcular $k_3$

Calcular $k_4$

Cada coeficiente representa una estimación de la pendiente en distintos puntos del intervalo.

Paso 4: Calcular el nuevo valor de $y$

El próximo valor de $y$ se obtiene mediante:

Este promedio ponderado mejora la precisión de la aproximación.

Paso 5: Actualizar el valor de $x$ y repetir el proceso

El nuevo valor de $x$ se calcula con:

Se repiten los cálculos de $k_1$, $k_2$, $k_3$ y $k_4$ hasta alcanzar el número de iteraciones necesarias para llegar al valor deseado de $x$.

Paso 6: Presentar el resultado final

Después de realizar todas las iteraciones, el valor final de $y$ es la aproximación numérica de la función en el punto deseado.

Ejemplo de Aplicación del Método de Runge-Kutta

Supongamos que queremos resolver la siguiente ecuación diferencial usando el método de Runge-Kutta de orden 4 (RK4):

con la condición inicial:

y queremos aproximar el valor de $y$ en $x = 0.2$ usando un paso de $h = 0.1$.

Paso 1: Calcular los coeficientes de Runge-Kutta

Para la primera iteración con $x_0 = 0$ y $y_0 = 1$:

Calcular $k_1$

Calcular $k_2$

Calcular $k_3$

Calcular $k_4$

Paso 2: Calcular el nuevo valor de $y$

La aproximación de $y$ en $x = 0.1$ se obtiene con:

Sustituyendo los valores:

Este es el valor aproximado de $y$ en $x = 0.1$.

Paso 3: Segunda Iteración

Ahora usamos $x_1 = 0.1$ y $y_1 = 1.113675$ para calcular el valor en $x = 0.2$. Siguiendo el mismo procedimiento:

Calcular $k_1$

Calcular $k_2$

Calcular $k_3$

Calcular $k_4$

Usamos la fórmula de actualización:

Este es el valor aproximado de $y$ en $x = 0.2$.

Usando el método de Runge-Kutta de orden 4, hemos encontrado que la solución aproximada para $y(0.2)$ es:

Ejemplo en python

import numpy as np
import matplotlib.pyplot as plt

def runge_kutta_4(f, x0, y0, h, n, return_all=False):
    """ 
    Implementa el método de Runge-Kutta de orden 4 para resolver ecuaciones diferenciales.
    
    Parámetros:
    - f: Función que define la EDO dy/dx = f(x, y)
    - x0: Valor inicial de x
    - y0: Valor inicial de y
    - h: Tamaño de paso
    - n: Número de iteraciones
    - return_all: Si es True, devuelve todos los valores de x e y calculados
    
    Retorna:
    - Si return_all=False: Último valor de y
    - Si return_all=True: Arrays de x e y en cada paso
    """
    x = x0
    y = y0
    
    if return_all:
        x_vals = [x0]
        y_vals = [y0]
    
    for _ in range(n):
        k1 = h * f(x, y)
        k2 = h * f(x + h/2, y + k1/2)
        k3 = h * f(x + h/2, y + k2/2)
        k4 = h * f(x + h, y + k3)

        y += (1/6) * (k1 + 2*k2 + 2*k3 + k4)
        x += h
        
        if return_all:
            x_vals.append(x)
            y_vals.append(y)
    
    if return_all:
        return np.array(x_vals), np.array(y_vals)
    else:
        return y

# Definimos la ecuación diferencial dy/dx = x + y
def f(x, y):
    return x + y

# Valores iniciales
x0 = 0    # Valor inicial de x
y0 = 1    # Valor inicial de y
h = 0.1   # Tamaño de paso
x_final = 0.2  # Valor de x donde queremos la solución

# Número de iteraciones necesarias
n = int((x_final - x0) / h)

# Calcular la solución con RK4 (guardando todos los pasos)
x_vals, y_vals = runge_kutta_4(f, x0, y0, h, n, return_all=True)

# Solución exacta para comparación (solución analítica de dy/dx = x + y)
def exact_solution(x):
    return 2 * np.exp(x) - x - 1

# Valores exactos
x_exact = np.linspace(x0, x_final, 100)
y_exact = exact_solution(x_exact)

# Graficación
plt.figure(figsize=(10, 6))
plt.plot(x_exact, y_exact, label='Solución exacta: $y = 2e^x - x - 1$', color='black', linestyle='--', linewidth=1.5)
plt.plot(x_vals, y_vals, 'o-', label=f'Aproximación RK4 (h={h})', color='blue', markersize=6, linewidth=1.5)

# Punto final resaltado
plt.scatter(x_vals[-1], y_vals[-1], color='red', s=100, zorder=5, 
            label=f'Aproximación en $x={x_final}$: {y_vals[-1]:.6f}')

plt.title('Método de Runge-Kutta de Orden 4 para $dy/dx = x + y$')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True, linestyle='--', alpha=0.7)
plt.legend()
plt.show()

# Imprimir resultado numérico
print(f"\nAproximación RK4 de y({x_final}) = {y_vals[-1]:.6f}")
print(f"Solución exacta y({x_final}) = {exact_solution(x_final):.6f}")
print(f"Error absoluto = {abs(y_vals[-1] - exact_solution(x_final)):.2e}")

Salida

Aproximación RK4 de y(0.2) = 1.242805
Solución exacta y(0.2) = 1.242806
Error absoluto = 3.75e-07

Grafica

Explicacion visual

Conclusión

El método de Euler y el método de Runge-Kutta son fundamentales en la resolución numérica de ecuaciones diferenciales ordinarias. El método de Euler es el más simple de los métodos explícitos y proporciona una solución aproximada utilizando un paso constante, aunque con errores que aumentan con el tiempo. El método de Runge-Kutta, por otro lado, mejora significativamente la precisión mediante una serie de pasos intermedios. Ambos métodos son esenciales en la simulación de sistemas dinámicos y en la resolución de problemas de física, ingeniería y biología.

La relevancia de estos métodos radica en su capacidad para modelar de manera eficiente sistemas complejos que no pueden resolverse de manera exacta, como los sistemas de ecuaciones diferenciales que describen fenómenos naturales. El método de Runge-Kutta, en particular, es ampliamente utilizado debido a su alta precisión y su aplicabilidad en la mayoría de los problemas prácticos, donde la simulación numérica de procesos dinámicos es crucial (Atkinson, 2008).

Atkinson, K. E. (2008). An Introduction to Numerical Analysis (2nd ed.). Wiley.