Professional Documents
Culture Documents
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
y n+1= y n+ y
(1.1)
dy
dx
dx
(1.2)
dy=
dy
x
dx
(1.3)
yn+1=yn+(xn+1-xn) f(xn,yn)
(1.4)
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)
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 ).
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.
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
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
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)
1
6
i = 0, 1, . . . , N 1 (1.17)
K3 = h . fi(xj +
K 1,1
2
h
2 , u 1, j +
h
2 , u2,j +
K 2,1
2
, 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
condies iniciais.
(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