Método de Runge-Kutta para Ecuaciones Diferenciales.

Uno de los métodos más utilizados para resolver numéricamente problemas de

ecuaciones diferenciales ordinarias con condiciones iniciales es el método de Runge-
Kutta de cuarto orden, el cual proporciona un pequeño margen de error con respecto a la
solución real del problema y es fácilmente programable en un software para realizar las
iteraciones necesarias.
El método de Runge-Kutta se utiliza para resolver ecuaciones diferenciales de la forma:

Y es sumamente útil para casos en los que la solución no puede hallarse por los métodos
convencionales (como separación de variables). Hay variaciones en el método de
Runge-Kutta de cuarto orden pero el más utilizado es el método en el cual se elige un
tamaño de paso h y un número máximo de iteraciones n tal que

y se realiza la iteración

Para i = 0,…, n-1. La solución se da a lo largo del intervalo (to, to+ hn).

1
El algoritmo para el método de Runge-Kutta de cuarto orden en seudo código es el
siguiente:
INICIO
INPUT: Número de iteraciones n (o tamaño de paso h), punto inicial del intervalo a
(punto final del intervalo b), condición inicial y (t0) = y0.

OUTPUT (t, y)
PARA

OUTPUT (t, y)
FIN PARA
FIN

2
Un software apropiado y muy útil además de fácil de programar es Matlab, con el cual
resolveremos el siguiente ejemplo:
 Resolver numéricamente con 100 iteraciones en el intervalo [1, 100] la
ecuación diferencial con condiciones iniciales dada a continuación:

Solución: Es claro que la ecuación diferencial dada no tiene una solución analítica
exacta ya que al realizar separación de variables nos encontramos con una función que
no posee antiderivada. Entonces tenemos que

Un algoritmo en Matlab para realizar la iteración es el siguiente:

3
La gráfica del resultado que entrega el programa es la siguiente:

4
Resolver la ecuación diferencial.

con el método de Runge-Kutta de 4° orden con h = 0.5 en el intervalo [0, 20] y

comparar con la solución exacta

Solución: Para hallar la solución numérica por el método de Runge-Kutta de cuarto

orden se elaboró un algoritmo en Matlab que grafica la solución numérica en rojo
marcando los puntos con asteriscos y uniéndolos por medio de rectas y en la misma
pantalla grafica la solución exacta en azul. El programa también entrega una tabla que
tiene el valor de t en la primera columna, el valor y* de la aproximación hallada
numéricamente en la segunda columna, el valor de y exacto en la tercera columna, y el
error absoluto | y-y*|. Todo lo anterior en el intervalo [0, 20].
El algoritmo en lenguaje Matlab es el siguiente:

5
6
Se tiene entonces:

7
Puede observarse en la gráfica que la aproximación realizada por el método de Runge-Kutta
es muy cercana al valor exacto de la solución, lo cual puede confirmarse con la vista de los
errores absolutos, siendo el mayor error del orden de 10-3 e igual a cero luego de t =13.5, es
decir, la aproximación numérica es igual a la solución real en esos casos.

8
A continuaci´on vamos a utilizar el m´etodo de Runge-Kutta de cuarto orden, para
resolver el problema de valor inicial
dy
= f (t, y) = −t y , y(0) = 2
, dt
para conocer un valor aproximado de y(1), con un paso h =
0.2. Empezamos calculando las siguientes constantes:

m1 = f (t0, y0) = f (0, 2) = −2

m2 = f (t0 + h/2, y0 + m1h/2) = f (0.1, 2 + (−2)(0.2)/2) = −1.7

m3 = f (t0 + h/2, y0 + m2h/2) = f (0.1, 2 + (−1.7)(0.2)/2) =

−1.73 m4 = f (t0 + h, y0 + m3h) = f (0.2, 2 + 0.2(−1.73)) =

−1.454

con lo cual

y1 = y0 + (m1 + 2m2 + 2m3 + m4) =

h6 0.2
2+ 6
(−2 − 3.4 − 3.46 − 1.454) = 1.6562 .

Al ser muy numerosas el nu´mero de operaciones que debemos hacer, proseguiremos

utilizando el programa Mathematica◎.

f[t , y ] := −
t

y; a = 0.;
b = 1.;
dato = {2.} ;
n = 5;
h = (b− a)/n;
nodo = Table[a + ih,{ i, 0,} n ];
For[i = 2, i <= n + 1, i + +,
m1 = f[nodo[[i − 1]], dato[[i − 1]]];
m2 = f[nodo[[i − 1]] + h/2, dato[[i − 1]] + (h/2)m1];
m3 = f[nodo[[i − 1]] + h/2, dato[[i − 1]] + (h/2)m2];
m4 = f[nodo[[i − 1]] + h, dato[[i − 1]] + hm3];
AppendTo[dato, dato[[i − 1]] + (h/6)(m1 + 2m2 + 2m3 + m4)]];
Print[Table[{nodo[[i]], dato[[i]]}, {i, n + 1}], PlotJoined
→ True]

Una vez ejecutado, la respuesta que obtenemos es la siguiente:

{{0., 2.}, {0.2, 1.6562}, {0.4, 1.41097}, {0.6, 1.24645}, {0.8, 1.148}, {1.,
1.10366}}

9
10