PRACTICAS

DE CALCULO
NUMERICO
AVANZADO

PRACTICA
3: M
etodos de Runge-Kutta explcitos. Pares encajados
En esta practica implementaremos un metodo de Runge-Kutta explcito general que posteriormente
utilizaremos para construir una rutina adaptativa para integrar sistemas de ecuaciones diferenciales
ordinarias (en concreto, implementaremos el metodo de Runge-Kutta Fehlberg).

M
etodos de Runge-Kutta explcitos

Construiremos un metodo de Runge-Kutta explcito general de s etapas, es decir, que implemente

cualquier metodo de un paso con la estructura:
yn+1 = yn + h

s
X

bi ki

(1)

(2)

i=1

donde

ki = f tn + ci h, yn + h

i1
X

j=1

aij kj , i = 1, ..., s

Nuestros programas deberan ser validos para sistemas de ecuaciones diferenciales ordinarias de primer
orden. Se sugiere utilizar alg
un sistema de ecuaciones sencillo como comprobacion de funcionamiento
de las rutinas que construyamos, en concreto, una posibilidad es:
y10 = y2
;
y20 = y1

y1 (0)
y2 (0)

0
1

(3)

Los programas deberan funcionar para cualquier metodo de Runge-Kutta sin mas que proporcionar el
tablero de Butcher correspondiente. Para facilitar la posterior tarea de construccion de un par encajado,
sera conveniente realizar de forma separada el calculo de las etapas k i y el calculo del paso (es decir, el
calculo de yn+1 a partir de yn ).
Construiremos la rutinas generales para metodos RK considerando como ejemplo concreto, el siguiente metodo de orden 3:

c A
bT

0
0
1/2 1/2

3/4 0
2/9

0
0
3/4
1/3

0
0
0
4/9

(4)

En resumen, se pide construir las siguientes rutinas:

1. Funcion fsis: conteniendo la funcion f (t, y), donde y es el vector columna de las soluciones. Por
ejemplo, en la caso de la Ec. (3), podramos escribir:
function f=fsis(t,y)
f=[y(2);-y(1)];
2. Rutina etapas, en las que calcularemos las k i . En la misma rutina se deberan proporcionar las
matrices c y A. La sintaxis sera:
function k=etapas(tn,yn,h)
%----------------------------------------------------------------

%Sintaxis: k=etapas(tn,yn,h)
%---------------------------------------------------------------%funcion que calcula las etapas de un metodo de RK explicito para
%sistemas de n EDOs de primer orden
%Inputs:
% tn: instante temporal
% yn: vector solucion en el instante tn (vector columna n x 1)
%
h: paso
%Outputs:
%
k: etapas (matriz n x s, donde s es el numero de etapas)
%---------------------------------------------------------------%Dentro de la rutina se han de proporcionar las matrices c y A
%---------------------------------------------------------------c=[0; 1/2; 3/4]; % Estas son las matrices c
a=[0
0 0;
% y A para un RK explicito de 3
1/2 0 0 ;
% etapas y orden 3
0
3/4 0];
Las salidas de esta rutina son pues las k i definidas en la ecuacion (2).
3. Rutina paso: dadas los valores para las etapas k i , esta rutina implementa un paso del metodo de
Runge-Kutta correspondiente. En esta rutina se proporcionara el vector b del tablero de Butcher.
La sintaxis y significado de inputs y outputs se describe a continuacion.
function yout=paso(tn,yn,h)
%---------------------------------------------------------------%Sintaxis: yout=paso(tn,yn,h)
%---------------------------------------------------------------%funcion que calcula un paso para un metodo de RK del que se
%proporciona el vector b y los valores de las etapas k_i
%Inputs:
%
tn: instante temporal
%
yn: vector solucion en el instante tn (vector columna n x 1)
%
h: paso
%Outputs:
% yout: vector solucion en el instante temporal tn+h
%---------------------------------------------------------------%Dentro de la rutina se ha de proporcionar la matriz b
%---------------------------------------------------------------%Esta rutina llama a la funcion etapas(tn,yn,h)
%---------------------------------------------------------------b=[2/9 1/3 4/9];%vector b para el RK de orden 3 dado como ejemplo
4. Rutina RK: esta rutina, utilizando rutina paso, integra la ecuacion diferencial definida por la
funcion fsis con las condiciones iniciales y0. La sintaxis es la siguiente:
function [t,y]=RK(t0,tf,y0,N)
%--------------------------------------------------------%Sintaxis: [t,y]=RK(t0,tf,y0,N)

%--------------------------------------------------------%Integracion de un sistema de EDOs de primer orden

%mediante un metodo de un paso
%Inputs:
%
t0:instante inicial
%
tf:instante final
%
y0:vector columna con las n condiciones iniciales
%
N:numero de divisiones del intervalo [t0,tf]
%Outputs:
%
t:vector conteniendo los instantes t0,t1,...,tN
%
y:matriz Nxn de las soluciones en t0,t1,...,tN
%--------------------------------------------------------%Esta funcion debe llamar a una rutina para evaluar
% y(n+1) a partir de y(n) mediante el correspondiente
% metodo de un paso (por ejemplo, mediante un Runge-Kutta)
5. Rutina orden. Escribiremos un programa para comprobar que el orden del metodo de Runge
Kutta que se da como prueba es, efectivamente, 3.

1.1

Algunos ejemplos de output como comprobaci

on

Como ayuda para comprobar el funcionamiento de las rutinas, damos algunos ejemplos numericos para
su comprobacion (aunque la mejor comprobacion sera la de obtener el orden mediante la rutina orden.
>> format short e
>> etapas(1,[0.1 0.9],0.01)
ans =
9.0000e-01
-1.0000e-01

8.9950e-01
-1.0450e-01

8.9922e-01
-1.0675e-01

>> paso(1.4,[1 3],0.1)

ans =
1.2945e+00
2.8852e+00
>> [t,y]=RK(0,1,[1 1],5)
t =
0

2.0000e-01

4.0000e-01

6.0000e-01

8.0000e-01

1.0000e+00

1.0000e+00
1.0000e+00

1.1787e+00
7.8133e-01

1.3103e+00
5.3154e-01

1.3897e+00
2.6060e-01

1.4137e+00
-2.0704e-02

1.3813e+00
-3.0114e-01

y =

1.2

Listado de programas

En resumen, para esta primera parte se piden los siguientes programas:

1. orden.m
2. RK.m
3. etapas.m
4. paso.m
5. fsis.m

Programaci
on de un par encajado

La idea de los pares encajados es simple: se basa en derivar pares de metodos de Runge-Kutta que
compartan las mismas etapas ki y que sean de ordenes consecutivos. Es decir, supone disponer de un
metodo de orden p
yn+1 = yn + h

s
X

bi ki

i=1

y de un metodo de orden p + 1:
yn+1 = yn + h

s
X

bi ki

i=1

donde

ki = f tn + ci h, yn + h

i1
X

j=1

aij kj , i = 1, ..., s

ya que consideramos metodos explcitos.

De este modo, se puede, por ejemplo, utilizar el metodo de orden p para obtener la solucion y el
metodo de orden p + 1 para estimar el error local de truncamiento. De hecho, una estimacion del mismo
para el metodo de orden p esta dada por:
Tn+1 = h

s
X

(bi bi )ki

(5)

i=1

Control adaptativo del paso de integraci

on
Si disponemos de una estimacion del error local de truncamiento, podemos plantearnos dise
nar un
algoritmo que permita adaptar el paso de integracion. Si queremos asegurarnos de que
Tn+1 < T ol ,
siendo T ol la tolerancia al error local de truncamiento que queramos imponer, podemos estimar Tn+1
como antes y comprobar si pasa o no el test. Si no lo pasa, reducimos el paso de integracion y volvemos
a dar el paso. Pero, como ha de ser el nuevo paso que tomemos para proceder de forma eficiente?.
Mediante argumentos simples podemos estimar que ese nuevo paso debe ser de la forma:
hnuevo = q

T ol

|Tn+1 |

!1/(p+1)

Hacer h=h ini

Calcular yn+1
~
Calcular la estimacion Tn+1

h n= q ~Tol
Tn+1

n = n+1
~
Es Tn+1 < Tol ?

1
p+1

hn

No

Si
1
p+1

h n+1
=q

( TTol
)
~

hn

No

Es t n+1 > b ?

n+1

Si
Fin

Figura 1: diagrama de flujo para un par encajado

siendo q, un factor de seguridad (q 0.8 suele funcionar bien).
En alg
un momento lograremos un paso de integracion que supere el test. Cuando suceda esto, sera
conveniente asegurarnos de que el siguiente paso que demos tambien va a resultar adecuado y economico.
Por tanto, avanzaremos el nuevo paso de integracion de acuerdo con la expresion anterior.

Algoritmo de un Runge-Kutta adaptativo

Aunque los diagramas de flujo estan algo pasados de moda, tienen su utilidad didactica. Damos a
continuacion el que correspondera a un metodo Runge-Kutta adaptativo tpico:

Desarrollo de la pr
actica
El metodo de Runge-Kutta-Fehlberg (4,5) responde al siguiente tablero de Butcher
0

1
4
3
8
12
13

1
4
3
32
1932
2197
439
216
8
27
25
216
16
135
1
360

1
1
2

bi
bi
bi bi

0
0
9
32
7200
2197

8
2
0
0
0

0
0
0
7296
2197
3680
513
3544
2565
1408
2565
6656
12825
128
4275

0
0
0
0
845
4104

1859
4104
2197
4104
28561
56430
2197
75240

0
0
0
0
0
11
40
15
9
50
1
50

0
0
0
0
0
0
0
2
55
2
55

Este metodo utiliza un metodo de cuarto orden de 5 etapas y un metodo de quinto orden de 6 etapas.
Se proporcionan los coeficientes en formato Matlab en:
http://personales.unican.es/segurajj/coefs.txt

Implementaci
on del m
etodo
Comenzaremos por repetir la primera parte de la practica para los metodos de Runge-Kutta de orden 4 y
5 descritos anteriormente, comprobando el orden de convergencia. Para ello, modificaremos ligeramente
las rutinas etapas, y paso.

1. etapas45: igual que etapas.m pero con los coeficientes A correspondientes al metodo de RungeKutta Fehlberg. La sintaxis sera la misma, salvo porque, para aplicar facilmente las rutinas a varias
funciones, anadiremos una primera entrada para especificar la funcion f (t, y) correspondiente. La
sintaxis sera entonces:
function k=etapas45(fun,t,yn,h)
Siendo fun una cadena alfanumerica. Por ejemplo, fun=fsis, si queremos considerar la f (t, y)
definida en el fichero fsis.m.
Otra diferencia respecto a etapas.m, sera en la propia evaluacion de las etapas para la que se
utilizara el comando feval. Recordemos que, por ejemplo, feval(fun,1,[3 -1]) para fun=fsis
equivale a escribir fsis(1,[3 -1]). Para mas detalles, consultar el help.
2. paso45: igual que paso.m pero incluyendo los coeficientes b para los Runge-Kutta encajados.
Las salidas de la rutina seran el nuevo valor dado por el metodo de orden 5 as como la estimacion
del error (ec. (5)):
function [yout,err]=paso45(fun,tn,yn,h)
%------------------------------------------------------------%Sintaxis: [yout,err]=paso45(fun,tn,yn,h)
%-------------------------------------------------------------%funcion que calcula un paso para el metodo de RK-F del que
%se proporcionan los vectores b y los valores de las etapas k_i
%Inputs:
%
fun: cadena alfanumerica con el nombre del fichero que
%
contiene la funcion f(t,y)
%
tn: instante temporal
%
yn: vector solucion en el instante tn (vector columna n x 1)
%
h: paso
%Outputs:
% yout: vector solucion en el instante temporal tn+h utilizando
%
el RK de orden 5
%
err: estimacion del error de truncamiento local para el RK-F
%---------------------------------------------------------------%Dentro de la rutina se han de proporcionar las matrices b (para
%orden (4) y bg (para orden 5))
%---------------------------------------------------------------%Esta rutina llama a la funcion etapas45(tn,yn,h)
%---------------------------------------------------------------b=[25/216 0 1408/2565 2197/4104 -1/5 0];
bg=[16/135 0 6656/12825 28561/56430 -9/50 2/55];
3. RK45, igual que RK.m pero para el Runge-Kutta Fehlberg. El vector de salida sera la solucion
numerica para el metodo de orden 5. Sintaxis:
[t,y,error]=RK45(fun,t0,tf,y_0,N)
donde la u
nica diferencia respecto a RK.m es la aparicion del primer input, antes descrito.
4. orden45.m: para comprobar que el orden obtenido con RK45 es, efectivamente, 5.

Una vez verificado el correcto funcionamiento de RK45, utilizaremos las funciones etapas45 y
paso45 para construir el metodo adaptativo de Runge-Kutta Fehlberg, que implementa el diagrama de
flujo de la Figura 1. La sintaxis sera la siguiente:
function [t,y,errlt]=fehlb(fun,t0,tf,y_0,eps)
%-------------------------------------------------------------------%Sintaxis: [t,y,errlt]=fehlb(fun,t0,tf,y_0,eps)
%-------------------------------------------------------------------%funcion que implementa el metodo de Runge-Kutta Fehlberg adaptativo
%Inputs:
% fun: cadena alfanumerica para el nombre del fichero conteniendo la
%
funcion f(t,y)
% tn: instante inicial
% tf: instante final
% y_0: vector columna de condiciones iniciales
% eps: tolerancia de error para el error local de truncamiento
%Outputs:
%
t: vector conteniendo los instantes temporales
%
y: valores numericos proporcionados para los instantes t; es una
%
matriz n x N (n: numero de ecuaciones; N: longitud del vector t)
% err: estimacion del error de truncamiento local para cada instante
%--------------------------------------------------------------------%Dentro de la rutina se han de proporcionar las matrices b (para orden
%4) y bg (para orden 5))
%--------------------------------------------------------------------%Esta rutina llama a la funcion paso45(fun,tn,yn,h)
%--------------------------------------------------------------------Para la construccion del la rutina fehlb.m se puede tomar cualquier paso inicial (menor que la
longitud del intervalo) puesto que la rutina adaptara el h hasta que resulte conveniente para la precision
exigida. Por ejemplo, tomaremos h = (tf t0)/10.
Ademas de las rutinas etapas45, paso45, RK45 y fehlb, construiremos tres funciones que contengan distintas f (t, y):
1. fsis: que hemos dados explcitamente en la primera pagina de este guion.
2. fpen: que implementa la f (t, y) para el pendulo simple (tomemos g = 9.8ms 2 , L = 1m).
3. fbru: que implementa la f (t, y) para el sistema conocido como Brusselator:
y10 = 1 + y12 y2 4y1
y20 = 3y1 y12 y2

(6)

sistema para el que, a diferencia de los otros sistemas estudiados, no tenemos solucion analtica,
ni siquiera en terminos de funciones especiales como ocurre con el pendulo simple.
Ademas, para poder comparar en el caso del pendulo, construiremos la rutina analitica.m, que
proporciona la solucion analtica del pendulo simple considerada en la anterior practica. La sintaxis
sera:
function theta=analitica(t,cond_in);

Esta rutina se proporciona en

http://personales.unican.es/segurajj/analitica.txt
A continuacion, describiremos las actividades a realizar con los programas desarrollados en la segunda parte de esta practica. Esta actividades deberan ser ejecutadas por un programa Matlab al que
llamaremos adaptativo.m.

2.1

Listado de programas

En resumen, los programas necesarios para realizar esta parte de la practica son:
1. orden45.m
2. RK45.m
3. etapas45.m
4. paso45.m
5. adaptativo.m
6. fehlb.m
7. fsis.m (programa ya utilizado en la primera parte)
8. fpen.m
9. fbrus.m
10. analitica.m (programa que se proporciona en la pagina web).

2.2
2.2.1

Actividades a realizar (adaptativo.m)

Primer problema

Resolveremos el problema de valores iniciales de le Ec. (3) para t [0, 10]. Dibujaremos cuatro graficas
(que se recomienda que aparezcan en la misma ventana grafica utilizando subplot):
1. Aplicaremos el metodo adaptativo para una tolerancia de error absoluto  = 10 10 . Dibujaremos
en una misma grafica la solucion y el paso h como funcion del tiempo. Como los pasos seran
peque
nos, se recomienda multiplicarlos por un factor para que sean visibles en la grafica (un
factor 20 debe bastar).
2. Dibujaremos el error absoluto cometido para la primera componente del vector solucion, comparando con la solucion exacta y1 (t) = sin t.
3. Considerando el mismo n
umero de puntos que resultan en el metodo adaptativo pero escogiendo
un paso constante, resolveremos el mismo problema mediante RK45 y dibujaremos la solucion.
4. Representar el error para la primera componente obtenida mediante RK45 comparando con la
solucion exacta.
Tiene en este caso alguna ventaja el metodo adaptativo RK-Fehlberg?, Por que?.

2.2.2

Segundo problema (p
endulo: primera parte)

Resolveremos el problema del pendulo simple comparandolo con la solucion analtica. Las condiciones
iniciales seran: angulo inicial /2 y velocidad angular inicial nula. Consideraremos el intervalo t [0, 10]
y una tolerancia para el error absoluto  = 10 10 .
Repetimos las representaciones graficas consideradas para el primer problema. La solucion analtica
en este caso se obtiene mediante analitica.m. Los pasos h convendra escalarlos por un factor 100
para que aperezcan claramente en la grafica.
Ademas, en otra ventana grafica proporcionaremos dos graficas con las estimaciones de los errores
de truncamiento locales para los dos metodos (fehlb y RK45)
2.2.3

Tercer problema (p
endulo: segunda parte)

Repetimos las graficas del segundo problema pero tomamos como condiciones iniciales: angulo inicial
0.999999, velocidad angular inicial 0. Consideraremos el intervalo t [0, 20] y una tolerancia para el
error absoluto  = 1014 . Al igual que antes, utilizaremos un factor 100 para los pasos h.
Que diferencias se observan respecto a los anteriores valores iniciales?.
2.2.4

Cuarto problema: el Brusselator

Consideraremos el problema del Brusselator con condiciones iniciales y 1 (0) = 1.5, y2 (0) = 3.1 en el
intervalo t [0, 30]. Como tolerancia de error absoluto tomaremos  = 10 10 . Dibujaremos dos graficas
en una misma ventana grafica:
1. Grafica con las soluciones y1 , y2 y los pasos h en funcion de t (se recomienda multiplicar los pasos
por 50 para que sean visibles en la grafica).
2. Grafica con la estimacion del error local de truncamiento.
Discutir brevemente los resultados.