capítulo 1. introdução - página do câmpus de rio … capítulo 1. introdução 1.1. teoremas e...

6

Capítulo 1. Introdução 1.1. Teoremas e Comentários

Definição1.0.0 : Uma função f(x,y) satisfaz a condição de Lipschitz na variável y sobre o

conjunto D⊂ ℜ2, se existe uma constante L>0, tal que é válida a propriedade:

|f(t,y1) - f(t,y2)|≤ L | y1 -y2|

sempre (t,y1), (t,y2)∈ D. L é chamada constante de Lipschitz para f.

Lema1.0.1 : Sejam s e t numeros reais positivos e {ai } é uma seqüência

que satisfaz a0 >= -t/s e

ai+1 <=(1+s) ai + t para i =0,1,2, ..., k

então

ai+1 <= e (i+1)s (t/s + a0 ) - t/s

Usando o lema anteriormente citado vamos mostrar a prova do

teorema 1.0.2 que nos diz que:

Teorema 1.0.2 : Suponha que f é uma função contínua e satisfaz a condição

de Lipschitz com constante L no conjunto D = {(t,y) | a<= t <=b ,- ∞< y < ∞

} e que a constante M existe com a propriedade | y’’(t) | <= M para todo t ε

[a,b]

Consideramos também y(t) como uma única solução para o problema

de valor inicial

7

y’ = f(t,y) a<= t <=b , y(a) = α

Então

|y(ti) -wi | <= hM/2L [e L(ti - α) -1 ] para cada i =0,1,2,...,N

PROVA:

Quando i= 0 o resultado é claramente verdadeiro desde que y(t0) = w0 =

α

Utilizando a equação mais geral para o método de EULER ,

para i =0,1,2,...,N, temos:

y(ti+1)=y(ti) + hf(ti,y(ti)) + h2/2 *y’’(ξi). (1.0.3)

O truncando o termo de 2a. ordem (com isso introduz um “pequeno”

erro) e fazendo wi equivalente a y(ti) então a equação 1.0.3 fica

wo = α

wi+1 = wi + h f (ti , wi) (1.0.4 )

Usaremos a notação yi = y(ti) e yi+1 = y (ti+1) .Subtraindo (1.0.3 ) de

(1.0.4) e usando a notação nova temos:

yi+1 - wi+1 = yi - wi + h[f(ti, yi) - f(ti, wi )] + h2/2 *y’’(ξi).

Aplicando o módulo temos:

|yi+1 - wi+1 |= |yi - wi |+ h|f(ti, yi) - f(ti, wi )| + h2/2 *|y’’(ξi)|. (1.0.2)

Como a função satisfaz a condição de Lipschitz então

9

O algoritmo Range Kutta de quarta ordem para sistemas de equações diferenciais

de primeira ordem trabalha da mesma maneira que o Range Kutta tradicional de quarta

ordem , só com algumas alterações .

Em cada um dos algoritmos anteriormente citados (rk4 tradicional e rk4 para

sistemas )

existem condições iniciais comuns que o usuário deverá entrar como por exemplo:

• Os valores de a e b sendo que a diferença b-a representará o intervalo onde a variável

t irá variar.

• A variável N que dividirá o intervalo anteriormente citado em N partes iguais .

obs: O valor (b-a)/N nos dará o valor h.

Outras condições iniciais do rk4 para sistemas devem ser entradas, só que estas são

diferentes do rk4 tradiconal:

• Enquanto para o rk4 tradicional existe apenas uma equação diferencial,para o rk4 de

sistemas existem m equações.

• Enquanto para o rk4 tradicional existe apenas uma condição inicial , para o rk4 de

sistemas existem m condições iniciais.

Após esta fase de inicialização de variáveis, o algoritmo atribui wj =αj onde αj são as

condições iniciais e j varia de 1 até o número de equações diferenciais de primeira ordem

entradas.

Depois disso , o algoritmo entra num laço que percorre todo o intervalo b-a ,ou seja, a

variavel t comecará com o valor a e a cada passo será acrescida a ela o valor do passo h.

10

Dentro do laço anterior serão calculados os vários k1,k2,k3,k4 para cada equação

diferencial dada.Assim,cada equação terá seus próprios k’s em cada passo.

Uma importante observação é que para o cálculo de um ki+1 é necessário o valor do ki

anterior .

De posse dos valores de k’s de todas as equações a cada passo calcula-se os valores

de w’s.Assim, temos valores intermediários de w’s a cada passo.

O algoritmo tem sua parada determinada quando o valor de t chegar ao extremo

superior do intervalo ,ou seja, b .

1.3. Métodos de Passos Variáveis A técnica previsor-corretor sempre gera duas aproximações para cada passo,

então ela é a candidata natural para adaptação de controle de erros.

Para demonstrar o procedimento para controle de erro, foi construído um método

previsor-corretor com tamanho de passos variáveis.]

Este algoritmo, a princípio, resolve a equação utilizando o Runge Kutta de Quarta

ordem para que a partir de sua resposta, o algoritmo faça o refinamento do erro cometido.

A cada passo será calculado o valor previsto e o valor corrigido. O cálculo do

erro depende diretamente desses dois fatores. Se esse erro for muito grande, ou

seja,maior que a tolerância desejada, então é realizado mudanças em algumas variáveis

para que o erro no próximo passo reduza. A cada passo , a precisão tende a aumentar.

Com o cálculo do valor corrigido através do uso valor previsto, obtém-se um valor que

mais se aproxima da resposta.

11

A cada passo o RK4 é chamado, mas com uma diferença. Substitue um ponto em

relação a última chamada, sendo que este ponto é o calculado através do método

previsor-corretor, ou seja, a tendência é que o novo resultado do RK4 seja um pouco

mais satisfatório, e que o cálculo do erro dimunua. Este processo continua até que o erro

seja muito pequeno, ou seja, até que se consiga refiná-lo.

1.4. Estabilidade Um método estável é aquele que depende continuamente dos estados iniciais, ou

seja, são estáveis se quando pequenas mudanças nas aproximações subsequentes.

Definição 1: Um método de equação diferencial de um passo com erro local σi(h) no i-

ésimo passo é dito ser consistente com a equação diferencial se

Lim max | σi(h) | = 0 h->0 1<i<N Definição 2: Um método de equação diferencial de 1 passo é dito ser convergente com

a respectiva equação diferencial se

Lim max | ωi - y(ti) | = 0 h->0 1<i<N onde yi = y(ti) denota o valor exato da solução da equação diferencial e ωi è a

aproximação obtida do método de diferença no i-ésimo passo.

Teorema : Suponha o problema de de valor inicial y’ = f(t,y), a≤ t ≤ b , y(a)=α

12

é aproximado por um método de um passo da forma

W0 = α

Wi+1 = Wi + hφ(ti,Wi,h)

Suponha também que um número h0 > 0 existe φ(t,W,h) é contínu e satisfaz a

condição de Lipschitz* na variável com constante Lipschitz L sobre o conjunto D={

(t,W,h) | a≤ t ≤ b, -∝< W< ∝ , 0≤ h≤h0 }. Então

1) o método é estável;

2) o método é convergente, se e somente se é consistente; que é se e somente se

φ(t,W,h) = f(t,y), para todo a≤ t ≤ b;

3) se para cada i=1,2,3...N, o erro local σi(h) satisfaz |σi(h)| ≤ σ(h), sempre que 0≤ h≤h0

então

| y(ti) - ωi | ≤ ( σ(h)/L ) exp(L(ti - a))

1.5. Métodos de Múltiplos Passos Estes métodos, assim como a família Runge-Kutta, também são derivados a

partir de séries de Taylor.

O que caracteriza estes métodos é que eles usam informações sobre a solução em

mais de um ponto.

13

Supondo inicialmente conhecida as aproximações para y(x) em x0, x1, ... , xn e

que xi +1 - xi =h, queremos aproximar a solução da equação diferencial y’=f(x,y) de xn até

xn + 1

xn + 1 xn + 1 � y’ dx = � f(x,y(x)) dx xn xn integrando o 1a. membro, xn + 1 y(xn + 1) - y(xn) = � f(x,y(x)) dx xn O problema agora reside então em aproximar uma solução para a integral acima, para

encontrar uma solução aproximada. Antes de prosseguir a discussão é importante ter em

mente dois conceitos:

1.5.0 MÉTODO EXPLÍCITO: Os métodos desta classe são obtidos quando trabalhamos

com xn,xn-1,...,xn-m, ou seja o cálculo de yn + 1 tem forma explícita em função dos

outros (para calcular yn + 1, uso somente yn, yn-1, yn-2, yn-3, por exemplo se o método

escolhido for de 3 passos).

1.5.1 MÉTODO ÍMPLICITO: Nestes tipos de métodos na fórmula que calcula yn + 1,

deve-se entrar com o valor de yn + 1, ou seja a fórmula não é explícita, o que gera a

grande dificuldade destes destes métodos.

Para uma melhor compreensão destes métodos acompanhe alguns exemplos da família Adams de múltlipos passos, seguidos logo abaixo de um breve comentário, lembrando ao leitor que uma reflexão mais profunda sobre estes métodos é recomendada.

1.6. Métodos de Adams-Bashforth 1.6.0 Método de Adams-Bashforth de 2 passos (2a. ordem)

w0=α , w1= α1

14

wi+1 =wi + h/2[3f(ti,wi)-f(ti-1,wi-1)

1.6.1 Método de Adams-Bashforth de 3 passos (3a. ordem)

w0=α , w1= α1, w2= α2

wi+1 =wi + h/12[23f(ti,wi)-16f(ti-1,wi-1) +5 f(ti-2,wi-2)]


w0=α , w1= α1, w2= α2 , w3= α3

wi+1 =wi + h/24[55f(ti,wi)-59f(ti-1,wi-1) +37f(ti-2,wi-2) - 9 f(ti-3,wi-3)]


w0=α , w1= α1, w2= α2 , w3= α3 , w4= α4

wi+1 =wi + h/720[1901f(ti,wi)-2774f(ti-1,wi-1) +2616(ti-2,wi-2) - 1274 f(ti-3,wi-3)

+251 f(ti-4,wi-4)]

1.7 Métodos de Adams-Moulton 1.7.0Método de Adams-Moulton de 2 passos (2a. ordem)

w0=α , w1= α1

wi+1 =wi + h/12[5f(ti+1,wi+1)+ 8(ti,wi) -(ti-1,wi-1) ]

1.7.1 Método de Adams-Moulton de 3 passos (3a. ordem)

w0=α , w1= α1, w2= α2

wi+1 =wi + h/24[9f(ti+1,wi+1) + 19f(ti,wi) - 5 (ti-1,wi-1) + f(ti-2,wi-2)]

1.7.2 Método de Adams-Moulton de 4 passos (4a. ordem)

w0=α , w1= α1, w2= α2 , w3= α3

15

wi+1 =wi + h/720[251f(ti+1,wi+1) + 646f(ti,wi) - 264 (ti-1,wi-1) + 106f(ti-2,wi-2) - 19

f(ti-3,wi-3)]

1.8. Comentário Os métodos de Adams-B.são todos métodos explícitos e não auto-inicializáveis,

sendo preciso de alguma forma (usando R.K, por exemplo), calcular os m-primeiros wi’s,

quando se usa um método Adams-B de m-passos.Para calcular wj estes métodos usam os

valores anteriores de wj-1,wj-2,...,wo. Então o esforço computacional nestes tipos de

algoritmos se residem em apenas calcular o valor da função em cada ponto. Já os

métodos de Adams-M. se caracterizam por serem fechados (implícitos). A grande

dificuldade deste método é usar uma fórmula implícita , ou seja para calcular a

aproximação em um ponto, a fórmula empregada já usa este valor, o que torna o

problema computacionalmente inviável, pois não se consegue uma recurssividade. A

maneira encontrada para contornar este problema é por exemplo usar um método

explícito para auxiliar.

De maneira geral o módulo do erro para Adams-M. é menor que Adams-B. , mas

depende fundamentalmente se o problema estar bem condicionado e a escolha do melhor

método para aquele problema.

1.9. Métodos Previsor-Corretor Este método usa a fórmula explícita e implícita para aproximar uma solução. A

idéia primeira era usar a fórmula implícita para aproximar uma solução, mas isso esbarra

no problema acima mencionado, ou seja, para calcular yn + 1 uso o valor de xn + 1. Para

16

contornar esta situação obtém-se o valor de yn + 1, através de uma aproximação por um

método explícito (convenientemente escolhido). De posse desta aproximação posso

agora usar a fórmula impícita, substituindo nesta este valor e encontrando assim uma

nova aproximação muito melhor para yn + 1.

A forma explícita primeiramente usada é chamada de um previsor; e a forma

implícita é chamada de corretor. Daí o nome previsor-corretor.

Quando o previsor e o corretor usado são da mesma ordem e a escolha do h é

conveniente a precisão de algoritmo é muito boa.

O esforço computacional demandado é dobrado em relação aos métodos acima

apresentados , pois para calcular o valor duas vezes em em cada ponto: o primeiro

calculo estima o valor, o segundo corrige este valor.

1.10. Modelo para a dinâmica de populações (presa-predador) Um modelo muito simples é aquele em que o crescimento (ou decaimento) da

população é proporcional ao número de membros da mesma. Escrevendo na forma de

equação diferencial ordinária (edo):

dNdt

(t) = rN(t), N(0) = No

sendo: dN/dt a variação da população em relação ao tempo

No a população inicial

17

R a taxa de variação

Porém, este modelo está longe da realidade, pois sabemos que, após um certo

período de tempo, a população será tão grande que surgirão problemas (limitação de

alimentos, espaço etc).

Surgiu então a equação logística

dNdt

(t) = f(N) N(t), N(0) = No

na qual a taxa de variação depende da população e é dada por f(N). Vamos construir uma

função f(N) que tenha as propriedades desejadas:

a) a população cresce exponencialmente quando ela for pequena;

b) o crescimento desacelera conforme a população vai crescendo;

c) observamos mortalidade quando a população for muito grande. Matematicamente,

escrevemos isso como f(n) < 0 quando N >> 1.

Um modelo seria a função:

f(N) = r [1 - (N/M)]

sendo: M o ponto a partir do qual observamos a mortalidade de indivíduos

Um modelo um pouco mais complexo é dado a seguir:

dNdt

(t) = { -r [ 1 - (N/M1)] [ 1 - (N/M2)] } N(t), N(0) = No

18

Finalmente, estudaremos um modelo no qual duas populações competem para

sobreviver. Sejam N1(t) e N2(t) a população de presas e predadores, respectivamente.

Suporemos que as presas tem um suprimento abundante de alimento, enquanto que o

predador alimenta-se das presas. Vamos também assumir que um biólogo nos forneceu as

seguintes hipóteses(todas as constantes ki, i = 1, 2, 3, 4 dadas abaixo são positivas):

1.10.0 PRESA: Taxa de natalidade: proporcional à população naquele instante: k1N1(t) Taxa de mortalidade: depende da população das presas assim como dos predadores. Por simplicidade, adotaremos a expressão: -k2N1(t)N2(t) • PREDADOR: Taxa de natalidade: proporcional à população de predadores assim como a das presas:

k3N1(t)N2(t)

Taxa de mortalidade: proporcional à população de predadores: -k4N2(t)

Colocando essas informações na forma de edo’s, temos o sistema

dNdt

1 = k1N1 - k2N1N2

dNdt

2 = k3N1N2 - k4N2

com N1(0) = N10 e N2(0) = N2

0.

1.11. Exercícios e Programas

• Exercício 4.1 da apostila “Curso Métodos Numéricos - Notas de Aula”

19

• Programa desenvolvido em Borland C++ para a solução deste problema, sendo que o

programa abaixo é genérico possuindo a opção de resolução através dos métodos de Euler

(Runge-Kutta 1a. ordem), Rungr-Kutta 2a. ordem e Runge-Kutta de 4a. ordem

/* Programa para a resolucao de equacoes diferenciais,

atraves dos metodos :

- Runge-Kutta 1a. ordem (Euler)

- Runge-Kutta 2a. ordem

- Runge-Kutta 4a. ordem

#include<stdio.h>

#include<stdlib.h>

#include<conio.h>

#include<math.h>

int a,b,n,i;

float h,t0,t[11],w1[11],w4[11],w2[11],ya,g1,g2,k1,k2,k3,k4;

char opc;

FILE *runge1,*runge2,*runge4;

float function(float x,float y)

{

return(x-y+2);

}

void main(void)

20

{

clrscr();

printf("Escolha o metodo que deseja usar : \n");

printf("1->para Runge-Kutta1;2->para Runge-Kutta2;3->para Runge-Kutta4\n");

scanf("%s",&opc);

printf("\nEntre com o numero de iteracoes : ");

scanf("%i",&n);

printf("\nEntre com o valor inicial y(0) : ");

scanf("%f",&w1[0]);

printf("\nEntre com o inicio do intervalo : ");

scanf("%i",&a);

printf("\nEntre com o final do intervalo : ");

scanf("%i",&b);

printf("\nEntre com o passo de integracao : ");

scanf("%f",&h);

w2[0] = w1[0];

w4[0] = w1[0];

switch (opc)

{

case '1':{

runge1=fopen("rk1.dat","wt");

t[0]=a;

fprintf(runge1,"%2.4f,%2.4f\n",t[0],w1[0]);

21

for (i=1;i<=n;i++)

{

w1[i]=w1[i-1]+h*function(i-1,w1[i-1]);

t[i]=t[i-1]+h;

fprintf(runge1,"%2.4f,%2.4f\n",t[i],w1[i]);

}

fclose(runge1);

for(i=0;i<=n;i++)

printf("%2.4f\n",w1[i]);

break;

}

case '2':{


t[0]=a;


for (i=1;i<=n;i++)

{

g1=h*function(i-1,w2[i-1]);

g2=h*function(w2[i-1]+g1,w2[i-1]);

w2[i]=w2[i-1]+0.5*(g1+g2);

t[i]=t[i-1]+h;


22

}

fclose(runge2);

for(i=0;i<=n;i++)


break;

}

case '3':{ //open1


t[0]=a;


for(i=1;i<=n;i++)

{ //open2

k1=h*function(i-1,w4[i-1]);

k2=h*function(w4[i-1]+k1/2,w4[i-1]);

k3=h*function(w4[i-1]+k2/2,w4[i-1]);

k4=h*function(w4[i-1]+k3,w4[i-1]);

w4[i]=w4[i-1]+(k1+2*k2+2*k3+k4)/6;

t[i]=t[i-1]+h;



}

fclose(runge4);

23

} //close1

}

}

• Gráfico de saída do programa em Borland C++ para h = 0.1 e Método Runge-Kutta 1a.

Ordem (Euler) (plotado no GRAPHER)

1.800

1.900

2.000

2.100

2.200

2.300

2.400

• Gráfico de saída do programa em Borland C++ para h = 0.01 e Método Runge-

Kutta 1a. Ordem (Euler) (plotado no GRAPHER)

24

1.800

1.900

2.000

2.100

2.200

2.300

2.400

• Gráfico de saída do programa em Borland C++ para h = 0.001 e Método Runge-Kutta 1a. Ordem (Euler) (plotado no GRAPHER)

1.800

1.900

2.000

2.100

2.200

2.300

2.400

• Gráfico de saída do programa em Borland C++ para h = 0.1 e Método Runge- Kutta 2a. Ordem (plotado no GRAPHER)

25

1.800

1.900

2.000

2.100

2.200

2.300

2.400

• Gráfico de saída do programa em Borland C++ para h = 0.01 e Método Runge-Kutta 2a. Ordem (plotado no GRAPHER)

1.800

1.900

2.000

2.100

2.200

2.300

2.400


26

1.800

1.900

2.000

2.100

2.200

2.300

2.400

• Gráfico de saída do programa em Borland C++ para h = 0.1 e Método Runge-

Kutta 4a. Ordem (plotado no GRAPHER)

1.800

1.900

2.000

2.100

2.200

2.300

2.400

• Gráfico de saída do programa em Borland C++ para h = 0.01 e Método Runge- Kutta 4a. Ordem (plotado no GRAPHER)

27

1.800

1.900

2.000

2.100

2.200

2.300

2.400


1.800

1.900

2.000

2.100

2.200

2.300

2.400

• Esquema SIMULINK para a solução da equação diferencial

28

+-+

Somatorio das variaveis

2Constante

ySaida para y1/s

Integracao paraobter y

xSaida para x

Grafico de X/Y

[T,U]

Matriz contendoos valores de x

Gr

Gráfico de saída do esquema SIMULINK para h=0.1.

0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1

1.5

1.6

1.7

1.8

1.9

2

2.1

2.2

2.3

2.4

2.5

X Axis

Y A

xis

X Y Plot

• Gráfico de saída do esquema SIMULINK para h = 0.01

29

0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1

1.5

1.6

1.7

1.8

1.9

2

2.1

2.2

2.3

2.4

2.5

X Axis

Y A

xis

X Y Plot

• Gráfico de saída do esquema SIMULINK para h = 0.001

0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 11.5

1.6

1.7

1.8

1.9

2

2.1

2.2

2.3

2.4

2.5

X Axis

Y A

xis

X Y Plot


• Programa desenvolvido em Borland C++ para a solução deste problema

/* Exercicio 2 : RK4

Linguagem : Borland C++ */

30

#include<iostream.h>

#include<stdio.h>

#include<math.h>

#include<conio.h>

double f1(double,double,double);

double f2(double,double,double);

//double f3(double,double,double);

float x0,y0,xn,n,x,h;

int i,j;

float y[3];

float k[4][3];

float w[4]; //valores inicias das equa‡äes diferenciais

int t;

void main()

{

clrscr();

FILE *arq1,*arq2,*arq3;

printf("Entre com o valor de x(0)=a : ");

scanf("%f",&x0);

printf("Entre com o valor de y1(0) : ");

31

scanf("%f",&w[1]);


scanf("%f",&w[2]);


scanf("%f",&w[3]);

printf("Entre com o valor de x(n)=b : ");

scanf("%f",&xn);

printf("Entre com o valor de n : ");

scanf("%f",&n);

h=(xn-x0)/n;

x=x0;

//double n = 0;

arq1= fopen("V'xt.DAT","wt");

arq2= fopen("Vxt.DAT","wt");

arq3= fopen("VxV'.DAT","wt");

for (i=0;i<n;i++)

{

// 1§ for

k[1][1] =h*f1(x,w[1],w[2]);

k[1][2] =h*f2(x,w[1],w[2]);

// k[1][3] =h*f3(x,w[1],w[2],w[3]);

// 2§ for

32

k[2][1] =h*f1(x+h/2,w[1]+k[1][1]/2,w[2]+k[1][2]/2);

k[2][2] =h*f2(x+h/2,w[1]+k[1][1]/2,w[2]+k[1][2]/2);

// k[2][3]

=h*f3(x+h/2,w[1]+k[1][1]/2,w[2]+k[1][2]/2,w[3]+k[1][3]/2);

// 3§ for

k[3][1] =h*f1(x+h/2,w[1]+k[2][1]/2,w[2]+k[2][2]/2);

k[3][2] =h*f2(x+h/2,w[1]+k[2][1]/2,w[2]+k[2][2]/2);

// k[3][3]

=h*f3(x+h/2,w[1]+k[2][1]/2,w[2]+k[2][2]/2,w[3]+k[2][3]/2);

// 4§ for

k[4][1] =h*f1(x+h/2,w[1]+k[3][1]/2,w[2]+k[3][2]/2);

k[4][2] =h*f2(x+h/2,w[1]+k[3][1]/2,w[2]+k[3][2]/2);

// k[4][3]

=h*f3(x+h/2,w[1]+k[3][1]/2,w[2]+k[3][2]/2,w[3]+k[3][3]/2);

// 5§ for

w[1]=w[1] + (k[1][1] +2*k[2][1] +2*k[3][1] +k[4][1])/6;

w[2]=w[2] + (k[1][2] +2*k[2][2] +2*k[3][2] +k[4][2])/6;

// w[3]=w[3] + (k[1][3] +2*k[2][3] +2*k[3][3] +k[4][3])/6;

x=x0 +i*h;

printf("\nValores de x,w[1],w[2]:

:%3.3f,%3.3f,%3.3f",x,w[1],w[2]);

fprintf(arq1,"%3.3f,%3.3f\n",x,w[1]);

fprintf(arq2,"%3.3f,%3.3f\n",x,w[2]);

33

fprintf(arq3,"%3.3f,%3.3f\n",w[1],w[2]);

}

getch();

fclose(arq1);

fclose(arq2);

fclose(arq3);

}

double f1(double x,double y1,double y2)

{

return(y2);

}

double f2(double x,double y1,double y2)

{

return(((-1/3)*y1-4*y2)/5);

}

/*double f1(double x,double y1,double y2)

{

return(((-1/3)*y1-4*y2)/5);

}*/

• Gráfico de saída do programa em Borland C++ para h = 0.001 (plotado no

GRAPHER)

34

Gráfico da Aceleração

0 50 100 150 200-0.5

0

0.5

Gráfico da Velocidade

0 50 100 150 200-1.5

-1

-0.5

0

0.5

1

1.5

2

Gráfico da Velocidade x Aceleração

35

-2 -1 0 1 2-2

-1

0

1

2

3

Esquema SIMULINK para a solução da equação diferencial

---

Sum

[T,U]

FromWorkspace

1/sIntegrator

0.

Gain

1/sIntegrator1

4

Gain2

0.

Gain1

V x V`

du/dtDerivative

velocidade

f(u)Fcn

Aceleracao1

Gráficos de saída do esquema SIMULINK para h = 0.001 Gráfico da Aceleração

36

0 50 100 150 200-0.5

0

0.5

Time (second) Gráfico daVelocidade

0 50 100 150 200

-1.5

-1

-0.5

0

0.5

1

1.5

2

Time (second) Gráfico da Velocidade x Aceleração

37

-2 -1 0 1 2-2

-1

0

1

2

3

X Axis

Y A

xis

X Y Plot


Programa desenvolvido em Borland C++ para a solução deste problema.

/* Exercicio 3 : RK4

Linguagem : Borland C++ */

#include<iostream.h>

#include<stdio.h>

#include<math.h>

#include<conio.h>

double f1(double,double,double,double);

double f2(double,double,double,double);

//double f3(double,double,double,double);

float x0,y0,xn,n,x,h;

int i,j;

38

float y[3];

float k[4][3];

float w[4]; //valores inicias das equa‡äes diferenciais

int t;

void main()

{

clrscr();

FILE *arq1,*arq2,*arq3;

printf("Entre com o valor de x(0)=a : ");

scanf("%f",&x0);


scanf("%f",&w[1]);


scanf("%f",&w[2]);


scanf("%f",&w[3]);

printf("Entre com o valor de x(n)=b : ");

scanf("%f",&xn);

printf("Entre com o valor de n : ");

scanf("%f",&n);

h=(xn-x0)/n;

x=x0;

//double n = 0;

39

arq= fopen("DADOS."wt");

for (i=0;i<n;i++)

{

// 1§ for

k[1][1] =h*f1(x,w[1],w[2]);

k[1][2] =h*f2(x,w[1],w[2]);

k[1][3] =h*f3(x,w[1],w[2],w[3]);

// 2§ for

k[2][1] =h*f1(x+h/2,w[1]+k[1][1]/2,w[2]+k[1][2]/2);

k[2][2] =h*f2(x+h/2,w[1]+k[1][1]/2,w[2]+k[1][2]/2);

k[2][3]=h*f3(x+h/2,w[1]+k[1][1]/2,w[2]+k[1][2]/2,w[3]+k[1][3]/2);

// 3§ for

k[3][1] =h*f1(x+h/2,w[1]+k[2][1]/2,w[2]+k[2][2]/2);

k[3][2] =h*f2(x+h/2,w[1]+k[2][1]/2,w[2]+k[2][2]/2);

k[3][3]=h*f3(x+h/2,w[1]+k[2][1]/2,w[2]+k[2][2]/2,w[3]+k[2][3]/2);

// 4§ for

k[4][1] =h*f1(x+h/2,w[1]+k[3][1]/2,w[2]+k[3][2]/2);

k[4][2] =h*f2(x+h/2,w[1]+k[3][1]/2,w[2]+k[3][2]/2);

k[4][3] =h*f3(x+h/2,w[1]+k[3][1]/2,w[2]+k[3][2]/2,w[3]+k[3][3]/2);

// 5§ for

w[1]=w[1] + (k[1][1] +2*k[2][1] +2*k[3][1] +k[4][1])/6;

w[2]=w[2] + (k[1][2] +2*k[2][2] +2*k[3][2] +k[4][2])/6;

40

// w[3]=w[3] + (k[1][3] +2*k[2][3] +2*k[3][3] +k[4][3])/6;

x=x0 +i*h;

printf("\nValores de x,w[1],w[2]:

:%3.3f,%3.3f,%3.3f",x,w[1],w[2]);

fprintf(arq1,"%3.3f,%3.3f,%3.3f ,%3.3f \n",x,w[1],w[2],w[3]);

}

getch();

fclose(arq);

}

double f1(double x,double y1,double y2,double y3)

{

return(y2);

}

double f2(double x,double y1,double y2,double y3)

{

return(y3);

}

/*double f1(double x,double y1,double y2,double y3)

{

return(y2-y1*y1-2*y1-x);

}*/

41

• Gráfico de saída do programa em Borland C++ para h = 0.001 (onde a 1a., 2a. e

3a. curvas, rferem-se à y1[t], y2[t] e y3[t] respectivamente) . (plotado no

GRAPHER)

0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 20

0.5

1

1.5

2

2.5

3

3.5

4

4.5

5


[T,U]

FromWorkspace

++++

Sum

2

Gain

1/sIntegrator1

1/sIntegrator

1/sIntegrator2

*

Product

Mux Mux

Graph

• Gráficos de saída do esquema SIMULINK para h = 0.001 (onde a 1a., 2a. e 3a. curvas, rferem-se à y1[t], y2[t] e y3[t] respectivamente).

42

0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 20

0.5

1

1.5

2

2.5

3

3.5

4

4.5

5

Time (second)

• Exercício 1.a do Conjunto 5.1 da apostila “Initial-Value Problems for Ordinary Differential Equations”


1/sIntegrator

[T,U]

FromWorkspace

cos(u)Fcn

*

Product

Graph

youtTo Workspace

• Gráfico de saída dp esquema SIMULINK para h=0.001.

43

0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 10

0.5

1

1.5

2

2.5

3

3.5

4

4.5

5

Time (second)

• Exercício 1.b do Conjunto 5.1 da apostila “Initial-Value Problems for Ordinary Differential Equations”


1/sy

[T,U]

FromWorkspace exp(u)

funcao exponencial

*

Product22/u

funcao auxiliar++

Sum

Graph

*

Product1

u*ufuncao aux1

• Gráfico de saída dp esquema SIMULINK para h=0.001

44

1 1.2 1.4 1.6 1.8 2 2.2 2.4 2.6 2.8 3-5

-4

-3

-2

-1

0

1

2

3

4

5

Time (second)

• Exercício 1.d do Conjunto 5.1 da apostila “Initial-Value Problems for Ordinary Differential Equations” • Esquema SIMULINK para a solução da equação diferencial.

[T,U]

FromWorkspace

1/sIntegrator

4Constant

f(u)Fcn

*

Product*

Product1

Graph

• Gráfico de saída de esquema SIMULINK para h=0.001

45

0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1-5

-4

-3

-2

-1

0

1

2

3

4

5

Time (second) • Exercício 1.d do Conjunto 5.2 da apostila “Initial-Value Problems for Ordinary Differential Equations” Esquema SIMULINK para a solução da equação diferencial

f(u)sen(3*u)

f(u)cos(2*u)

[T,U]

FromWorkspace

++

Sum1/s

Integrator1Graph

• Gráfico de saída de esquema SIMULINK para h=0.25.

46

0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 10

0.5

1

1.5

2

2.5

3

Time (second)

• Exercício 5 do Conjunto 5.2 da apostila “Initial-Value Problems for Ordinary Differential Equations”


2/u2/u

f(u)exp(u)*(u*u)

[T,U]

FromWorkspace

*

Product++

Sum1/s

Integrator1Graph

• Gráfico de saída de esquema SIMULINK para h=0.1

47

1 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 20

2

4

6

8

10

12

14

16

18

20

Time (second)

Através do Método de Euler com um passo de 0.1, a solução obtida possui

um desvio de 21% de erro, sendo que o método do Runge-Kutta de 4a. Ordem é

superior na obtenção de soluções.

Item a) A solução apresentada para o método de Euler foi 15.3982,

enquanto que a solução real é 18.6831.

Item b) Com a solução para esses valores (y(1.04), y(1.55) e y(1.97)),

podemos observar que para valores pequenos, perto do inicial, a aproximação é

muito boa, enquanto que para valores próximos ao limite superior do intervalo, as

soluções são discrepantes. Vê-se que o erro introduzido cresce numa escala

exponencial.

Item c) Com o uso da fórmula abaixo

hm

| y(ti) - wi| <= [eL(ti-a) - 1] 2L

chegou a um valor para que o erro seja mínimo, tal que h = 0.001

48

• Programas, em Matlab, para o modelo presa-predador

%========================================

% programa runpop.m

% Programa para executar e plotar os

% resultados do problema predador-presa

% =======================================

%

% leitura dos dados iniciais para um sistema de edo 2x2

global k1 k2 k3 k4

initial(1)=input('Digite a populacao inicial da presa : ');

initial(2)=input('Digite a populacao inicial do predador : ');

% intervalo de tempo usado [ti,tf]

ti = input('Tempo inicial : ');

tf = input('Tempo final : ');

% constantes referentes a presa e ao predador

k1 = 3

k2 = 0.002

k3 = 0.0006

k4 = 0.5

% ode23 = rotina do MATLAB para resolucao de edo's

[x, num_y] = ode23('pop',ti,tf,initial);

49

subplot(211);

plot(x,num_y(:,1));

title('Populacao da Presa')

xlabel('x');

grid;

subplot(212);

plot(x,num_y(:,2));

title('Populacao do Predador'),xlabel('x');

grid;

%========================================

% programa pop.m

% campo vetorial para o

% problema predador-presa

% =======================================

%

function xf = pop(t,x)

global k1 k2 k3 k4

xf(1) = k1*x(1)-k2*x(1)*x(2);

xf(2) = k3*x(1)*x(2)-k4*x(2);

50

0 1 2 3 4 5 6 7 8 9 100

1

2

3

4x 10

4 Populacao da Presa

x

0 1 2 3 4 5 6 7 8 9 100

5000

10000

15000Populacao do Predador

x

• Modelo para calcular a trajetória de uma bola de tênis com “topspin”:

A bola tem massa m, diâmetro d, mas é representada por um ponto. As forças

consideradas são: o peso G, a resistencia do ar D e a força de Magnus M que reflete o

efeito do “topspin”. Essas forças são dadas por:

G = mg, sendo g = (0, 0, -g) e g é a aceleração da gravidade

D = - DL(v) t

sendo v o valor absoluto da velocidade

t o vetor unitário tangente à trajetória

DL(v) = CD12

(π d2/4) ρv2

sendo ρ a densidade do ar

CD a constante empírica

CD = 0,508 [ 1 / (22,053 + 4,196(v/w)5/2)]2/5

w representa a velocidade angular da bola (dada pelo “topspin”).

51

M = - ML(v) n

n é o vetor unitário normal à trajetória e

ML(v) = CM 12

(π d2/4) ρv2

A constante empírica é dada por

CM = 1/ [2,022 + 0,981 (v/w) ]

A dinâmica é governada pelo uso da Lei de Newton em cada uma das direções (x

e z). Isto nos leva a um sistema de duas edo’s de segunda ordem, em que cada uma indica

que força é igual a massa vezes aceleração. Reescrevendo as equações como um sistema

de edo’s de primeira ordem, obtemos:

dxdt

= vx

dvdt

x = - CD α v vx + η CM α v vZ

dzdt

= vz

dvdt

z = -g - CD α v vx + η CM α v vZ

tendo como condições iniciais

x(0) = 0

vx(0) = v0 cos(θ)

z(0) = h

vx(0) = v0 sen(θ)

Adotaremos a seguinte notação para manter as equações em forma compacta:

v = (vx, vz) = (dx/dt, dz/dt)

52

α = ρ π d2 / 8 m

v = v vx z² ²+

η = ± 1

+1 => “topspin” e -1 => sentido contrário

h é a altura da bola na hora da raquetada e θ o ângulo do início da trajetória dela.

• Programas, em Matlab, para o modelo bola de tênis com “topspin”

%==================================================

% Problema para a trajetoria de uma bola de tenis viajando no vacuo,

% no ar e no ar na presenca de um spin (rotacao)

%==================================================

% tenisV = caso no vacuo

% Temos 4 funcoes: tenisA = caso no ar sem spin

% tenisAsp = caso no ar com rotacao positiva

% tenisAfs = caso no ar com rotacao negativa

% Variaveis que serao usadas pelas funcoes com os campos vetoriais

global g alpha w etha

% inicializacao

% Constantes basicas em unidades MKS

clg

g=9.81; d=0.063; m=0.05; rho=1.29;

alpha=pi*d^2/(8*m)*rho;

etha=1;

53

w=20;

%condicoes iniciais

h=1; v0=25; theta=pi/180*15;

xin=[0,h,v0*cos(theta), v0*sin(theta)];

%tempo de voo no vacuo

tmaxid=(xin(4)+sqrt(xin(4)^2 + 2*g*xin(2)))/g;

% solucao no vacuo

[tV, xV]=ode23('tenisV',0,tmaxid,xin);

%solucao no ar sem spin

[tA, xA]=ode23('tenisA',0,tmaxid,xin);

%solucao com spin

[tAsp, xAsp]=ode23('tenisAsp',0,tmaxid,xin);

%Preparando a saida grafica do problema

N = max(xV(:,1)); x = 0:N/100:N;

axis([0,max(xV(:,1)),0,max(xV(:,2))])

hold % comando que permite superpor os tres graficos (plots) seguintes

% esses tres comandos abaixo nao funcionam na versao do estudante

% e por isso foram "comentados"

%1 plot(x,spline(xV(:,1), xV(:,2),x),':g');

%2 plot(x,spline(xA(:,1), xA(:,2), x),'--g');

%3 plot(x,spline(xAsp(:,1),xAsp(:,2),x),'-w');

plot(xV(:,1), xV(:,2), ':g');

plot(xA(:,1), xA(:,2), '-- g');

54

plot(xAsp(:,1), xAsp(:,2), '-w');

%============================================

% Arquivo: tenisA.m

%

% calcula o campo vetorial para a bola no AR sem rotacao

%============================================

function xdot = tenisA(t,x)

%sem spin a constante de Magnus CM e ZERO.

global g alpha

v = sqrt(x(3)^2+x(4)^2);

xdot(1) = x(3);

xdot(2) = x(4);

xdot(3) = -alpha*0.508*x(3)*v;

xdot(4) = -g -alpha*0.508*x(4)*v;

%===========================================

% Arquivo a ser guardado com o nome de tenisAsp.m

%

% Calcula o campo vetorial para a bola no AR com rotacao

%============================================

55

function xdot = tenisAsp(t,x)

global g alpha w etha

v = sqrt(x(3)^2+x(4)^2);

% calculo do campo levando em conta as constantes de arraste CD

% e a de Magnus CM

aux1 = (0.508+1/(22.503+4.196*(v/w)^0.4))*alpha*v;

aux2 = etha*w/(2.022*w+0.981*v)*alpha*v;

xdot(1) = x(3);

xdot(2) = x(4);

xdot(3) = -aux1*x(3) + aux2*x(4);

xdot(4) = -g -aux1*x(4) - aux2*x(3);

%===================================================

% Arquivo : tenisV.m

%

% calcula o campo vetorial para a bola no VACUO

%===================================================

function xdot = tenisV(t,x)

global g

xdot(1) = x(3);

xdot(2) = x(4);

xdot(3) = 0;

xdot(4) = -g;

56

0 10 20 300

0.5

1

1.5

2

2.5

3

Trajetórias da bola de tênis • no vácuo (linha pontilhada) • no ar (linha tracejada) • no ar com “topspin” (linha cheia)

capítulo 1. introdução - página do câmpus de rio … capítulo 1. introdução 1.1. teoremas e...

Documents