HOWTO · Python

Imitar la función ode45() en Python

Este artículo analiza la implementación de la función ode45() en python. Originalmente, la función se define en MatLab. Sin embargo, el artículo analiza la implementación de la función ode45() utilizando el módulo scipy en Python.

En esta página

La función ode45() de MATLAB resuelve problemas de valor inicial para ecuaciones diferenciales ordinarias (EDO) con un método adaptativo de Runge-Kutta. Python no tiene ninguna función llamada literalmente ode45(), pero solve_ivp() de SciPy cubre el mismo flujo de trabajo: describes la ecuación, le das al solucionador un intervalo de tiempo y un estado inicial, y lees la solución en el objeto que devuelve.

Usa solve_ivp() de SciPy para ode45() de MATLAB

La función solve_ivp() de scipy.integrate es el análogo práctico más cercano a ode45(). Su método predeterminado, RK45, es una fórmula explícita de Runge-Kutta de orden 5(4) con control automático del tamaño de paso, la misma familia de algoritmos que ode45() utiliza en MATLAB, de modo que el solucionador da pasos más grandes donde la solución cambia lentamente y pasos más pequeños donde cambia rápidamente.

No es un reemplazo directo: los nombres de los argumentos difieren y el resultado vuelve como un único objeto en lugar de un par de arrays t e y. Aun así, el patrón general —una función de derivadas, un intervalo de tiempo y un estado inicial— se corresponde directamente entre ambos. Instala SciPy con pip install scipy si aún no está disponible.

Define la EDO y llama a solve_ivp()

La llamada esencial es solve_ivp(fun, t_span, y0, method="RK45", t_eval=None, args=None, ...). Las entradas principales son:

  • fun: un invocable fun(t, y) que devuelve la derivada dy/dt para el tiempo actual t y el estado y. Para una sola ecuación devuelve un valor; para un sistema devuelve un array con una derivada por cada componente del estado.
  • t_span: un par (t_start, t_end) que indica el inicio y el fin del intervalo de integración.
  • y0: el estado en t_start; su longitud fija el número de ecuaciones del sistema.
  • method (opcional): el esquema de integración, 'RK45' de forma predeterminada.
  • args (opcional): valores adicionales que se pasan a la función como fun(t, y, *args).
  • rtol y atol (opcionales): tolerancias relativa y absoluta que controlan el tamaño de paso adaptativo.

Este ejemplo resuelve dy/dt = 2y partiendo de y(0) = 1 en el intervalo [0, 2]. La llamada devuelve un objeto de resultado; al imprimir sus atributos t e y se muestran los puntos de tiempo que eligió el solucionador y el estado en cada uno de ellos. El código y las etiquetas de la salida se mantienen en inglés:

from scipy.integrate import solve_ivp


def growth(t, y):
    return 2 * y


result = solve_ivp(growth, (0, 2), [1])
print("t:", result.t)
print("y:", result.y[0])
t: [0.         0.07580098 0.56590702 1.18757739 1.85907272 2.        ]
y: [ 1.          1.16369695  3.10133569 10.75272756 41.18553629 54.59497095]

La separación entre los tiempos reportados es irregular porque solve_ivp() adapta cada paso al comportamiento local de la solución en lugar de avanzar con un incremento fijo.

Lee el resultado del solucionador

solve_ivp() devuelve un objeto scipy.integrate.OdeResult. Los atributos que más usarás son:

  • t: un array de NumPy con los puntos de tiempo reportados. Sin t_eval, estos son los pasos adaptativos internos del solucionador.
  • y: un array bidimensional de NumPy con forma (n, len(t)); la fila i contiene el componente i del estado en cada tiempo reportado, de modo que y[:, k] es el estado en t[k]. Para una sola ecuación, y[0] es la curva de la solución.
  • sol: un interpolante continuo OdeSolution que puedes llamar como result.sol(t) para evaluar la solución en tiempos arbitrarios dentro del intervalo. Solo se rellena cuando pasas dense_output=True; en caso contrario es None.
  • success y message: un booleano que indica si la integración terminó y una descripción legible de cómo finalizó.
  • status: 0 cuando el intervalo se completó, 1 cuando ocurrió un evento de terminación y -1 cuando el solucionador no logró avanzar.

Comprobar success (o status) antes de usar y es una buena costumbre, ya que una ejecución fallida aún puede devolver arrays parciales.

Elige los tiempos de salida con t_eval

Los tiempos de paso adaptativos rara vez coinciden con los tiempos que quieres reportar. Pasa un array ordenado de tiempos a t_eval y solve_ivp() devuelve la solución exactamente en esos tiempos en lugar de en sus pasos internos. El código y las etiquetas de la salida se mantienen en inglés:

from scipy.integrate import solve_ivp


def growth(t, y):
    return 2 * y


times = [0.5, 1.0, 1.5, 2.0]
result = solve_ivp(growth, (0, 2), [1], t_eval=times)
print("t:", result.t)
print("y:", result.y[0])
t: [0.5 1.  1.5 2. ]
y: [ 2.71823524  7.38683161 20.07910026 54.59497095]

Ahora t contiene solo los tiempos solicitados e y guarda el estado interpolado en cada uno. Cada valor de t_eval debe estar dentro de t_span; pedir un tiempo fuera del intervalo de integración detiene la llamada con un error que indica que los valores deben estar dentro de t_span. Los extremos están permitidos, así que t_eval puede incluir tanto t_start como t_end.