You are on page 1of 9

1.

Objetivo
Este trabalho tem como objetivo desenvolver um cdigo com para o Mtodo de Runge-Kutta de 4
ordem. Para tal, ser testado novamente dois exemplos de funes retirados do livro texto do curso
Anlise Numrica (Richard L. Burden e J.Douglas Faires). Sendo as solues reais:

u1(t)=-0.5*exp(2*t)+t^2+2t-0.5
u2(t)=0.5*exp(2*t)+t^2-0.5

E equaes de diferenciais :
u'1=u1-u2+2
u'2=-u1-u2+4*t

2. Introduo
Interpolao
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, porm raramente utilizada.
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.
Seja uma funo

dy
=f (x , y)
dx

, com a condio de contorno y = y n quando x = xn . Da Figura 1,

observa-se que o valor de yn+1 , em x = xn+1, dado por:

y n+1= y n+ y

(1.1)

dy
dx
dx

(1.2)

Do clculo, pode-se escrever que:

dy=

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

dy
x
dx

(1.3)

yn+1=yn+(xn+1-xn) f(xn,yn)

(1.4)

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

Na Figura 1, observa-se que quanto menor o valor da diferena entre x n+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+1e 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:

(1.5)

xn+1=xn+h

(1.6)

yn+1=yn+hf(xn,yn)

(1.7)

Sendo a equao completa, levando em consierao o erro do mtodo igual a:


2

h
y n+1= y n+ h f ( t , y n ) + y ' ' ()
2

(1.8)

A equao (1.8) 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 (h2 ).

Figura 1: Ilustrao do mtodo de Euler.

Mtodos de Runge-Kutta

dy
Os mtodos de Runge-Kutta so algoritmos explcitos para calcular y(x) ou dx

em pontos entre xi

e xi+1. Eles so utilizados tanto para problemas de valores iniciais, como para problemas de valores de
contorno. Uma abordagem mais ampla sobre problemas com valores iniciais e valores de contorno
ser considerada. Assim como no mtodo de Euler, os mtodos de Runge-Kutta tambm so
provenientes de uma aproximao da srie de Taylor. Essa aproximao permite a obteno de
diversas ordens do mtodo, sendo os mais comuns o de 2 e 4 ordem.

Figura 2: Representao grfica dos mtodos de Euler e Runge-Kutta.

Ambos os mtodos possuem termos da ordem de uma potncia de h. Estes termos so o erro
associados ao mtodo e, portanto, quanto menor o tamanho do passo, menor o erro do mtodo. Alm
disso, quanto maior a ordem do mtodo de Runge-Kutta, maior o nmero de termos utilizados na
aproximao. A frmula geral dos mtodos Runge-Kutta dada por:
M

ui+1 =ui+ W j K j onde


j =1
j1

K j =hf x i +c j h , ui + a jl K l
j=1

e c1=0, a11=0

Runge-Kutta 2 ordem
ui+1 = ui + h2 [K1 + K2]

i = 0, 1, . . . , N 1 (1.9)

K1 = f(xi, ui)

(1.10)

K2 = ui + f(xi + h, ui + h.K1)

(1.11)

Runge-Kutta 4 ordem
ui+1 = ui +

1
6

[K1 + 2K2 + 2K3 + K4]


K1 = h . f(xi , ui)

i = 0, 1, . . . , N 1 (1.12)
(1.13)

K2 = h . f(xi +

h
2 , ui +

K1
2

(1.14)

K3 = h . f(xi +

h
2 , ui +

K2
2

(1.15)

K4 = h . f(xi + h, ui + K3)

(1.16)

Mtodo de Runge Kutta 4a Ordem (RK4) para SISTEMA DE EQUAES


DIFERENCIAIS
Os mtodos para resolver sistemas de equaes diferenciais de primeira ordem so uma generalizao
dos mtodos para uma nica equao de primeira ordem apresentados no tpico anterior. Para este
projeto foi utilizado o mtodo clssico de RK4 expresso por:
ui+1,j = ui,j +

1
6

[K1,j + 2K2,j + 2K3,j + K4,j]

i = 0, 1, . . . , N 1 (1.17)

K1 = h . fi (xi , u1,i,u2,i,..., um,i)


K2 = h . fi(xj +

K3 = h . fi(xj +

K 1,1
2

h
2 , u 1, j +

h
2 , u2,j +

K 2,1
2

K4 = h . fi(xj +h, u3,j +

, u1,j +

, u2,j +

K 1,2
2 ,..., um,j +

K 2,2
2 ,..., um,j +

K 3,1 , u , +
2 j

j=1,2,...,m

K 1,m
2 )

K 2,m
2 )

K 3,2 ,..., u , +
m j

K 3,m )

(1.18)

j=1,2,...,m

(1.19)

j=1,2,...,m

(1.20)

j=1,2,...,m

(1.21)

Para a resoluo deste tipo de equaes diferencias considera-se que ij a aproximao da i-sima
soluo ui(t) da equao dum

d um
( t ) =
dt

fm(t, u1, u2, ... , um) no j-simo ponto da malha tj Como

condies iniciais.

1,0 = 1, 2,0 = 2, ... . , m,0 = m

(1.22)

3. Algoritmos
Mtodo de Runge-Kutta de 4 ordem
1) INICIO
2) ENTRADA extremidades a,b; nmero inteiro N; condio inicial alfa; nmero de equaes m;
3) FAA h=(b-a)/N;
t=a;
PARA j variando de 1 at m
wj=alfaj;
4)PARA i variando de 0 at N-1, execute os passos
PARA j variando de 1 at m
FAA k1,j=h*f(t,w1,w2,...,wm)
PARA j variando de 1 at m
FAA k2,j=h*f(t+h/2, w1+1/2*k1,1,w2+1/2*k1,2,...,wm+1/2*k1,m)
PARA j variando de 1 at m
FAA k3,j=h*f(t+h/2, w1+1/2*k2,1,w2+1/2*k2,2,...,wm+1/2*k2,m)
PARA j variando de 1 at m
FAA k4,j=h*f(t+h, w1+k3,1,w2+k3,2,...,wm+k3,m)
5)FAA wj+1=wj+( k1,j +2* k2,j +2* k3,j + k4,j)/6

t=a+ih
6) PARE
7) SADA aproximao de w e y nos (N+1) valores de t

4. Programa C
Mtodo de Runge-Kutta de 4 ordem
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
// Implementao Mtodo Runge-Kutta de 4ord
// Autor: Renan Sadao Kuroda Rodrigues
// Disciplina: Mtodos Numricos em Fenmenos de Transporte
//Aproximao da soluo do problema de valor inicial
// Entrar com as funes do sistema de equaes.
float f(int a, float i1, float i2, float tt) // Para adicionar mais uma equao, acrescente um float i3,
i4,...,im;
{
if (a==1) // Equao 1: u'_1=u1-u2+2 Condio Inicial: u_1(0)=-1
return i1-i2+2;
else
if (a==2) // Equao 2: u'_2=-u1-u2+4*t Condio Inicial: u_2(0)=0
return -i1+i2+4*tt;
}
int main()
{
// n: nmero de iteraes N
// x[]: vetor para armazenar os valores de x
// a e b: extremidades
// h[]: tamanho do passo
// alpha[]: condio inicial
// m : nmero de equaes do sistema de equaes
// w[m][n]: resultados
//err[i]: erro absoluto
int n,i,j,m;
float a,b,h;
// Inserir os quantos pontos sero utilizados
printf("\n Metodo de Runge-Kutta de 4ord \n");
printf(" Considere o problema de valor inicial de primeira ordem\n");
printf(" - u'1=u1-u2+2 para 0<=t<=1\n");
printf(" - u'2=-u1-u2+4*t\n");
printf(" condies iniciais:\n");
printf(" u1(0)=-1 & u2(0)=0\n");
printf(" Solucoes reais:\n");
printf(" - u1(t)=-0.5*exp(2*t)+t^2+2t-0.5\n" );
printf(" - u2(t)=0.5*exp(2*t)+t^2-0.5\n" );

printf(" O metodo de RK4 sera usado para encontrar uma aproximao da soluo desse\n");
printf(" problema usando h=0,1.\n");
printf("\n Digite o intervalo a e b (ex. [0;5] = digite 0 5): ");
scanf("%f %f",&a,&b);
printf(" Digite o numero de iteracoes: ");
scanf("%d",&n);
printf(" Digite o numero de equacoes do sistema de equacoes diferenciais: ");
scanf("%d",&m);
// Cria um vetor para os valores dos pontos
float w[m][n],t[n],alpha[m][n],err[n];
float k1[m][n],k2[m][n],k3[m][n],k4[m][n],I_1[i],I_2[i],err1[i],err2[i];
// Inicializa o passo h, tempo t0 e w0
//h=(b-a)/n;
h=0.1;
t[0]=a;
for (j=1; j<=m; j++)
{
printf("Digite condicao inicial alpha %d: ",j);
scanf("%f",&alpha[j][0]);
w[j][0]=alpha[j][0];
}
// Lao formar o tempo t
for (i=0; i<=n; i++)
{
t[i]=a+i*h;
}
puts (" ");
printf("\n\nTabela de Resultados");
printf("\n\n t

w1,j

w2,j

|y1(tj)-w1,j| |y2(tj)-w2,j|");

printf("\n__________________________________________________________________________
______");
for (i=0; i<=n-1; i++)
{
for (j=1; j<=m; j++)
{
k1[j][i]=h*f(j,w[1][i],w[2][i],t[i]); // *** Caso o nmero de equaes seja 3 o
termo k1 ficar k1[j][i]=h*f(j,w[1][i],w[2][i],w[3][i]);
printf("valor w %d = %f",j,w[j][0]);
//printf("k11=%f: \n",k1[1][i]);
}
for (j=1; j<=m; j++)
{
k2[j][i]=h*f(j,w[1][i]+k1[1][i]/2,w[2][i]+k1[2][i]/2,t[i]+h/2);// ***Caso o
nmero de equaes seja 3 o termo k2 ficar k2[j][i]=h*f(j,w[1][i],w[2][i],w[3][i],t[i]++h/2);
}
for (j=1; j<=m; j++)

{
k3[j][i]=h*f(j,w[1][i]+k2[1][i]/2,w[2][i]+k2[2][i]/2,t[i]+h/2);// ***Caso o
nmero de equaes seja 3 o termo k3 ficar k3[j][i]=h*f(j,w[1][i],w[2][i],w[3][i],t[i]+h/2);
}
for (j=1; j<=m; j++)
{
k4[j][i]=h*f(j,w[1][i]+k3[1][i],w[2][i]+k3[2][i],t[i]+h);// *** Caso o nmero
de equaes seja 3 o termo k4 ficar k4[j][i]=h*f(j,w[1][i],w[2][i],w[3][i],t[i]+h);
}
// Clculo da aproximao
w[1][i+1]=w[1][i]+(k1[1][i]+2*k2[1][i]+2*k3[1][i]+k4[1][i])/6;
w[2][i+1]=w[2][i]+(k1[2][i]+2*k2[2][i]+2*k3[2][i]+k4[2][i])/6;
// Soluo exata
// u1(t)=-0.5*exp(2*t)+t^2+2t-0.5
I_1[i]=(-0.5)*exp(2*t[i])+t[i]*(t[i]+2)-0.5;
// u2(t)=0.5*exp(2*t)+t^2-0.5
I_2[i]=(0.5)*exp(2*t[i])+t[i]*t[i]-0.5;
// Clculo do erro absoluto
err1[i]=I_1[i]-w[1][i];
err2[i]=I_2[i]-w[2][i];
// Impresso dos resultados
printf("%f | %f | %f | %f | %f \n",t[i],w[1][i],w[2][i],fabs(err1[i]),fabs(err2[i]));
//printf("%f | %f | %f | %f | %f \n",t[i],w[1][i],w[2][i],err1[i],err1[i]);
}
printf("\n\n\nFim do calculo \n\n\n");
return(0);
}

5. Resultados e Discurses
Para a verificao do cdigo foi escolhido um exerccio do livro texto do curso, Analise Numrica,
referente a utilizao do mtodo de Runge-Kutta de 4 Ordem para sistema para encontrar
aproximaes das solues do sistema de primeira ordem.
t

u1

u2

w1

w2

0
0,1
0,2
0,3
0,4
0,5
0,6
0,7
0,8
0,9

-1
-0,9007
-0,80591
-0,72106
-0,65277
-0,60914
-0,60006
-0,6376
-0,73652
-0,91482

0
0,120701
0,285912
0,501059
0,77277
1,109141
1,520058
2,0176
2,616516
3,334824

-1,000000
-0,900700
-0,805909
-0,721053
-0,652760
-0,609126
-0,600036
-0,637568
-0,736471
-0,914762

0,000000
0,120700
0,285909
0,501053
0,772760
1,109126
1,520036
2,017568
2,616471
3,334762

errro 1

errro 2

0
1
2
3
4
5
6
7
8
9

0,000000
-0,000001
-0,000003
-0,000006
-0,000010
-0,000015
-0,000022
-0,000032
-0,000045
-0,000061

0,000000
0,000001
0,000003
0,000006
0,000010
0,000015
0,000022
0,000032
0,000045
0,000061

6. Concluso
O mtodo de Runge-Kutta se demonstrou novamente ter uma boa aproximao da soluo real. Como
j esperado a medida que aumentasse o tempo, o erro de truncamento do mtodo comea a aumentar.
Entretanto, se aumentar o valor do passo h, a propagao do erro tende a diminuir.

7. Referncia
[1] - Burden, Richard L. and Faires, J.Doulas - Analise numrica traduo 8aed norte americana. Ed
Cengage Learning.
[2] Guidi, Leonardo F. Material Graduo Pgina da disciplina "Noes de Clculo Numrico"
MAT01186 (http://www.mat.ufrgs.br/~guidi/grad/MAT01169/calculo_numerico.pdf) Acessado em
22/03/2015
[3] Rigo, Giancarlo and Manzo, Rafael Reggiani - Implementao do Mtodo de Integrao Numrica

Runge-Kutta
em
GPGPU
para
Aplicaes
Cientficas

(http://bcc.ime.usp.br/principal/tccs/2012/giancarlo+rafael/documentacao/monografia.pdf) acessado
em 02/06/2015

You might also like