1. ObjetivoEste trabalho tem como objetivo desenvolver um código com para o Método de Runge-Kutta de 4ª ordem. Para tal, será testado novamente dois exemplos de funções retirados do livro texto do curso Análise Numérica (Richard L. Burden e J.Douglas Faires). Sendo as soluções 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 equações de diferenciais : u'1=u1-u2+2 u'2=-u1-u2+4*t

2. Introdução

Interpolação

O método de Euler, também conhecido como método da reta secante, é um dos métodos mais antigos que se conhece para a solução de equações diferenciais ordinárias, porém raramente utilizada. Problemas práticos não devem ser resolvidos com o método de Euler. Existem outros métodos que proporcionam resultados com uma melhor precisão e estabilidade se comparados ao método de Euler para o mesmo passo.

Seja uma função dydx

=f (x , y ) , com a condição de contorno y = yn quando 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 cálculo, pode-se escrever que:

dy=dydxdx (1.2)

Da equação (1.2), encontra-se uma aproximação para:

∆ y ≅dydx∆ x (1.3)

Das equações (1.1) e (1.3), encontra-se:

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

Na Figura 1, observa-se que quanto menor o valor da diferença entre xn+1 e xn (desprezando os erros causados pela representação finita dos números pelos computadores), menor o erro da estimativa para yn+1. Todavia, o número de computações para um intervalo aumenta à medida que a diferença entre xn+1e xn reduzida. Define-se o passo h como sendo igual a:

h=xn+1-xn (1.5)

Usando a equação (1.5) nas equações (1.5) e (1.4), tem-se:

xn+1=xn+h (1.6)

e

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

Sendo a equação completa, levando em consieração o erro do método igual a:

yn+1= yn+h ∙ f (t , yn )+ h2

2y ' ' () (1.8)

A equação (1.8) é conhecida como fórmula de Euler. A solução de uma equação diferencial pelo método de Euler é realizada pelo uso recursivo das equações (1.6) e (1.7), usando as condições de contorno x0 e y0 . O erro no método de Euler é da ordem de O (h2 ).

Figura 1: Ilustração do método de Euler.

Métodos de Runge-Kutta

Os métodos de Runge-Kutta são algoritmos explícitos para calcular y(x) oudydx

em pontos entre xi e

xi+1. Eles são 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 método de Euler, os métodos de Runge-Kutta também são provenientes de uma aproximação da série de Taylor. Essa aproximação permite a obtenção de diversas ordens do método, sendo os mais comuns o de 2ª e 4ª ordem.

Figura 2: Representação gráfica dos métodos de Euler e Runge-Kutta.

Ambos os métodos possuem termos da ordem de uma potência de h. Estes termos são o erro associados ao método e, portanto, quanto menor o tamanho do passo, menor o erro do método. Além disso, quanto maior a ordem do método de Runge-Kutta, maior é o número de termos utilizados na aproximação. A fórmula geral dos métodos Runge-Kutta é dada por:

ui+1=ui+∑j=1

M

W jK j onde

K j=hf (x i+c jh ,ui+∑j=1

j−1

a jlK l) 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 + 16

[K1 + 2K2 + 2K3 + K4] i = 0, 1, . . . , N – 1 (1.12)

K1 = h . f(xi , ui) (1.13)

K2 = h . f(xi + h2

, ui + K1

2 ) (1.14)

K3 = h . f(xi + h2

, ui + K2

2 ) (1.15)

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

Método de Runge Kutta 4a Ordem (RK4) para SISTEMA DE EQUAÇÕES DIFERENCIAIS

Os métodos para resolver sistemas de equações diferenciais de primeira ordem são uma generalização dos métodos para uma única equação de primeira ordem apresentados no tópico anterior. Para este projeto foi utilizado o método clássico de RK4 expresso por:

ui+1,j = ui,j + 16

[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) j=1,2,...,m (1.18)

K2 = h . fi(xj + h2

, u1,j + K1,1

2 , u1,j +

K1,2

2,..., um,j +

K1 ,m

2) j=1,2,...,m (1.19)

K3 = h . fi(xj + h2

, u2,j + K2,1

2 , u2,j +

K2,2

2,..., um,j +

K2 ,m

2) j=1,2,...,m (1.20)

K4 = h . fi(xj +h, u3,j + K3,1 , u2,j + K3,2,..., um,j + K3 , m) j=1,2,...,m (1.21)

Para a resolução deste tipo de equações diferencias considera-se que ω ij é a aproximação da i-ésima

solução ui(t) da equação dum dumdt

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

condições iniciais.

ω1,0 = α1, ω2,0 = α2, ... . , ωm,0 = αm (1.22)

3. Algoritmos

Método de Runge-Kutta de 4ª ordem1) INICIO2) ENTRADA extremidades a,b; número inteiro N; condição inicial alfa; número de equações m;3) FAÇA 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 passosPARA j variando de 1 até mFAÇA k1,j=h*f(t,w1,w2,...,wm)

PARA j variando de 1 até mFAÇA 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é mFAÇA 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é mFAÇA k4,j=h*f(t+h, w1+k3,1,w2+k3,2,...,wm+k3,m)

5)FAÇA wj+1=wj+( k1,j +2* k2,j +2* k3,j + k4,j)/6 t=a+ih6) PARE

7) SAÍDA aproximação de w e y nos (N+1) valores de t

4. Programa C

Método de Runge-Kutta de 4ª ordem#include <stdio.h>#include <stdlib.h>#include <math.h>

// Implementação Método Runge-Kutta de 4ord// Autor: Renan Sadao Kuroda Rodrigues// Disciplina: Métodos Numéricos em Fenômenos de Transporte

//Aproximação da solução do problema de valor inicial

// Entrar com as funções do sistema de equações.float f(int a, float i1, float i2, float tt) // Para adicionar mais uma equação, acrescente um float i3, i4,...,im;{

if (a==1) // Equação 1: u'_1=u1-u2+2 Condição Inicial: u_1(0)=-1 return i1-i2+2; else

if (a==2) // Equação 2: u'_2=-u1-u2+4*t Condição Inicial: u_2(0)=0 return -i1+i2+4*tt; }

int main() {

// n: número de iterações N// x[]: vetor para armazenar os valores de x// a e b: extremidades// h[]: tamanho do passo// alpha[]: condição inicial// m : número de equações do sistema de equações// w[m][n]: resultados//err[i]: erro absoluto

int n,i,j,m; float a,b,h; // Inserir os quantos pontos serão 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(" condições 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 aproximação da solução 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];

}

// Laço 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 número de equações 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 número de equações 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 número de equações 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 número de equações seja 3 o termo k4 ficará k4[j][i]=h*f(j,w[1][i],w[2][i],w[3][i],t[i]+h);

}

// Cálculo da aproximaçãow[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;

// Solução exata// u1(t)=-0.5*exp(2*t)+t^2+2t-0.5I_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.5I_2[i]=(0.5)*exp(2*t[i])+t[i]*t[i]-0.5;

// Cálculo do erro absolutoerr1[i]=I_1[i]-w[1][i];err2[i]=I_2[i]-w[2][i];

// Impressão dos resultadosprintf("%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 Discursões

Para a verificação do código foi escolhido um exercício do livro texto do curso, Analise Numérica, referente a utilização do método de Runge-Kutta de 4ª Ordem para sistema para encontrar aproximações das soluções do sistema de primeira ordem.

t u1 u2 w1 w2

0 -1 0 -1,000000 0,000000

0,1 -0,9007 0,120701 -0,900700 0,120700

0,2 -0,80591 0,285912 -0,805909 0,285909

0,3 -0,72106 0,501059 -0,721053 0,501053

0,4 -0,65277 0,77277 -0,652760 0,772760

0,5 -0,60914 1,109141 -0,609126 1,109126

0,6 -0,60006 1,520058 -0,600036 1,520036

0,7 -0,6376 2,0176 -0,637568 2,017568

0,8 -0,73652 2,616516 -0,736471 2,616471

0,9 -0,91482 3,334824 -0,914762 3,334762

N errro 1 errro 2

0 0,000000 0,000000

1 -0,000001 0,000001

2 -0,000003 0,000003

3 -0,000006 0,000006

4 -0,000010 0,000010

5 -0,000015 0,000015

6 -0,000022 0,000022

7 -0,000032 0,000032

8 -0,000045 0,000045

9 -0,000061 0,000061

6. Conclusão

O método de Runge-Kutta se demonstrou novamente ter uma boa aproximação da solução real. Como já esperado a medida que aumentasse o tempo, o erro de truncamento do método começa a aumentar. Entretanto, se aumentar o valor do passo h, a propagação do erro tende a diminuir.

7. Referência[1] - Burden, Richard L. and Faires, J.Doulas - Analise numérica – tradução 8aed norte americana. Ed Cengage Learning.

[2] Guidi, Leonardo F. – Material Gradução Página da disciplina "Noções de Cálculo Numérico" MAT01186 (http://www.mat.ufrgs.br/~guidi/grad/MAT01169/calculo_numerico.pdf) – Acessado em 22/03/2015

[3] Rigo, Giancarlo and Manzo, Rafael Reggiani - Implementação do Método de Integração NuméricaRunge-Kutta em GPGPU para Aplicações Científicas – (http://bcc.ime.usp.br/principal/tccs/2012/giancarlo+rafael/documentacao/monografia.pdf) acessado em 02/06/2015