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

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

Seja uma funo

dy = 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 dx

(1.2)

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

dy x dx

(1.3)

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 Usando a equao (1.5) nas equaes (1.5) e (1.4), tem-se: xn +1 = xn + h

e 1

(1.5)

(1.6)

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)
y

yn
Valores iniciais

x = h

Figura 1 Ilustrao do mtodo de Euler.

xn

xn+1

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 dx

(1.8)

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

y (0) = 1
2

(1.9)

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

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

(1.10)

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

xn +1 = xn + h
e

(1.11)

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

(1.12)

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.

xn
0,000 0,001 0,002 0,003 0,004 0,005 ... 0,500 1,000 1,500 2,000

yn
1,000000 1.005000 1.010019 1.015057 1.020114 1.025191 ... 8.677069 64.382558 473.559790 3484.160803

y 1,000000 1.005010 1.010038 1.015086 1.020153 1.025239 ... 8.712004 64.897803 479.259192 3540.200110

0 1 2 3 4 5 ... 500 1000 1500 2000

4000 3500
y(t)

4000

Numrica Analtica

3500

3000 2500

3000

2500

y(t)

2000 1500 1000 500 0 0,0

2000 1,90

1,92

1,94

1,96

1,98

2,00

0,5

1,0

1,5

2,0

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:
f ( x, y ) .

01: Entre com a funo

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
Faa

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

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.

#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 n+ 2 2

(1.13)

Na equao (1.13), y de y
n+ 1 2

1 o valor de y em xn + h . Uma estimativa do valor 2 encontrado com o auxlio do mtodo de Euler:

1 n+ 2

y
Denominando:

1 n+ 2

h = yn + f ( xn , yn ) 2

(1.14)

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

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

n+

1 2

yn h 2 h

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

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 1 h k3 = h f xn + , yn + k2 2 2 k4 = h f ( xn + h, yn + k3 ) yn +1 = yn + 1 ( k1 + 2 k2 + 2 k3 + k4 ) 6

(1.17)

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.

xn
0,000 0,001 0,002 0,003 0,004 0,005 ... 0,500 1,000 1,500 2,000

yn
1,000000 1.050963 1.103903 1.158903 1.216044 1.275416 8.712004 64.897798 479.259133 3540.199525

y 1,000000 1.050963 1.103903 1.158903 1.216044 1.275416 8.712004 64.897803 479.259192 3540.200110

0 1 2 3 4 5 ... 50 100 150 200

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

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) { return 1-x+4*y; } /* a funo f(x,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:

d2y dy + q ( x ) = r ( x, y ) 2 dx dx
Defini-se uma varivel auxiliar z :

(1.19)

z ( x, y ) =

dy dx

(1.20)

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 dz = r ( x, y ) q ( x ) z ( x ) dx
O conjunto de equaes em (1.21) pode ser escrito como:

(1.21)

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 ) zn +1 = zn + h g ( xn , yn , zn )

(1.23)

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

d2y dy + 30 + 200 y = 1000 2 dx dx

(1.24)

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

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

(1.25)

O primeiro passo reduzir esta equao diferencial de 2 ordem para um conjunto de 2 equaes diferenciais ordinrias de 1 ordem:

dy =z dx dz = 1000 30 z 200 y dx

(1.26)

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.

xn
0,0 0,01 0,02 0,03 0,04 0,05 ... 0,5 0,7 0,9 1,0

yn
0.000000 0.000000 0.100000 0.270000 0.487000 0.733500 4.948534 4.993735 4.999238 4.999734

y 0.000000 0.045280 0.164293 0.335876 0.543444 0.774091 4.932848 4.990885 4.998766 4.999546

0 1 2 3 4 5 ... 50 70 90 100

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) { return z; } double g(double x, double y, double z) { return 1000.0-30.0*z-200.0*y; }

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

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

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:

yn +1 = yn +

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

(1.28)

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 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.

(1.29)

d2y dy + 30 + 200 y = 1000 2 dx dx

(1.30)

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

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

(1.31)

O primeiro passo reduzir esta equao diferencial de 2 ordem para um conjunto de 2 equaes diferenciais ordinrias de 1 ordem:

dy =z dx dz = 1000 30 z 200 y dx

(1.32)

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.

xn
0,0 0,01 0,02 0,03 0,04 0,05 ... 0,5 0,7 0,9 1,0

yn
0.000000 0.016667 0.123528 0.293960 0.507390 0.748036 4.943575 4.992869 4.999100 4.999680

y 0.000000 0.045280 0.164293 0.335876 0.543444 0.774091 4.932848 4.990885 4.998766 4.999546

0 1 2 3 4 5 ... 50 70 90 100

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) { return z; } double g(double x, double y, double z) { return 1000.0-30.0*z-200.0*y; } /* a funo f(x,y,z)=dy/dx */

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

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)); variveis */

/* escreve os valores das

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

13

l1 k2 l2 k3 l3 k4 l4

= = = = = = =

h*g(xn, yn, zn); h*f(xn+(1/2)*h, yn+(1/2)*k1, h*g(xn+(1/2)*h, yn+(1/2)*k1, h*f(xn+(1/2)*h, yn+(1/2)*k2, h*g(xn+(1/2)*h, yn+(1/2)*k2, h*f(xn+h, yn+k3, zn+l3); h*g(xn+h, yn+k3, zn+l3);

zn+(1/2)*l1); zn+(1/2)*l1); zn+(1/2)*l2); zn+(1/2)*l2);

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; xn = xn1; yn = yn1; zn = zn1;

/* atualiza as variveis para a prxima iterao */

}/* 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