Os 2 Ordem Mtodo de Runge-Kutta

nd

http://www.swarthmore.edu/NatSci/echeeve1/Ref/NumericInt/RK2.html Claramente, h um trade-off entre a preciso ea complexidade dos clculo que depende muito do valor escolhido para h. Em geral, como h diminui o clculo leva mais tempo, mas mais preciso. No entanto, se h diminuio muito ligeira do arredondamento que ocorre no computador (porque no pode representam nmeros reais exatamente) comea a acumular o suficiente para causar erros significativos. Para muitos sistemas de ordem superior, muito difcil fazer a aproximao de Euler eficaz. Por esta razo, mais precisa e mais elaboradas tcnicas foram desenvolvidas. Ns discutir os mtodos desenvolvidos por dois matemticos, Runge e Kutta, perto da incio do sculo 20. As tcnicas, apropriadamente, so chamados os mtodos de Runge-Kutta. Os 2 ordem de Runge-Kutta (RK2) mtodo mais facilmente entendido como um refinamento do mtodo de Euler. mostrado graficamente abaixo.
nd

Essa tcnica funciona atravs do mtodo de Euler para usar a derivada de y (t) em to (O que chamamos de k1). Usamos k1 para obter uma estimativa inicial para y (to+ H) marcado y * (to+ H). De * y (to+ H), podemos obter uma estimativa para a derivada de y (t) em to+ H, que chamaremos de k2. Em seguida, usamos a mdia desses dois derivados, k3, para chegar a nossa estimativa final de y (to+ H) rotulados * y '(to+ H). Isto chamado um mtodo de segunda ordem, pois os resultados acaba por coincidir com a srie de Taylor para dois mandatos. Existe tambm um mtodo de 4 ordem que aquele que usa Matlab : O mtodo RK2 atos para aumentar a preciso, obtendo uma mais acurada estimativa para a inclinao durante o intervalo. O mtodo de Euler usa a derivada no y (to) Para gerar um valor aproximado de y (to+h). Olhando para a figura voc pode ver que o uso de k tende a superestimar o valor de y (to+h). Usando o valor do clculo derivada em to+h, K , Tende a subestime o valor de y (to+h). Uma funo que cncava para cima faria o oposto. Pela mdia das duas vertentes obtemos uma estimativa para y (to+h) que melhor do que qualquer estimativa sozinho - este o corao de todos os Runge-Kutta mtodos.
1 2

Algoritmicamente podemos descrever cada passo do caminho essa RK2. 1) Iniciando no tempo to, Vamos to= To. 2) No tempo to, Encontrar a derivada de y (t) e chamam isso de k (Eq. 1).
1

3) Encontrar um valor inicial para y * (to+ H) usando a frmula de Euler (eq.2)

4) De * y (to+ H) estimativa do derivada de y (t) em to+ H, e chamam isso de k (Eq. 1).

2

5) Obtenha um novo valor para y * (to+ H) com base na mdia dos valores de k ek .
1 2

6) Deixe-y (to) * = Y '(to+ H) e to= To+ H . 7) Repita os passos 2 a 6 at terminar.

Exemplo de Numrica (primeira equao diferencial de ordem de Runge-Kutta)

Agora vamos percorrer o mesmo exemplo que usamos com o Euler mtodo:

Primeira Etapa Time Vamos usar h = 0.1 * Para encontrar y (to+ H) = y * (h) (desde to= 0) Calculamos primeiro a derivada (etapa 2, De cima para baixo):

Em seguida, encontrar a soluo aproximada aps o intervalo de tempo (etapa 3, De cima para baixo):

Em seguida, usamos isso para encontrar o valor de k2 (Etapa 4, A partir de acima):

Use k1 e k2 para encontrar * y '(to+ H) (passo 5, A partir de acima)

Nossa soluo aproximada de 1,04, o soluo exata de 1,04. Note que este muito melhor do que a aproximao de 1,1 obtida com o mtodo de Euler Subsequentes passos de tempo O procedimento repetido para os perodos subseqentes. Resultados A tabela abaixo mostra os resultados da segunda ordem de Runge-Kutta aproximaes, bem como a soluo exata at 4 segundos. Voc pode ver melhor que o algoritmo de Runge-Kutta ainda mais preciso em h = 0,1 do que o mtodo de Euler h = 0,01. Aqui est um link para cdigo Matlab e C cdigo, Que realiza a aproximao.
t t t t t t 1,0000, 1,0413, 1,0018, 0,9202, 0,8205, 0,7167, . . . t = 3,900, y (t) = 0,0010, t = 4,000, y (t) = 0,0008, = = = = = = 0,000, 0,100, 0,200, 0,300, 0,400, 0,500, y y y y y y (t) (t) (t) (t) (t) (t) = = = = = = y y y y y y '* '* '* '* '* '* (t) (t) (t) (t) (t) (t) = = = = = = 1,0000 1,0405 1,0011 0,9200 0,8208 0,7176

y '* (t) = 0,0011 y '* (t) = 0,0009

TheRunge de Kutta, Mtodo de Equaes Diferenciais Ordem Superior

O mtodo Runge-Kutta facilmente adaptado ao diferencial de ordem superior equaes exatamente no mesma forma como os mtodos de Euler.

Mtodos de Runge Kutta de Ordem Superiormtodos de ordem superior Runge-Kutta existir, com os mais comumente utilizados sendo a quarta ordem de Runge-Kutta. Estes mtodos correspondem aos termos de ordem superior mais no Taylor aproximao srie, tendo uma mdia ponderadas dos diversos derivados aproximaes (a segunda ordem de Runge-Kutta usa duas aproximaes, K1 e K2). Matlab utiliza uma quarta ordem de Runge-Kutta, que tambm varia o tamanho do passo h. O valor de h aumentada sempre que possvel, para acelerar o clculo, e diminuiu quando necessrio, para manter a preciso.

Iintegrao por Runge-Kutta para um problema de primeira ordem:

MatLab
h=0.1; t=0:h:4; %h is the time step. %initialize time variable. %initial condition (same for approximation).

yPrimeStar(1)=1.0;

for i=1:length(t)-1,

%Set up "for" loop.

k1=3*exp(-4*t(i))-2*yPrimeStar(i);%Calculate derivative; ystar=yPrimeStar(i)+h*k1; k2=3*exp(-4*(t(i)+h))-2*ystar; %Estimate new value of y*(to+h). %Calculate derivative at end of step. %Estimate new value of y'*(to+h).

yPrimeStar(i+1)=yPrimeStar(i)+h*(k1+k2)/2; end

Cdigo em C
/* Programa RK2.c wrtitten por Erik Cheever Aproxima a soluo de uma equao diferencial de primeira ordem usando uma Runge-Kutta segunda ordem O problema a ser resolvido :

y'(t)+2*y(t)=3*exp(-4*t)

Nota: este problema tem uma soluo conhecida exata

y(t)=2.5*exp(-2*t)-1.5*exp(-4*t)

Este programa muito geral, facilmente adaptado para praticamente qualquer problema

mudando a rotina "CalcDerivs" que calcula os derivados, e o valor de NDERIVS. */

#include <stdlib.h> #include <stdio.h> #include <math.h> //I/O biblioteca //Math biblioteca

#defineNDERIVS

//nr de derivativos

void CalcDerivs(int numDerivs, float *x, float t, float h, float *k1, float *k2);

int main();

void CalcDerivs(int numDerivs, float *x, float t, float h, float *k1, float *k2) {

// NumDerivs o nmero de derivados que devem ser calculados // X // T // H // K1 // K2 um array contendo as variveis de estado o tempo o passo de tempo a matriz dos derivados calculado (no incio do passo detempo). a matriz dos derivados de clculo (no final do passo detempo).

float xapprox[NDERIVS]; // aprox intermediaria do estado das variveis. int i; //loop contador

k1[0]=3*exp(-4*t)-2*x[0]; //Calcula os derivativos no final do passo do tempo.

for(i=0;i<NDERIVS;i++) {//variveis de estado aproximado no final do passo do tempo. xapprox[i]=x[i]+h*k1[i]; }

k2[0]=3*exp(-4*(t+h))-2*xapprox[0];

//Calcula a derivative at end of time step.

int main() {

float yexact, ystar; float x[NDERIVS];

//Os valores exatos e aproximados de y //Matrizes para manter as variveis de estado.

float k1[NDERIVS], k2[NDERIVS]; //Matrizes para manter as variveis de estado. float h=0.1, t=0.0, tmax=4.0; //tamanho / Passo, tempo, tempo final. int i; //loop contador

printf("\nResolucao de EDO pelo metodo de RK2 \n\n");

x[0]=1; ystar=x[0];

//Condies iniciais. //sada a nossa varivel de estado s neste caso.

printf("Coordenadas do SAVAR por Ruge Kutta, considerando a velocidade do alvo.\n\n");

for (t=0;t<tmax;t=t+h){

//loop para iterar atravs do tempo.

CalcDerivs(NDERIVS, x, t, h, k1, k2); ystar=x[0]; //Pega aproximadamente exato e y.

yexact=2.5*exp(-2*t)-1.5*exp(-4*t);

//Imprime o resultado. printf("t=%4.2f, yexact=%6.4f, ystar=%6.4f\n",t,yexact,ystar); for(i=0;i<NDERIVS;i++) { //atualiza o estado das variveis. x[i]=x[i]+h*(k1[i]+k2[i])/2.0; } } printf("\nCalculo realizado.\n"); system("PAUSE"); return 0; }