PRCTICA 6 : MTODOS

NUMRICOS DE RESOLUCIN
DE ECUACIONES
DIFERENCIALES ORDINARIAS
En esta prctica vamos a hallar la solucin numrica de ecuaciones diferenciales con
condiciones iniciales dadas, puesto que es muy limitado el nmero de tipos de ecuaciones
diferenciales integrables de forma analtica. Por ello, es necesario habilitar nuevos recursos
para obtener la solucin de una ecuacin diferencial que cumpla las condiciones iniciales
prefijadas. En la primera parte de la prctica utilizaremos funciones propias de Mathematica
y en la segunda parte programaremos los algoritmos correspondientes a los mtodos de
Picard, Euler y Runge-kutta.
1. Resolucin numrica de ecuaciones diferenciales de primer orden con funciones propias
de Mathematica.
2. Recursos de programacin en Mathematica.
3. Mtodo de Picard o de las aproximaciones sucesivas.
4. Mtodo de Euler.
5. Ejercicios.
6. Mtodos de Runge Kutta de diversos rdenes.
7. Aplicaciones.
8. Ejercicios.

1. Funciones propias de Mathematica

El comando NDSolve[{ec,cond},y,{x,xmin,xmax}] encuentra la solucin numrica
de una ecuacin diferencial ordinaria. Aqu la variable independiente es x y su rango es el
intervalo de extremos xmin y xmax. Escribiremos la ecuacin y la condicn inicial entre
llaves y separadas por una coma. La sintaxis es similar a la del comando DSolve con algunas
diferencias. En DSolve no tenamos que establecer el rango de x.

Ejemplo 1.

Pr6MatII.nb

Resuelve la ecuacin y' = 30 - 5 y, y (0) = 1.

HUtilizando el comando DSolveL
DSolve@8y '@xD  30 5 y@xD, y@0D  1<, y@xD, xD
99y@xD 5 x I5 + 6 5 x M==
HUtilizando el comando NDSolveL
NDSolve@8y '@xD  30 5 y@xD, y@0D  1<, y@xD, 8 x, 0, 1<D
88y@xD InterpolatingFunction @880., 1.<<, <>D@xD<<
Plot@y@xD . %, 8x, 0, 1<D
6

0.2

0.4

0.6

0.8

1.0

InterpolatingFunction es una funcin aproximada que interpola los datos.

NDSolve tiene muchos mtodos para resolver ecuaciones, y determina el nmero de pasos
segn sea la ecuacin. En general, si la solucin parece estar variando rpidamente en una
regin en particular, entonces NDSolve reducir el tamao del paso o cambiar el mtodo
con el fin de obtener la mejor solucin. Tambin se puede especificar el mtodo y los pasos
que queremos que utilice. Para ello, tenemos que cargar los paquetes DifferentialEquations`NDSolveProblems` y "DifferentialEquations`NDSolveUtilities`".

Pr6MatII.nb

Needs@"DifferentialEquations`NDSolveProblems`"D;
Needs@"DifferentialEquations`NDSolveUtilities`"D;
s = NDSolve@8y '@xD  y@xD, y@0D  1<, y@xD, 8x, 0, 1<,
Method "ExplicitEuler", "StartingStepSize" 1 10D;
Plot@y@xD . s, 8x, 0, 1<D
1.0
0.9
0.8
0.7
0.6
0.5

0.2

0.4

0.6

0.8

1.0

El comando NDSolve tiene las siguientes opciones en la versin 6.0 de Mathematica :

Options@NDSolveD

:AccuracyGoal Automatic, Compiled Automatic,

DependentVariables Automatic, EvaluationMonitor None,
1
InterpolationOrder Automatic, MaxStepFraction
,
10
MaxSteps 10 000, MaxStepSize Automatic,
Method Automatic, NormFunction Automatic,
PrecisionGoal Automatic, SolveDelayed False,
StartingStepSize Automatic, StepMonitor None,
WorkingPrecision MachinePrecision>

Veamos algunos de ellos :

AccuracyGoal->n
Indica el nmero de dgitos de precisin con los que el programa calcula las soluciones, de
manera que: |y(x)- ya HxL 10-n , x[xmin,xmax] donde ya HxL es el valor de la aproximacin a
la solucin en el punto x e y(x) es la solucin exacta en ese mismo punto. El valor por
defecto es Automatic, que corresponde al valor de precisin del equipo menos 10 dgitos.
PrecisionGoal->n
Indica el nmero de dgitos de precisin con los que se determina el error relativo que se
tiene en la realizacin del clculo, de modo que:
yHxL-ya HxL
10-n,
yHxL

x[xmin,xmax] donde ya HxL es el valor de la aproximacin a la solucin en

el punto x e y(x) es la solucin exacta en ese mismo punto. El valor por defecto es Automatic.
WorkingPrecision->n

Pr6MatII.nb

Indica el nmero de dgitos con los que se realizan los clculos internos. Por defecto
asume el valor de la variable del sistema $MachinePrecision. De todas formas, el valor
elegido para esta opcin deber ser siempre superior al de las opciones anteriores para no
desvirtuar el resultado obtenido.
MaxSteps->n
Es el nmero mximo de subintervalos del dominio considerado que se han de utilizar.
El valor por defecto de esta opcin es 1000. Con ello podemos cambiar el nmero de puntos
que determinan la funcin de interpolacin que el comando NDSolve[...] proporciona como
resultado.

Ejemplo 2.
Resuelve la ecuacin y'' (x) + sen (x) = y' (x) con las condiciones iniciales y (0) = 0, y' (0) =
1.
NDSolve@8y ''@xD + Sin@xD == y '@xD, y@0D  0, y '@0D  1<,
y, 8x, 5, 5<, WorkingPrecision 25D
88y InterpolatingFunction@885.000000000000000000000000,
5.000000000000000000000000<<, <>D<<
Plot@y@xD . %, 8x, 5, 5<D
30
25
20
15
10
5

-4

-2

Pr6MatII.nb

2. Recursos de programacin en Mathematica.

En esta seccin vamos a tratar algunos aspectos del estilo de programacin procedimental. En concreto, consideraremos las estructuras condicionales ("If[]") y las recursivas y
bucles ("Do[]", "For[]").
Cada vez que declaramos una variable o una funcin Mathematica la guarda en algn
contexto. Por defecto el contexto en el que se guardan todas las variables y funciones definidas por el usuario es el contexto Global. Esto es as para que dichas variables y funciones
puedan ser usadas en cualquier celda en cualquier momento.
var = 30
? var

Mathematica nos dice que var es una variable almacenada en el contexto Global
cuyo valor actual es 30. Muchas veces es conveniente usar alguna variable o alguna funcin
para realizar una tarea muy especfica y no nos interesa que dicha variable o funcin pueda
ser accesible desde otras instancias del programa. Para ello Mathematica dispone del
comando Module[{x,y,... <,expr]que especifica que los smbolos x, y,... en
expr deben ser tratados como variables locales.
Module@8var<, var = 0; varDH Mathematica nos da el valor de la variable local "var" L
var H "var" sigue siendo una variable global y su valor no ha cambiado L

Por ejemplo:
Clear@aD; Clear@bD; t = 5;
H declaramos "t" como variable global con valor inicial 5 L
f@x_D := Module@8t<, t = H1 + xL ^ 2; Expand@tDDH declaramos "t"como una variable local L
f@a + bD
1 + 2 a + a2 + 2 b + 2 a b + b 2

Podemos comprobar el valor de la variable t en Global con:

?t

If
El uso ms frecuente del comando "If[]" es con tres argumentos.
If[test,expr1,expr2]
El primer argumento debe ser una expresin boleana. Si test=True, expr1 es
ejecutada, mientras que si test=False, expr2 es ejecutada. Las expresiones expr1 y
expr2 pueden estar formadas por varias instrucciones separadas por punto y coma.
Por ejemplo, podemos usar "If[]" para definir una funcin que devuelva 1 si su
argumento es positivo y devuelva -1 si es negativo.

Pr6MatII.nb

Clear@fD
f@x_D := If@x > 0, 1, 1D
H observa que es obligado el uso de :=
si no lo usamos Mathematica tratara
de evaluar inmediatamente la condicin x>
0 lo que dara un error. L
f@.2D
f@.01D

Podemos modificar la funcin para que devuelva 0 si su argumento es igual a 0. Para

ello podemos anidar dos "If[]" como sigue:
Clear[f]
f[x_]:= If[x>0,1,If[x==0,0,-1]]
Si el argumento es mayor que 0, "f[]" devuelve un 1; si no, si es igual a cero,
devuelve un 0; en otro caso devuelve un -1.
Tambin se puede usar If con dos argumentos. (*If[condition,t]*)
Clear@tD; t = 2; If@t  2, "true"D
true

For
El comando For se usa para realizar bucles. Un bucle es un proceso repetitivo que
se realiza un cierto nmero de veces. La sintaxis de la orden es:
For[expresininicial,test,incr,expr]
expresininicial nos sita en las condiciones de comienzo del bucle.
test dir a Mathematica el momento de detener el proceso.
incr expresar la forma de modificar la condicin inicial.
expr dir a Mathematica lo que tiene que realizar en cada paso; la expresin puede estar
compuesta de varias instrucciones separadas mediante punto y coma.
El orden de evaluacin es testexprincr.El proceso termina cuando test da
False. Un aspecto importante de For es que su resultado es Null es decir, que no proporciona resultado en pantalla salvo que se lo indiquemos de alguna forma explcita. Vamos a
ver algunos ejemplos del funcionamiento de este comando. Ejecuta la siguiente celda.
Clear@iD
For@i = 1, i 100, i ++, i = i ^ 3D

Aparentemente no ha pasado nada pero eso no es as. Comprueba el valor actual de i

(trata de averiguarlo antes de preguntrselo a Mathematica).

Pr6MatII.nb

i
9^3
730
729

Para saber con total claridad todas las operaciones que ha realizado Mathematica
para ejecutar un comando podemos usar la orden Trace.
Trace@For@i = 1, i 100, i ++, i = i ^ 3DD
9ForAi = 1, i < 100, i ++, i = i3E, 8i = 1, 1<,
88i, 1<, 1 < 100, True<, 998i, 1<, 13 , 1=, i = 1, 1=,
8i ++, 8i, 1<, 8i = 2, 2<, 1<, 88i, 2<, 2 < 100, True<,
998i, 2<, 23 , 8=, i = 8, 8=, 8i ++, 8i, 8<, 8i = 9, 9<, 8<,
88i, 9<, 9 < 100, True<, 998i, 9<, 93 , 729=, i = 729, 729=,
8i ++, 8i, 729<, 8i = 730, 730<, 729<,
88i, 730<, 730 < 100, False<, Null=

El valor final de i es 730 ya que 9^3+1=730. Para que For proporcione una salida en
pantalla se usa el comando Print[expr].
For@i = 1, i 500, i ++, i = i ^ 2; Print@iDD
H observa cmo las dos instrucciones
al final van separadas por ";" no por "," L

El ltimo valor de i que Mathematica ha impreso en pantalla es 729 = H8 + 1L3

porque ese fue el ltimo valor calculado de i^3. Sin embargo el valor actual de i es 730
porque se ha incrementado el valor en una unidad al ejecutar la orden i++.
Break
Este comando, cuya sintaxis es simplemente Break[], tiene como nica finalidad
interrumpir la ejecucin de un bucle. Esto puede ser interesante si, por ejemplo, creemos que
el resultado que buscamos puede alcanzarse antes de que el test del bucle sea False.

Pr6MatII.nb

ForAi = 1, i 100, i ++,

IfA1. + 10i  1.,
PrintA"El exponente i con el que se
logra la igualdad 1.+ 10i 1. es i=", iE;
Break@D, H para interrumpir la ejecucin del
bucle cuando se d la igualdad L
PrintA"Para ", 10.i , " no se da la igualdad porque ",
NA1. + 10i , 14E, " es distinto de ", 1.E
E

Para 0.1 no se da la igualdad porque 1.1 es distinto de 1.

Para 0.01 no se da la igualdad porque 1.01 es distinto de 1.
Para 0.001 no se da la igualdad porque 1.001 es distinto de 1.
Para 0.0001 no se da la igualdad porque
1.0001 es distinto de 1.
Para 0.00001 no se da la igualdad porque
1.00001 es distinto de 1.
Para 1. 106 no se da la igualdad porque 1. es distinto de 1.
Para 1. 107 no se da la igualdad porque 1. es distinto de 1.
Para 1. 108 no se da la igualdad porque 1. es distinto de 1.
Para 1. 109 no se da la igualdad porque 1. es distinto de 1.
Para 1. 1010 no se da la igualdad porque 1. es distinto de 1.
Para 1. 1011 no se da la igualdad porque 1. es distinto de 1.
Para 1. 1012 no se da la igualdad porque 1. es distinto de 1.
Para 1. 1013 no se da la igualdad porque 1. es distinto de 1.
El exponente i con el que
se logra la igualdad 1.+ 10i 1. es i=14

Pr6MatII.nb

Do

Se trata de un comando que permite hacer repetidamente una operacin. Su sintaxis

es:
Do[expr,{iter}]
donde expr es una o varias instrucciones separadas por punto y coma y {iter} puede ser
de varias formas:
{iter}={nmero} Repite las operaciones tantas veces como indica "nmero".
{iter}={i,nmero} Repite las operaciones indicadas desde i=1 hasta i=nmero
incrementando i de uno en uno.
{iter}={i,nmero1,numero2} Repite las operaciones indicadas desde i=numero1
hasta i=nmero2 incrementando i de uno en uno.
{iter}={i,nmero1,numero2,incr} Repite las operaciones indicadas desde
i=numero1 hasta i=nmero2 incrementando i de incr en incr.
Veamos un ejemplo del uso de Do:
Module[ {prod,i},
prod = 3;
Do[prod =i*prod*(prod-2);Print[prod], {i,1,10,2}];
prod
]
3
9
315
690 165
4 286 937 122 055
4 286 937 122 055

En la creacin de los algoritmos son tiles los comandos Table y Array. El comando
Table[{expr1, expr2}, {i, imin, imax}] genera una lista de valores de las expresiones para los
valores naturales de i entre imin e imax como ya hemos visto en prcticas anteriores.
Array[f, n] genera un vector de longitud n con los valores de f, por ejemplo :
Array@f, 10D
Array@f, 10, 0D
Hel 0 se pone para que comience desde el valor f@0DL
8f@1D, f@2D, f@3D, f@4D, f@5D, f@6D, f@7D, f@8D, f@9D, f@10D<
8f@0D, f@1D, f@2D, f@3D, f@4D, f@5D, f@6D, f@7D, f@8D, f@9D<

10

Pr6MatII.nb

3. Mtodo de Picard o de las aproximaciones sucesivas.

Partimos de un problema de valores iniciales como y'=f(x,y), y(x0 )=y0 , donde f es una
funcin definida y continua en un entorno del punto (x0,y0 ) y lo sustituimos por una
ecuacin integral equivalente
x

y HxL = y Hx0L + f Ht, y HtLL dt

x0

As, obtendremos una solucin del problema de valores iniciales si conseguimos una
solucin continua de la ecuacin integral. Esta expresin nos proporciona la clave para que,
a partir de una primera aproximacin de la funcin yHxL y0 HxL = y0 , podamos definir una
sucesin de funciones 8yn HxL< de forma iterativa del siguiente modo:
x

y1 HxL = y Hx0L + f Ht, y0 HtLL dt

x0

y2 HxL = y Hx0L + f Ht, y1 HtLL dt

x0

...
x

yn HxL = y Hx0L + f Ht, yn-1 HtLL dt

x0

Si la sucesin converge entonces esperamos aproximarnos a la solucin exacta un

poco ms en cada una de las iteraciones.
Ejemplo 3. Calcula el valor de y con el mtodo de aproximaciones sucesivas de Picard para
el problema de condicin inicial y'=y, y(0)=1 para n=5.

Pr6MatII.nb

11

x0 = 0; y0 = 1; n = 5; f@x_, y_D := y;
ye1@x_D := Module@8u<, u = y0 + Integrate@f@t, 1D, 8t, x0, x<DD;
ye2@x_D :=
Module@8u<, u = y0 + Integrate@f@t, ye1@tDD, 8t, x0, x<DD;
ye3@x_D := Module@8u<,
u = y0 + Integrate@f@t, ye2@tDD, 8t, x0, x<DD;
ye4@x_D := Module@8u<,
u = y0 + Integrate@f@t, ye3@tDD, 8t, x0, x<DD;
ye5@x_D := Module@8u<,
u = y0 + Integrate@f@t, ye4@tDD, 8t, x0, x<DD;
Print@ye5@xDD

2
3
4
5
x
x
x
x
1 + x + -- + -- + -- + ---2
6
24
120

4. Mtodo de Euler.
El mtodo de Euler es el ms simple de los mtodos numricos de resolucin de
ecuaciones diferenciales pero tiene la desventaja de que el error que se comete al aplicarlo
crece considerablemente con el nmero de iteraciones. Partimos de un problema de valores
iniciales de la forma:
y ' = f Hx, yL, y Hx0 L = y0

Supongamos que este problema tiene solucin nica y(x). Buscamos una aproximacin de los valores de la funcin y(x) para una serie de valores de x separados por una
distancia h. Para ello, elegimos un intervalo [a, b] con x0 =a. Dividimos el intervalo [a, b] en
subintervalos iguales, tomando xi = xi-1 + h, i = 1, 2, ..., n. Entonces h= b-a
. El mtodo de
n
Euler consiste en utilizar el desarrollo en serie de Taylor de la solucin quedndonos en el
primer orden de h, es decir:
y1 = y Hx0 + hL y Hx0 L + hy ' Hx0 L = y Hx0 L + hf Hx0 , y0 L

de y2 .

Anlogamente, repitiendo el proceso para: y'=f(x,y), y(x1 L = y1 , conseguimos el valor

y2 = y Hx1 + hL y Hx1 L + hy ' Hx1 L = y Hx0 L + hf Hx1 , y1 L

12

Pr6MatII.nb

En general,
yi+1 = yi + hf Hxi , yi L, y Hx0 L = y0 , i = 1, 2, ...

De esta forma, obtenemos puntos Hxi , yi L, i = 0, 1, 2, ... n, y as

podemos confeccionar la grfica de una funcin que contenga a esos puntos.
Ejemplo 4. Dado el problema de valor inicial y'=y-x, y(0)=1,5, calcula, mediante el
mtodo de Euler, una aproximacin de y(1,5), tomando h=0,25.
x0 = 0; y0 = 1.5; h = 0.25; b = 1.5; n = Hb x0L h;
For@i = 0, i n, i ++, y1 = y0 + h Hy0 x0L;
Print@"Valores en la iteracin i=", iD;
Print@"x= ", x0D; Print@"y= ", y0D; y0 = y1; x0 = x0 + hD
Valores en la iteracin i=0
x= 0
y= 1.5
Valores en la iteracin i=1
x= 0.25
y= 1.875
Valores en la iteracin i=2
x= 0.5
y= 2.28125
Valores en la iteracin i=3
x= 0.75
y= 2.72656
Valores en la iteracin i=4
x= 1.
y= 3.2207
Valores en la iteracin i=5
x= 1.25
y= 3.77588
Valores en la iteracin i=6
x= 1.5
y= 4.40735

Si queremos que la salida sea un conjunto de puntos entonces podemos utilizar los

Pr6MatII.nb

13

comandos Table y Array.

a = 0; b = 1.5; h = 0.25; n = Hb aL h; f@x_, y_D := y x;
Array@x, n + 1, 0D; Array@ye, n + 1, 0D;
Do@x@iD = a + i h, 8i, 0, n<D; ye@0D = 1.5;
For@i = 0, i n, i ++, ye@i + 1D = ye@iD + h f@x@iD, ye@iDDD;
le = Table@8x@iD, ye@iD<, 8i, 0, n<D
880, 1.5<, 80.25, 1.875<, 80.5, 2.28125<, 80.75, 2.72656<,
81., 3.2207<, 81.25, 3.77588<, 81.5, 4.40735<<
HAhora representaremos los
puntos unidos con una lnea poligonalL
p1 = ListPlot@le, PlotStyle AbsolutePointSize@9DD;
p2 = ListPlot@le, PlotJoined TrueD; Show@p1, p2D
4.0
3.5
3.0
2.5
2.0

0.2

0.4

0.6

0.8

1.0

1.2

1.4

A continuacin vamos a resolver la ecuacin diferencial y'=y-x, y(0)=1,5 mediante el

comando DSolve y compararemos la solucin que nos d con la que hemos obtenido del
mtodo de Euler.
DSolve@8y '@xD  y@xD x, y@0D == 1.5<, y@xD, xD
88y@xD 1. + 0.5 x + x<<

14

Pr6MatII.nb

p3 = Plot@1 + 0.5 Exp@xD + x, 8x, 0, 1.5<, PlotRange 80, 5<D;

Show@p3, p1DHShow toma el rango de y definido para p3L
5

0.0

0.2

0.4

0.6

0.8

1.0

1.2

1.4

5. Ejercicios
1. Resuelve de forma aproximada el problema de valor inicial y' = 25 - 8y, y (0) = 4.
2. Resuelve el problema de valor inicial xy+y'=ax y2, y(0)=1, de forma aproximada y dibuja
la solucin en el rango -1<x<1, variando el parmetro a desde -2 a 2, de 0,25 en 0,25.
3. Dado el problema de valor inicial y'=3xy, y(1)=1. Calcula la solucin analtica. Halla el
valor aproximado de y(1,5) mediante el mtodo de Euler y compara los resultados para los
pasos
h= 0,1 h = 0,01 con la solucin analtica del problema planteado.
4. Dado el problema de valor inicial y' = Hx - 2 y - 1L2 ,
y H0L = 2, halla el valor aproximado de la solucin en x = 0,
5 utiliando el mtodo de Euler con los pasos h = 0, 1 y h = 0,
01. Compara el valor aproximado con el valor real de la
solucin analtica indicando el error cometido en cada iteracin.
5. Resuelve numricamente el problema del valor inicial y' - y = y2 , y H0L = 1,
con 5 iteraciones de Picard.

6. Mtodos de Runge Kutta de diversos rdenes.

Los mtodos de Runge-kutta tienen la exactitud del esquema de la serie de Taylor sin
necesitar del clculo de derivadas superiores. Existen muchas variaciones pero todas ellas se
pueden ajustar a la forma general de la ecuacin:
yi+1 = yi + Hxi , yi , hL h

donde Hxi , yi , hL se le llama funcin de incremento y puede interprestarse como el

Pr6MatII.nb

15

promedio de la pendiente sobre el intervalo. La funcin de incremento se puede escribir en la

forma general como:
= a1 k1 + a2 k2 + + an kn

donde las a son constantes y las k son:

k1 = f Hxi , yi L
k2 = f Hxi + p1 h, yi + q11 k1 hL
k3 = f Hxi + p2 h, yi + q21 k1 h + q22 k2 hL

kn = f Hxi + pn1 h, yi + qn1,1 k1 h + qn1,2 k2 h + + qn1,n2 kn1 hL

Para n=1 el mtodo de Runge-Kutta coincide con el mtodo de Euler.

Mtodo de Runge - Kutta de rden 2

La versin de segundo orden nos queda :

yi+1 = yi + Ha1 k1 + a2 k2 L h, k1 = f Hxi , yi L, k2 = f Hxi + p1 h, yi + q11 k1 hL
Los valores de a1, a2 ,
p1 y q11 se evalan igualando la ecuacin yi+1 = yi + Ha1 k1 + a2 k2 L h al desarrollo
de la serie de Taylor hasta el segundo trmino. Haciendo esto,
se obtienen tres ecuaciones para evaluar las cuatro incgnitas
constantes. Estas tres ecuaciones son :
a1 + a2 = 1; a2 p1 =

1
1
; a2 q11 =
2
2

Como tenemos tres ecuaciones con cuatro incgnitas existe un nmero infinito de
mtodos de RK de segundo orden. Las siguientes versiones son las que ms se usan :
1
* Mtodo de Heun con un corrector simple : a2 = .
2
* El Mtodo mejorado del polgono : a2 = 1.
2
* El Mtodo de Ralston : a2 = .
3

Ejemplo. Resuelve numricamente con el mtodo de Euler y de Heun el problema de

condicin inicial y'=-2x3 + 12 x2 - 20 x + 8.5, y(0)=1.
para un tamao del paso de 0,5. Compara las soluciones con la solucin exacta.

16

Pr6MatII.nb

HSolucin verdadera LDSolve@8y '@xD  2 x ^ 3 + 12 x ^ 2 20 x + 8.5, y@0D  1<, y@xD, xD

99y@xD 1 + 8.5 x 10. x2 + 4. x3 0.5 x4 ==
yv@x_D := 1 + 85 10 x 10 x ^ 2 + 4 x ^ 3 1 2 x ^ 4

Mtodo de Heun con un corrector simple : a2 =

a1 =

1
2

yi+1 = yi +

1
2

, p1 = 1, q11 = 1. Las ecuaciones quedan :

1
2

k1 +

1
2

k2 h, k1 = f Hxi , yi L, k2 = f Hxi + h, yi + k1 hL

x0 = 0; y0 = 1;
f@x_, y_D := 2 x ^ 3 + 12 x ^ 2 20 x + 8.5;
h = 0.5;
k10 = f@x0, y0D;
k20 = f@x0 + h, y0 + k10 hD; x1 = x0 + h; y1 = y0 + 1 2 k10 h + 1 2 k20 h;
y1v = yv@x1D; Print@x1D; Print@y1D; Print@y1vD
0.5
3.4375
3.21875
HEl error relativo porcentual LAbs@Hy1 y1v L y1vD 100
6.79612

k11 = f@x1, y1D;

k21 = f@x1 + h, y1 + k11 hD; x2 = x1 + h; y2 = y1 + 1 2 k11 h + 1 2 k21 h;
y2v = yv@x2D; Print@x2D; Print@y2D; Print@y2vD
1.
3.375
3.
HEl error relativo porcentual LAbs@Hy2 y2v L y2vD 100
12.5
HEl error relativo porcentual LAbs@Hy1 y1v L y1vD 100
6.79612

Programacin de los mtodos con 8 iteraciones

HMtodo de EulerL
Clear@"@"D; a = 0; b = 4; h = 0.5; n = Hb aL h; f@x_, y_D := 2 x ^ 3 + 12 x ^ 2 20 x + 8.5;
Array@x, n + 1, 0D; Array@ye, n + 1, 0D; Do@x@iD = a + i h, 8i, 0, n<D;
ye@0D = 1; For@i = 0, i n, i ++, ye@i + 1D = ye@iD + h f@x@iD, ye@iDDD;
le = Table@8x@iD, ye@iD<, 8i, 0, n<D
880, 1<, 80.5, 5.25<, 81., 5.875<, 81.5, 5.125<,
82., 4.5<, 82.5, 4.75<, 83., 5.875<, 83.5, 7.125<, 84., 7.<<

Pr6MatII.nb

HMtodo de HeunL
a = 0; b = 4; h = 0.5; n = Hb aL h; f@x_, y_D := 2 x ^ 3 + 12 x ^ 2 20 x + 8.5;
Array@x, n + 1, 0D; Array@yhe, n + 1, 0D; Array@k1, n, 0D;
Array@k2, n, 0D; Do@x@iD = a + i h, 8i, 0, n<D; yhe@0D = 1;
For@i = 0, i n, i ++, k1@iD = f@x@iD, yhe@iDD; k2@iD = f@x@iD + h, yhe@iD + k1@iD hD;
Print@"i=", iD; Print@"El valor de k1 es ", k1@iDD; Print@"El valor de k2 es ", k2@iDD;
yhe@i + 1D = yhe@iD + 1 2 k1@iD h + 1 2 k2@iD hD; lhe = Table@8x@iD, yhe@iD<, 8i, 0, n<D
i=0
El valor de k1 es 8.5
El valor de k2 es 1.25
i=1
El valor de k1 es 1.25
El valor de k2 es 1.5
i=2
El valor de k1 es 1.5
El valor de k2 es 1.25
i=3
El valor de k1 es 1.25
El valor de k2 es 0.5
i=4
El valor de k1 es 0.5
El valor de k2 es 2.25
i=5
El valor de k1 es 2.25
El valor de k2 es 2.5
i=6
El valor de k1 es 2.5
El valor de k2 es 0.25
i=7
El valor de k1 es 0.25
El valor de k2 es 7.5
880, 1<, 80.5, 3.4375<, 81., 3.375<, 81.5, 2.6875<,
82., 2.5<, 82.5, 3.1875<, 83., 4.375<, 83.5, 4.9375<, 84., 3.<<

17

18

Pr6MatII.nb

HAhora representaremos los puntos unidos

con una lnea poligonal y la solucin exactaL
p1 = ListPlot@le, PlotStyle AbsolutePointSize @9D, GridLines AutomaticD;
p2 = ListPlot@le, PlotJoined True, PlotStyle Green, GridLines AutomaticD;
p3 = ListPlot@lhe, PlotStyle AbsolutePointSize @9D, GridLines AutomaticD;
p4 = ListPlot@lhe, PlotJoined True, GridLines Automatic D;
yv@x_D := 1 + 85 10 x 10 x ^ 2 + 4 x ^ 3 1 2 x ^ 4;
p5 = Plot@yv@xD, 8x, 0, 4<, PlotStyle Orange, GridLines Automatic D;
Show@p1, p2, p3, p4, p5D
7
6
5
4
3
2

Mtodo de Runge - Kutta de rden 3

Se puede llevar a cabo una derivacin anloga a la del mtodo de segundo orden,
para n=3. El resultado de esta derivacin es de seis ecuaciones con ocho incgnitas. por lo
tanto, se deben especificar a priori los valores de dos de las incgnitas para determinar los
parmetros restantes. Una versin comn que resulta es:
1
Hk1 + 4 k2 + k3 L h, donde
6
1
1
k1 = f Hxi , yi L, k2 = f xi + h, yi + hk1 ,
2
2
k3 = f Hxi + h, yi hk1 + 2 hk2 L
yi+1 = yi +

Ejemplo. Resuelve numricamente con el mtodo de Runge Kutta de rden 3 el problema de condicin inicial y' =
-2 x3 + 12 x2 - 20 x + 8.5, y H0L = 1.
para un tamao del paso de 0, 5.
f@x_, y_D := 2 x ^ 3 + 12 x ^ 2 20 x + 8.5
h = 0.5; x0 = 0; y0 = 1; k10 = f@x0, y0D; k20 = f@x0 + 1 2 h, y0 + 1 2 h k10D;
k30 = f@x0 + h, y0 h k10 + 2 h k02D; yrkt1 = y0 + 1 6 Hk10 + 4 k20 + k30L h;
Print@"yrkt1= ", yrkt1D; Print@"k10= ", k10D; Print@"k20= ", k20D; Print@"k30= ", k30D;

Pr6MatII.nb

19

yrkt1= 3.21875
k10= 8.5
k20= 4.21875
k30= 1.25
HMtodo de RungeKutta de rden 3L
a = 0; b = 4; h = 0.5; n = Hb aL h; f@x_, y_D := 2 x ^ 3 + 12 x ^ 2 20 x + 8.5;
Array@x, n + 1, 0D; Array@yrkt, n + 1, 0D; Array@k1, n, 0D; Array@k2, n, 0D;
Array@k3, n, 0D; Do@x@iD = a + i h, 8i, 0, n<D; yrkt@0D = 1; For@i = 0, i n, i ++,
k1@iD = f@x@iD, yrkt@iDD; k2@iD = f@x@iD + 1 2 h, yrkt@iD + 1 2 k1@iD hD;
k3@iD = f@x@iD + h, yrkt@iD k1@iD h + 2 h k2@iDD;
yrkt@i + 1D = yrkt@iD + 1 6 Hk1@iD + 4 k2@iD + k3@iDL hD;
lrkt = Table@8x@iD, yrkt@iD<, 8i, 0, n<D
880, 1<, 80.5, 3.21875<, 81., 3.<, 81.5, 2.21875<,
82., 2.<, 82.5, 2.71875<, 83., 4.<, 83.5, 4.71875<, 84., 3.<<

Mtodo de Runge - Kutta de rden 4

Los mtodos RK ms populares son los de cuarto orden. Como sucede con los mtodos de segundo orden, existe un nmro infinito de versiones. El siguiente algunas veces se
llama mtodo clsico RK de cuarto orden:
1
Hk1 + 2 k2 + 2 k3 + k4 L h, donde
6
1
1
k1 = f Hxi , yi L, k2 = f xi + h, yi + hk1 ,
2
2
1
1
k3 = f xi + h, yi + hk2 , k4 = f Hxi + h, yi + hk3 L
2
2
yi+1 = yi +

Ejemplo. Resuelve numricamente con el mtodo de Runge Kutta de rden 3 el problema de condicin inicial y' =
-2 x3 + 12 x2 - 20 x + 8.5, y H0L = 1.
para un tamao del paso de 0, 5.
Clear@"@"D; f@x_, y_D := 2 x ^ 3 + 12 x ^ 2 20 x + 8.5
h = 0.5; x0 = 0; y0 = 1; k10 = f@x0, y0D; k20 = f@x0 + 1 2 h, y0 + 1 2 h k10D;
k30 = f@x0 + 1 2 h, y0 + 1 2 h k20D; k40 = f@x0 + h, y0 + h k30D;
yrkc1 = y0 + 1 6 Hk10 + 2 k20 + 2 k30 + k40L h; Print@yrkc1D;
Print@k10D; Print@k20D; Print@k30D; Print@k40D;
3.21875
8.5
4.21875
4.21875
1.25

20

Pr6MatII.nb

HMtodo de RungeKutta de rden 4L

Clear@a; b; f; h; yrkc; k3D; a = 0; b = 4; h = 0.5; n = Hb aL h;
f@x_, y_D := 2 x ^ 3 + 12 x ^ 2 20 x + 8.5; Array@x, n + 1, 0D; Array@yrkc, n + 1, 0D;
Array@k1, n, 0D; Array@k2, n, 0D; Array@k3, n, 0D; Array@k4, n, 0D;
Do@x@iD = a + i h, 8i, 0, n<D; yrkc@0D = 1; For@i = 0, i n, i ++,
k1@iD = f@x@iD, yrkc@iDD; k2@iD = f@x@iD + 1 2 h, yrkc@iD + 1 2 k1@iD hD;
k3@iD = f@x@iD + 1 2 h, yrkc@iD + 1 2 h k2@iDD;
k4@iD = f@x@iD + h, yrkc@iD + k3@iD hD;
yrkc@i + 1D = yrkc@iD + 1 6 Hk1@iD + 2 k2@iD + 2 k3@iD + k4@iDL hD;
lrkc = Table@8x@iD, yrkc@iD<, 8i, 0, n<D
880, 1<, 80.5, 3.21875<, 81., 3.<, 81.5, 2.21875<,
82., 2.<, 82.5, 2.71875<, 83., 4.<, 83.5, 4.71875<, 84., 3.<<

HAhora representaremos los puntos unidos

con una lnea poligonal y la solucin exactaL
s1 = ListPlot@lrkt, PlotStyle AbsolutePointSize @9D, GridLines Automatic D;
s2 = ListPlot@lrkt, PlotJoined True, PlotStyle Green, GridLines AutomaticD;
s3 = ListPlot@lrkc, PlotStyle AbsolutePointSize @9D, GridLines Automatic D;
s4 = ListPlot@lrkc, PlotJoined True, GridLines AutomaticD;
yv@x_D := 1 + 85 10 x 10 x ^ 2 + 4 x ^ 3 1 2 x ^ 4;
s5 = Plot@yv@xD, 8x, 0, 4<, PlotStyle Orange, GridLines AutomaticD;
Show@s1, s2, s3, s4, s5D
4.5
4.0
3.5
3.0
2.5
2.0
1.5

7. Aplicaciones
1. Un proyectil de masa m = 0,11 kg se lanza verticalmente hacia arriba con una velocidad
inicial de 8 m/s siendo frenado por la accin de la gravedad g y por la resistencia del aire k.
Se satisface la ecuacin diferencial : mv' = -mg - kv | v | donde g = 9, 8 m/s2 y k=0,002 kg/m.
Halla la velocidad, al cabo de 2 segundos, usando el mtodo de Rung-kutta con 20 subintervalos. Tomando un intervalo de tiempo mayor, comprueba que la velocidad decrece hasta
llegar a cierto lmite. Calcula dicho lmite. Representa el campo de direcciones y las soluciones obtenidas en cada caso.

Pr6MatII.nb

21

f@t_, v_D := 9.8 0.002 v Abs@vD 0.11; v0 = 8; t0 = 0;

Needs@"VectorFieldPlots` "D
p1 = VectorFieldPlot @ 81, 9.8 0.002 v Abs@vD 0.11<,
8t, 0.5, 25<, 8v, 0.5, 10<, AxesOrigin 80, 0<D

a = 0; b = 2; n = 20; h = N@Hb aL nD; f@t_, v_D := 9.8 0.002 v Abs@vD 0.11;

Array@t, n + 1, 0D; Array@vrkc, n + 1, 0D; Array@k1, n, 0D; Array@k2, n, 0D; Array@k3, n 1, 0D;
Array@k4, n 1, 0D; Do@t@iD = a + i h, 8i, 0, n<D; vrkc@0D = 8; For@i = 0, i n,
i ++, k1@iD = f@t@iD, vrkc@iDD; k2@iD = f@t@iD + 1 2 h, vrkc@iD + 1 2 k1@iD hD;
k3@iD = f@t@iD + 1 2 h, vrkc@iD + 1 2 h k2@iDD;
k4@iD = f@t@iD + h, vrkc@iD + k3@iD hD;
vrkc@i + 1D = vrkc@iD + 1 6 Hk1@iD + 2 k2@iD + 2 k3@iD + k4@iDL hD;
MatrixForm @Table@8t@iD, vrkc@iD<, 8i, 0, n<DD

0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1.
1.1
1.2
1.3
1.4
1.5
1.6
1.7
1.8
1.9
2.

8
6.91872
5.86433
4.83219
3.81804
2.81789
1.82793
0.844543
0.13582
1.11496
2.09015
3.05795
4.01506
4.9583
5.8847
6.7915
7.67619
8.53653
9.3706
10.1767
10.9536

22

Pr6MatII.nb

a = 0; b = 10; n = 20; h = N@Hb aL nD; f@t_, v_D := 9.8 0.002 v Abs@vD 0.11;
Array@t, n + 1, 0D; Array@vrkc, n + 1, 0D; Array@k1, n, 0D; Array@k2, n, 0D; Array@k3, n 1, 0D;
Array@k4, n 1, 0D; Do@t@iD = a + i h, 8i, 0, n<D; vrkc@0D = 8; For@i = 0, i n,
i ++, k1@iD = f@t@iD, vrkc@iDD; k2@iD = f@t@iD + 1 2 h, vrkc@iD + 1 2 k1@iD hD;
k3@iD = f@t@iD + 1 2 h, vrkc@iD + 1 2 h k2@iDD;
k4@iD = f@t@iD + h, vrkc@iD + k3@iD hD;
vrkc@i + 1D = vrkc@iD + 1 6 Hk1@iD + 2 k2@iD + 2 k3@iD + k4@iDL hD;
MatrixForm @Table@8t@iD, vrkc@iD<, 8i, 0, n<DD
0
0.5
1.
1.5
2.
2.5
3.
3.5
4.
4.5
5.
5.5
6.
6.5
7.
7.5
8.
8.5
9.
9.5
10.

8
2.8179
2.0883
6.7897
10.9519
14.3703
17.0088
18.9496
20.3272
21.2803
21.9283
22.3636
22.6536
22.8458
22.9727
23.0563
23.1113
23.1474
23.1711
23.1867
23.1969

lrkc = Table@8t@iD, vrkc@iD<, 8i, 0, n<D;

s1 = ListPlot@lrkc, PlotStyle AbsolutePointSize @9D, GridLines Automatic D;
s2 = ListPlot@lrkc, PlotJoined True, PlotStyle Green, GridLines AutomaticD;
p1 = VectorFieldPlot @ 81, 9.8 0.002 v Abs@vD 0.11<,
8t, 0.5, 25<, 8v, 30, 10<, AxesOrigin 80, 0<D;
Show@s1, s2, p1D

2
-5
-10
-15
-20

10

Pr6MatII.nb

23

Anliticamente tambin podemos hallar este valor al que tiende la velocidad,

pues se trata de un punto de equilibrio donde v ' = 0 y por tanto v =

mg k resultando :

Sqrt@0.11 9.8 0.002D

23.2164

8. Ejercicios
1. Resuelve numricamente con el mtodo del polgono mejorado y de Ralston el problema
de condicin inicial y'=-2x3 + 12 x2 - 20 x + 8.5, y(0)=1.
para un tamao del paso de 0,5. Calcula el error reativo aproximado cometido en cada iteracin. Compara las soluciones con la solucin exacta.
2. Programa 8 iteraciones del mtodo de Runge-Kutta de tercer orden para el problema de
condicin inicial y'=-2x3 + 12 x2 - 20 x + 8.5, y(0)=1.
para un tamao del paso de 0,5. Dibuja los puntos unidos y la solucin exacta.
3. Dado el problema de valor inicial y' = y + cos (x), y (0) = 1. Halla el valor aproximado de
y(0,4) utilizando el mtodo de Runge - Kutta de 4 pasos con un paso de h = 0,1. Compara los
resultados con la solucin analtica.
4. El rea S (cm2 M que ocupa una colonia de microorganismos viene modelizada por
dS
dt

= SH3.12 - 0.14 SL, SH0L = 0, 34 cm2

a) Utiliza el mtodo de Runge-Kutta de 4 pasos con h=0,5 para completar la tabla:

t das
1
2
3
4
5
S observado 3,78
16,56
38,01
52,60
58,02
S aproximado
b) Calcula analticamente S(1),...,S(5) y compara ambos resultados, indicando el error
cometido en cada iteracin.
c) Dibuja una grfica de la solucin analtica y numrica.
5. Resuelve numricamente el problema del valor inicial y' = 2 y/x, y (0.1) = 1 en el intervalo ]0.1, 3[ y, dibuja la solucin. Obtn el valor numrico de la solucin para x = 2 con el
mtodo del polgono mejorado. Calcula el error absoluto, el relativo verdadero y el relativo
aproximado.

6. Dibuja la grfica de 4 aproximaciones numricas al problema de valor inicial y'=e2 cosH5 yL,
y(0)=1 en el intervalo ]-1,1[ utilizando 20 pasos.
7. Calcula dos iteraciones del mtodo de Runge-Kutta de 4 pasos para

24

Pr6MatII.nb

y'=-2 x3 + 12 x2 - 20 x + 8.5, y(0)=1, para un tamao del paso de 0,2 sin utilizar herramientas
de programacin.

Bibliografa :
Problemas Resueltos de Metodos Numricos. A.Cordero, J.L. Hueso, E.Martnez,
J.R.Torregrosa. UPV

Mtodos Numricos para ingenieros con aplicaciones en computadoras

personales.Steven C.Chapra, Raymond P.Canale. MacGH