DELC - Departamento de Eletrnica e Computao

ELC 1021 Estudo de Casos em Engenharia Eltrica

Soluo de Equaes Diferenciais

Ordinrias Usando Mtodos
Numricos
Verso 0.1

Giovani Baratto

Fevereiro de 2007
 ndice

1 Mtodo de Euler......................................................................................... 1
1.1 Derivao da Frmula de Euler ......................................................... 1
1.2 Exemplo Usando o Mtodo de Euler .................................................. 2
2 Mtodo de Runge-Kutta............................................................................. 5
2.1 Exemplo Usando o Mtodo de Runge-Kutta...................................... 7
3 Equaes Ordinrias de Ordem de 2 Ordem ........................................... 8
3.1 Soluo Usando o Mtodo de Euler.................................................... 9
3.2 Soluo Usando o Mtodo de Runge-Kutta ..................................... 11
Neste texto ser apresentado o mtodo de Euler e o mtodo de Runge-Kutta
para a soluo de equaes diferenciais ordinrias.

1 Mtodo de Euler

O mtodo de Euler, tambm conhecido como mtodo da reta secante, um

dos mtodos mais antigos que se conhece para a soluo de equaes
diferenciais ordinrias. Problemas prticos no devem ser resolvidos com o
mtodo de Euler. Existem outros mtodos que proporcionam resultados com
uma melhor preciso e estabilidade se comparados ao mtodo de Euler para
o mesmo passo.

1.1 Derivao da Frmula de Euler

dy
Seja uma funo = f ( x, y ) com a condio de contorno y = yn quando
dx
x = xn . Da Figura 1, observa-se que o valor de yn +1 , em x = xn +1 , dado por:

yn +1 = yn + y (1.1)

Do clculo, pode-se escrever que:

dy
dy = dx (1.2)
dx

Da equao (1.2), encontra-se uma aproximao para y :

dy
y x (1.3)
dx

Das equaes (1.1) e (1.3), encontra-se:

yn +1 = yn + ( xn +1 xn ) f ( x n , yn ) (1.4)
Na Figura 1, observa-se que quanto menor o valor da diferena entre xn +1 e
xn (desprezando os erros causados pela representao finita dos nmeros
pelos computadores), menor o erro da estimativa para yn +1 . Todavia, o
nmero de computaes para um intervalo aumenta medida que a
diferena entre xn +1 e xn reduzida. Define-se o passo h como sendo igual a:

h = xn +1 xn (1.5)
Usando a equao (1.5) nas equaes (1.5) e (1.4), tem-se:

xn +1 = xn + h (1.6)
e

1
 yn +1 = yn + h f ( xn , yn ) (1.7)

A equao (1.7) conhecida como frmula de Euler. A soluo de uma

equao diferencial pelo mtodo de Euler realizada pelo uso recursivo das
equaes (1.6) e (1.7), usando as condies de contorno x0 e y0 . O erro no
mtodo de Euler da ordem de O ( h 2 ) .

Estimativa

y
yn+1
Erro
f(x)

yn

Valores
iniciais
x = h

xn xn+1 x
Figura 1 Ilustrao do mtodo de Euler.

1.2 Exemplo Usando o Mtodo de Euler

As seguir ser apresentado o mtodo de Euler na soluo de uma equao

diferencial ordinria de 1 ordem. A equao escolhida ser (Boyce, W. E.;
DiPrima, R. C. Equaes Diferenciais Elementares e Problemas de Valor de
Contorno. ed. 7, pp. 420):

dy
= 1 x + 4 y (1.8)
dx

Esta equao ser resolvida de x = 0 s a x = 2 s, com a seguinte condio de

contorno:

y (0) = 1 (1.9)

2
A soluo da equao diferencial (1.8) com a condio de contorno (1.9)
conhecida:

1 3 19
y ( x ) = x + e 4 x (1.10)
4 16 16

A soluo numrica encontrada com a avaliao das equaes (1.6) e (1.7):

xn +1 = xn + h (1.11)
e

yn +1 = yn + h f ( xn , yn )
(1.12)
= yn + h (1 x + 4 y )

Com a condio de contorno da equao (1.9), temos que x0 = 0 e y0 = 1 . Os

prximos valores so calculados com o uso recursivo das equaes (1.11) e
(1.12). O valor do passo escolhido considerando-se o erro desejado. Neste
exemplo, escolhemos h = 0, 001 . A seguir apresentada uma tabela com
alguns valores calculados de y pelo mtodo de Euler e usando a soluo
algbrica.

Tabela 1 Resultado da soluo numrica da equao (1.8) usando o mtodo de

Euler.

n xn yn y
0 0,000 1,000000 1,000000
1 0,001 1.005000 1.005010
2 0,002 1.010019 1.010038
3 0,003 1.015057 1.015086
4 0,004 1.020114 1.020153
5 0,005 1.025191 1.025239
... ... ... ...
500 0,500 8.677069 8.712004
1000 1,000 64.382558 64.897803
1500 1,500 473.559790 479.259192
2000 2,000 3484.160803 3540.200110

3
 4000 4000 Numrica
Analtica
3500 3500

3000 3000

y(t)
2500 2500
y(t)

2000 2000
1,90 1,92 1,94 1,96 1,98 2,00

1500

1000

500

0
0,0 0,5 1,0 1,5 2,0
t

Figura 2 Grfico apresentando a soluo numrica (mtodo de Euler) e analtica

da equao (1.8).

O mtodo pode ser aplicado com o uso de lpis, papel e calculadora. No

entanto, este processo fastidioso pelo nmero de iteraes. A programao
em computador simples. A programao segue os seguintes passos:

01: Entre com a funo f ( x, y ) .

02: Entre com os valores iniciais x0 e y0 .
03: Entre com o passo h .
04: Enquanto xn < x final execute:
Escreva n , xn , yn
Avalie xn +1 = xn + h
Avalie yn +1 = yn + h f ( xn , yn )
Faa xn = xn +1 e yn = yn +1
06: Fim.

Um programa escrito em C apresentado a seguir. Este programa foi escrito

para ser didtico, podendo ser melhorado.

4
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

double y(double x) /* a soluo y(t) da equao */

{
return (1.0/4.0)*x-(3.0/16.0)+(19.0/16.0)*exp(4.0*x);
}

double f(double x, double y) /* a funo f(x,y)*/

{
return 1-x+4*y;
}

int main(int arc, char* argv[])

{
double xn, xn1, xmax; /* variveis tn e tn+1 */
double yn, yn1; /* variveis yn e yn+1 */
double y0, x0; /* valores iniciais de y e t */
double h; /* passo */
int n;

x0 = 0.0; /* valor incial para t */

y0 = 1.0; /* valor inicial para y */
xmax = 2.0; /* valor mximo para t */
h = 0.001; /* o valor do passo */
xn = t0;
yn = y0;
n = 0; /* numero de iteraes */
while(xn < xmax){
printf("%i %f %f %f\n",n,xn,yn,y(xn)); /*escreva os valores das variveis*/
yn1 = yn + h*f(xn,yn); /* estime yn+1 pelo mtodo de Euler */
xn1 = xn + h;
n = n+1; /* Atribua os valores para a prxima iterao */
yn = yn1;
xn = xn1;
}/* while */
return 0; /* termina a computao */
}/* main */

Ilustrao 1 Exemplo de um programa em C para a soluo da equao (1.8) pelo

mtodo de Euler.

2 Mtodo de Runge-Kutta

O mtodo de Runge-Kutta pode ser entendido como um aperfeioamento do

mtodo de Euler, com uma melhor estimativa da derivada da funo. No
mtodo de Euler a estimativa do valor de yn +1 realizado com o valor de yn e
com a derivada no ponto xn . No mtodo de Runge-Kutta, busca-se uma
melhor estimativa da derivada com a avaliao da funo em mais pontos no
intervalo [ xn , xn +1 ] . Um mtodo de Runge-Kutta de ordem n possui um erro
da ordem de O ( h n +1 ) . O mtodo de Runge-Kutta de 4 ordem o mais usado
na soluo numrica de problemas com equaes diferenciais ordinrias.
A seguir ser discutido o mtodo de Runge-Kutta de 2 ordem, ilustrado pela
Figura 3. No mtodo de Euler de passo h , a estimativa de yn +1 realizada
com os valores de xn e da derivada de yn . No mtodo de Runge-Kutta de 2
ordem, o valor da estimativa de yn +1 encontrado com o valor de yn e com
h
uma estimativa da derivada em um ponto mais prximo de xn +1 , em xn + :
2

5
 1
yn +1 = yn + h f xn + h, y 1 (1.13)
n+
2 2

1
Na equao (1.13), y 1 o valor de y em xn + h . Uma estimativa do valor
n+ 2
2

de y 1 encontrado com o auxlio do mtodo de Euler:

n+
2
h
y 1 = yn + f ( xn , yn ) (1.14)
n+ 2
2

Denominando:
k1 = h f ( xn . yn )
1 1 (1.15)
k2 = h f xn + h, yn + k1
2 2

Escreve-se a equao (1.13) como:

yn +1 = yn + k2 (1.16)

No mtodo de Runge-Kutta de 2 ordem, avaliam-se as equaes (1.15) e

(1.16).

Erro
Runge Kutta
yn +1
n +1
Erro
Euler

y 1
n+
2
yn

h
2

h xn +1xn xn +
2
Figura 3 Ilustrao do mtodo de Runge-Kutta de 2 ordem.

6
O mtodo de Runge-Kutta de 4 ordem tem as seguintes equaes:

k1 = h f ( xn , yn )
h 1
k2 = h f xn + , yn + k1
2 2
h 1
k3 = h f xn + , yn + k2 (1.17)
2 2
k4 = h f ( xn + h, yn + k3 )
1
yn +1 = yn + ( k1 + 2 k2 + 2 k3 + k4 )
6

xn +1 = xn + h (1.18)

2.1 Exemplo Usando o Mtodo de Runge-Kutta

A seguir ser apresentado um exemplo usando o mtodo de Runge-Kutta na

soluo de uma equao diferencial. Ser usada a equao diferencial (1.8)
com as condies iniciais dada por (1.9), a mesma equao que foi usada no
Exemplo usando o mtodo de Euler. O passo neste exemplo ser reduzido
para 0,01 s. A soluo da equao diferencial encontrada pelo uso iterativo
das equaes (1.17) e (1.18). A seguir apresentada uma tabela com os
valores calculados e com o valor analtico da soluo.

Tabela 2 Resultado da soluo numrica da equao (1.8) usando o mtodo de

Runge-Kutta.

n xn yn y
0 0,000 1,000000 1,000000
1 0,001 1.050963 1.050963
2 0,002 1.103903 1.103903
3 0,003 1.158903 1.158903
4 0,004 1.216044 1.216044
5 0,005 1.275416 1.275416
... ...
50 0,500 8.712004 8.712004
100 1,000 64.897798 64.897803
150 1,500 479.259133 479.259192
200 2,000 3540.199525 3540.200110

Comparando-se os resultados da soluo numrica usando o mtodo de

Euler (Tabela 1) com os resultados da soluo usando o mtodo de Runge-

7
Kutta (Tabela 2), observa-se que neste segundo mtodo a preciso maior,
mesmo com o uso de um passo 10 vezes maior.
A seguir apresentado um programa escrito em C, para a soluo numrica
da equao (1.8).

#include <stdlib.h>
#include <stdio.h>
#include <math.h>

double y(double x) /* a soluo y(x) da equao */

{
return (1.0/4.0)*x-(3.0/16.0)+(19.0/16.0)*exp(4.0*x);
}

double f(double x, double y) /* a funo f(x,y)*/

{
return 1-x+4*y;
}

int main(int argc, char* argv[])

{
double xn, xn1, xmax; /* variveis tn e tn+1 */
double yn, yn1; /* variveis yn e yn+1 */
double y0, t0; /* valores iniciais de y e t */
double h; /* passo */
double k1, k2, k3, k4; /* variveis auxiliares */
int n; /* nmero de iteraes */

x0 = 0.0; /* valor incial para t */

y0 = 1.0; /* valor inicial para y */
xmax = 2.0; /* valor mximo para t */
h = 0.01; /* o valor do passo */
xn = t0;
yn = y0;
n = 0; /* numero de iteraes */
while(xn < xmax){
printf("%i %f %f %f\n",n,tn,yn,y(tn)); /*escreva os valores das variveis*/
k1 = h*f(xn,yn); /* aplica o mtodo de Runge-Kutta */
k2 = h*f(xn+h/2, yn+k1/2.0);
k3 = h*f(xn+h/2, yn+k2/2.0);
k4 = h*f(xn+h, yn+k3);
xn1 = xn + h;
yn1 = yn + (k1+2*k2+2*k3+k4)/6.0;
n = n+1; /* atribua os valores para a prxima iterao */
xn = xn1;
yn = yn1;

}/* lao while */

return 0; /* termina a computao */
}/* funo main */

Ilustrao 2 Exemplo de um programa em C para a soluo da equao (1.8) pelo

mtodo de Runge-Kutta.

3 Equaes Ordinrias de Ordem de 2 Ordem

Equaes diferenciais de 2 ordem, ou de ordem superior, podem ser

reduzidas a um conjunto de equaes diferenciais de 1 ordem. Este conjunto
de equaes de 1 ordem pode ser resolvido pelo mtodo de Runge-Kutta ou
outro mtodo numrico. Seja uma equao diferencial de 2 ordem:

8
 d2y dy
2
+ q ( x ) = r ( x, y ) (1.19)
dx dx

Defini-se uma varivel auxiliar z :

dy
z ( x, y ) = (1.20)
dx

A equao (1.19) escrita como um conjunto de duas equaes diferenciais

de 1 ordem, com o auxlio da varivel z ( x, y ) , definida na equao (1.20).

dy
= z ( x, y )
dx
(1.21)
dz
= r ( x, y ) q ( x ) z ( x )
dx

O conjunto de equaes em (1.21) pode ser escrito como:

dy
= f ( x, y , z )
dx
(1.22)
dz
= g ( x, y , z )
dx
Para a soluo da equao diferencial ordinria de 2 ordem (1.19),
necessrio que as equaes diferenciais ordinrias de primeira ordem,
apresentadas em (1.22) seja resolvidas. A seguir, apresenta-se a soluo
destas equaes, usando o mtodo de Euler e o mtodo de Runge-Kutta.

3.1 Soluo Usando o Mtodo de Euler

As equaes em (1.22) so resolvidas pelo mtodo de Euler, usando

iterativamente as equaes apresentadas a seguir:

yn +1 = yn + h f ( xn , yn , zn )
(1.23)
zn +1 = zn + h g ( xn , yn , zn )

Exemplo: Resolva a seguinte equao diferencial de 2 ordem, usando o

mtodo de Euler.

d2y dy
2
+ 30 + 200 y = 1000 (1.24)
dx dx

Resolva a equao (1.24) com x variando de 0 a 1. Considere as seguintes

condies de contorno:

9
 y ( 0) = 0
dy (1.25)
=0
dx t =0

O primeiro passo reduzir esta equao diferencial de 2 ordem para um

conjunto de 2 equaes diferenciais ordinrias de 1 ordem:

dy
=z
dx
(1.26)
dz
= 1000 30 z 200 y
dx

O conjunto de equaes em (1.26) resolvido usando as expresses em (1.23)

. De acordo com as condies iniciais em (1.25), tem-se x0 = 0 e y0 = 0 . O
passo usando neste exemplo ser h = 0, 01 s. A seguir apresentada uma
tabela com os valores calculados numericamente e obtidos da soluo
analtica, que para este exemplo igual a:

y ( t ) = 5 10 e 10 x + 5 e 20 x (1.27)

Tabela 3 Resultado da soluo numrica da equao (1.24), usando o mtodo de

Euler.

n xn yn y
0 0,0 0.000000 0.000000
1 0,01 0.000000 0.045280
2 0,02 0.100000 0.164293
3 0,03 0.270000 0.335876
4 0,04 0.487000 0.543444
5 0,05 0.733500 0.774091
... ...
50 0,5 4.948534 4.932848
70 0,7 4.993735 4.990885
90 0,9 4.999238 4.998766
100 1,0 4.999734 4.999546

A seguir apresentado um programa em C que implementa esta soluo.

#include <stdlib.h> /* biblioteca de funes */

#include <stdio.h>
#include <math.h>

double y(double x) /* A soluo analtica de y(x)*/

{
return 5.0-10.0*exp(-10.0*x)+5.0*exp(-20.0*x);
}

10
double f(double x, double y, double z) /* a funo f(x,y,z)=dy/dx */
{
return z;
}

double g(double x, double y, double z) /* a funo g(x,y,z)=dz/dx */

{
return 1000.0-30.0*z-200.0*y;
}

int main(int arc, char* argv[])

{
double xn, xn1, xmax; /* declarao de xn, xn+1 e mximo valor de x na simulao
*/
double yn, yn1; /* declarao de yn e yn+1 */
double zn, zn1; /* declarao de zn e zn+1 */
double h; /* passo */
double x0,y0,z0; /* valores iniciais de x, y e z */
int n; /* nmero de iteraes */

x0 = 0.0; /* atribuio dos valores de contorno */

y0 = 0.0;
z0 = 0.0;
h = 0.01;
xmax = 1.0;

n = 0; /* inicializa as variveis com os valores iniciais*/

xn = x0;
yn = y0;
zn = z0;

while(xn<xmax){
printf("%i %f %f %f\n",n,xn,yn,y(xn)); /* escreve os valores das variveis */

xn1 = xn + h; /* realiza uma iterao do mtodo de Runge-Kutta */

yn1 = yn + h * f(xn,yn,zn);
zn1 = zn + h * g(xn,yn,zn);

n = n + 1; /* atualiza as variveis para a prxima iterao */

xn = xn1;
yn = yn1;
zn = zn1;
}/* while */
return 0; /* termina a execuo do programa */
}/* main */

Ilustrao 3 Programa em C usando o mtodo de Euler para a soluo da

equao (1.24), uma equao diferencial ordinria de 2 ordem.

3.2 Soluo Usando o Mtodo de Runge-Kutta

As equaes em (1.22) so resolvidas pelo mtodo de Runge-Kutta, usando

iterativamente as equaes apresentadas a seguir:

1
yn +1 = yn + ( k1 + 2 k2 + 2 k3 + k4 )
6
(1.28)
1
zn +1 = zn + ( l1 + 2 l2 + 2 l3 + l4 )
6
onde

11
 k1 = h f ( xn , yn , zn )
l1 = h g ( xn , yn , zn )
1 1 1
k2 = h f xn + h, yn + k1 , zn + l1
2 2 2
1 1 1
l2 = h g xn + h, yn + k1 , zn + l1
2 2 2
(1.29)
1 1 1
k3 = h f xn + h, yn + k2 , zn + l2
2 2 2
1 1 1
l3 = h g xn + h, yn + , zn + l2
2 2 2
k4 = h f ( xn + h, yn + k3 , zn + l3 )
l4 = h g ( xn + h, yn + k3 , zn + l3 )

Exemplo: Resolva a seguinte equao diferencial de 2 ordem, usando o

mtodo de Runge-Kutta.

d2y dy
2
+ 30 + 200 y = 1000 (1.30)
dx dx

Resolva a equao (1.24), para x entre 0 a 1. Considere as seguintes

condies de contorno:

y ( 0) = 0
dy (1.31)
=0
dx t =0

O primeiro passo reduzir esta equao diferencial de 2 ordem para um

conjunto de 2 equaes diferenciais ordinrias de 1 ordem:

dy
=z
dx
(1.32)
dz
= 1000 30 z 200 y
dx

O conjunto de equaes em (1.32) resolvido usando as expresses em(1.29).

De acordo com as condies iniciais em (1.31) , tem-se x0 = 0 e y0 = 0 . O
passo usando neste exemplo ser h = 0, 01 . A seguir apresentada uma
tabela com os valores calculados numericamente e obtidos da soluo
analtica, que para este exemplo igual a:

y ( t ) = 5 10 e 10 x + 5 e 20 x (1.33)

12
Tabela 4 Resultado da soluo numrica da equao(1.30), usando o mtodo de
Runge-Kutta.

n xn yn y
0 0,0 0.000000 0.000000
1 0,01 0.016667 0.045280
2 0,02 0.123528 0.164293
3 0,03 0.293960 0.335876
4 0,04 0.507390 0.543444
5 0,05 0.748036 0.774091
... ...
50 0,5 4.943575 4.932848
70 0,7 4.992869 4.990885
90 0,9 4.999100 4.998766
100 1,0 4.999680 4.999546

A seguir apresentado um programa em C que implementa esta soluo.

#include <stdlib.h> /* biblioteca de funes */

#include <stdio.h>
#include <math.h>

double y(double x) /* A soluo analtica de y(x)*/

{
return 5.0-10.0*exp(-10.0*x)+5.0*exp(-20.0*x);
}

double f(double x, double y, double z) /* a funo f(x,y,z)=dy/dx */

{
return z;
}

double g(double x, double y, double z) /* a funo g(x,y,z)=dz/dx */

{
return 1000.0-30.0*z-200.0*y;
}

int main(int arc, char* argv[])

{
double xn, xn1, xmax; /* declarao de xn, xn+1 e val mximo de x na simulao */
double yn, yn1; /* declarao de yn e yn+1 */
double zn, zn1; /* declarao de zn e zn+1 */
double h; /* passo */
double x0,y0,z0; /* valores iniciais de x, y e z */
double k1, k2, k3, k4; /* variveis auxiliares do mtodo de Runge-Kutta */
double l1, l2, l3, l4; /* variveis auxiliares do mtodo de Runge-Kutta */
int n; /* nmero de iteraes */

x0 = 0.0; /* atribuio dos valores de contorno */

y0 = 0.0;
z0 = 0.0;
h = 0.01;
xmax = 1.0;

n = 0; /* inicializa as variveis com os valores iniciais*/

xn = x0;
yn = y0;
zn = z0;

while(xn<xmax){
printf("%i %f %f %f\n",n,xn,yn,y(xn)); /* escreve os valores das
variveis */

k1 = h*f(xn, yn, zn); /* realiza uma iterao do mtodo Runge-Kutta */

13
 l1 = h*g(xn, yn, zn);
k2 = h*f(xn+(1/2)*h, yn+(1/2)*k1, zn+(1/2)*l1);
l2 = h*g(xn+(1/2)*h, yn+(1/2)*k1, zn+(1/2)*l1);
k3 = h*f(xn+(1/2)*h, yn+(1/2)*k2, zn+(1/2)*l2);
l3 = h*g(xn+(1/2)*h, yn+(1/2)*k2, zn+(1/2)*l2);
k4 = h*f(xn+h, yn+k3, zn+l3);
l4 = h*g(xn+h, yn+k3, zn+l3);

xn1 = xn + h;
yn1 = yn + (1/6.0)*(k1 + 2*k2 + 2*k3 + k4);
zn1 = zn + (1/6.0)*(l1 + 2*l2 + 2*l3 + l4);

n = n + 1; /* atualiza as variveis para a prxima iterao */

xn = xn1;
yn = yn1;
zn = zn1;
}/* while */
return 0; /* termina a execuo do programa */
}/* main */

Ilustrao 4 Programa em C usando o mtodo de Euler para a soluo da

equao (1.30), uma equao diferencial ordinria de 2 ordem.

14