Captulo 1.

Introduo
1.1. Teoremas e Comentrios
Definio1.0.0 : Uma funo f(x,y) satisfaz a condio de Lipschitz na varivel y sobre o
conjunto D 2, se existe uma constante L>0, tal que vlida 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 seqncia

que satisfaz a0 >= -t/s e
ai+1 <=(1+s) ai + t

para i =0,1,2, ..., k

ento
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 funo contnua e satisfaz a condio
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 tambm y(t) como uma nica soluo para o problema
de valor inicial

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

Ento
|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 equao mais geral para o mtodo 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) ento a equao 1.0.3 fica
wo =
wi+1 = wi + h f (ti , wi)

(1.0.4 )

Usaremos a notao yi = y(ti) e yi+1 = y (ti+1) .Subtraindo (1.0.3 ) de

(1.0.4) e usando a notao nova temos:
yi+1 - wi+1 = yi - wi + h[f(ti, yi) - f(ti, wi )] + h2/2 *y(i).
Aplicando o mdulo temos:
|yi+1 - wi+1 |= |yi - wi |+ h|f(ti, yi) - f(ti, wi )| + h2/2 *|y(i)|. (1.0.2)
Como a funo satisfaz a condio de Lipschitz ento

| f(t,y1) - f(t,y2)|<= L |y1 -y2| definio (1.0.0)

Usando a definio (1.0.0) em (1.0.2) e a propriedade | y(t) | <= M
temos :
|yi+1 - wi+1 |<= |yi - wi | + hL |yi - wi | + h2/2 *M
Pondo em evidncia o termo sublinhado anteriormente temos:
|yi+1 - wi+1 |<= |yi - wi | (1 + hL) + (h2*M)/2
Fazendo analogias para aplicar o lema 1.0.1 temos:
ai+1 = |yi+1 - wi+1 |

; ai = |yi - wi | ; s =hL ; t = (h2*M)/2

Aplicando finalmente o lema dado temos

|yi+1 - wi+1 |<= e(i+1)hL (|y0 - w0 | + (h2*M)/(2hL)) - (h2*M)/(2hL)
Sendo |y0 - w0 | = 0 e (i+1 )h = ti+1 - t0 = t0 - temos

|yi+1 - wi+1 |<= e(ti+1 -)L *( (h2*M)/(2hL) ) - (h2*M)/(2hL)

Colocando em evidncia o termo grifado temos :
0,1,2,...,N c.q.d.

|yi+1 - wi+1 |<= (h*M)/(2L) (e(ti+1 -)L - 1) para cada i =

1.2. Breve comentrio sobre o funcionamento do

algoritmo de RK4 para sistemas

O algoritmo Range Kutta de quarta ordem para sistemas de equaes diferenciais

de primeira ordem trabalha da mesma maneira que o Range Kutta tradicional de quarta
ordem , s com algumas alteraes .
Em cada um dos algoritmos anteriormente citados (rk4 tradicional e rk4 para
sistemas )
existem condies iniciais comuns que o usurio dever entrar como por exemplo:
Os valores de a e b sendo que a diferena b-a representar o intervalo onde a varivel

t ir variar.
A varivel N que dividir o intervalo anteriormente citado em N partes iguais .

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

Outras condies iniciais do rk4 para sistemas devem ser entradas, s que estas so
diferentes do rk4 tradiconal:
Enquanto para o rk4 tradicional existe apenas uma equao diferencial,para o rk4 de

sistemas existem m equaes.

Enquanto para o rk4 tradicional existe apenas uma condio inicial , para o rk4 de

sistemas existem m condies iniciais.

Aps esta fase de inicializao de variveis, o algoritmo atribui wj =j onde j so as

condies iniciais e j varia de 1 at o nmero de equaes diferenciais de primeira ordem
entradas.
Depois disso , o algoritmo entra num lao 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.

Dentro do lao anterior sero calculados os vrios k1,k2,k3,k4 para cada equao
diferencial dada.Assim,cada equao ter seus prprios ks em cada passo.
Uma importante observao que para o clculo de um ki+1 necessrio o valor do ki
anterior .
De posse dos valores de ks de todas as equaes a cada passo calcula-se os valores
de ws.Assim, temos valores intermedirios de ws 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. Mtodos de Passos Variveis

A tcnica previsor-corretor sempre gera duas aproximaes para cada passo,
ento ela a candidata natural para adaptao de controle de erros.
Para demonstrar o procedimento para controle de erro, foi construdo um mtodo
previsor-corretor com tamanho de passos variveis.]
Este algoritmo, a princpio, resolve a equao utilizando o Runge Kutta de Quarta
ordem para que a partir de sua resposta, o algoritmo faa o refinamento do erro cometido.
A cada passo ser calculado o valor previsto e o valor corrigido. O clculo do
erro depende diretamente desses dois fatores. Se esse erro for muito grande, ou
seja,maior que a tolerncia desejada, ento realizado mudanas em algumas variveis
para que o erro no prximo passo reduza. A cada passo , a preciso tende a aumentar.
Com o clculo do valor corrigido atravs do uso valor previsto, obtm-se um valor que
mais se aproxima da resposta.

10

A cada passo o RK4 chamado, mas com uma diferena. Substitue um ponto em
relao a ltima chamada, sendo que este ponto o calculado atravs do mtodo
previsor-corretor, ou seja, a tendncia que o novo resultado do RK4 seja um pouco
mais satisfatrio, e que o clculo 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 mtodo estvel aquele que depende continuamente dos estados iniciais, ou
seja, so estveis se quando pequenas mudanas nas aproximaes subsequentes.

Definio 1: Um mtodo de equao diferencial de um passo com erro local i(h) no isimo passo dito ser consistente com a equao diferencial se

Lim max | i(h) | = 0

h->0 1<i<N
Definio 2: Um mtodo de equao diferencial de 1 passo dito ser convergente com
a respectiva equao diferencial se
Lim max | i - y(ti) | = 0
h->0 1<i<N
onde yi = y(ti) denota o valor exato da soluo da equao diferencial e i a
aproximao obtida do mtodo de diferena no i-simo passo.
Teorema :

Suponha o problema de de valor inicial y = f(t,y), a t b , y(a)=

11

 aproximado por um mtodo de um passo da forma

W0 =

Wi+1 = Wi + h(ti,Wi,h)
Suponha tambm que um nmero h0 > 0 existe (t,W,h) contnu e satisfaz a
condio de Lipschitz* na varivel com constante Lipschitz L sobre o conjunto D={
(t,W,h) | a t b, -< W< , 0 hh0 }. Ento

1)

o mtodo estvel;

2)

o mtodo 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 hh0
ento
| y(ti) - i | ( (h)/L ) exp(L(ti - a))

1.5. Mtodos de Mltiplos Passos

Estes mtodos, assim como a famlia Runge-Kutta, tambm so derivados a
partir de sries de Taylor.
O que caracteriza estes mtodos que eles usam informaes sobre a soluo em
mais de um ponto.

12

Supondo inicialmente conhecida as aproximaes para y(x) em x0, x1, ... , xn e

que xi +1 - xi =h, queremos aproximar a soluo da equao 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,
y(xn + 1) - y(xn)

xn + 1
f(x,y(x)) dx

xn
O problema agora reside ento em aproximar uma soluo para a integral acima, para
encontrar uma soluo aproximada. Antes de prosseguir a discusso importante ter em
mente dois conceitos:

1.5.0 MTODO EXPLCITO: Os mtodos desta classe so obtidos quando trabalhamos

com xn,xn-1,...,xn-m, ou seja o clculo de yn

+ 1

tem forma explcita em funo dos

outros (para calcular yn + 1, uso somente yn, yn-1, yn-2, yn-3, por exemplo se o mtodo
escolhido for de 3 passos).

1.5.1 MTODO MPLICITO: Nestes tipos de mtodos na frmula que calcula yn + 1,

deve-se entrar com o valor de yn + 1, ou seja a frmula no explcita, o que gera a
grande dificuldade destes destes mtodos.
Para uma melhor compreenso destes mtodos acompanhe alguns exemplos da
famlia Adams de mltlipos passos, seguidos logo abaixo de um breve comentrio,
lembrando ao leitor que uma reflexo mais profunda sobre estes mtodos recomendada.

1.6. Mtodos de Adams-Bashforth

1.6.0 Mtodo de Adams-Bashforth de 2 passos (2a. ordem)
w0= ,

w1= 1

13

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

1.6.1 Mtodo 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)]

1.6.2 Mtodo de Adams-Bashforth de 4 passos (4a. ordem)
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)]

1.6.3 Mtodo de Adams-Bashforth de 5 passos (5a. ordem)
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 Mtodos de Adams-Moulton

1.7.0Mtodo 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 Mtodo 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 Mtodo de Adams-Moulton de 4 passos (4a. ordem)
w0= ,

w1= 1, w2= 2 , w3= 3

14

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. Comentrio
Os mtodos de Adams-B.so todos mtodos explcitos e no auto-inicializveis,
sendo preciso de alguma forma (usando R.K, por exemplo), calcular os m-primeiros wis,
quando se usa um mtodo Adams-B de m-passos.Para calcular wj estes mtodos usam os
valores anteriores de wj-1,wj-2,...,wo. Ento o esforo computacional nestes tipos de
algoritmos se residem em apenas calcular o valor da funo em cada ponto. J os
mtodos de Adams-M. se caracterizam por serem fechados (implcitos). A grande
dificuldade deste mtodo usar uma frmula implcita , ou seja para calcular a
aproximao em um ponto, a frmula empregada j usa este valor, o que torna o
problema computacionalmente invivel, pois no se consegue uma recurssividade. A
maneira encontrada para contornar este problema por exemplo usar um mtodo
explcito para auxiliar.
De maneira geral o mdulo do erro para Adams-M. menor que Adams-B. , mas
depende fundamentalmente se o problema estar bem condicionado e a escolha do melhor
mtodo para aquele problema.

1.9. Mtodos Previsor-Corretor

Este mtodo usa a frmula explcita e implcita para aproximar uma soluo. A
idia primeira era usar a frmula implcita para aproximar uma soluo, mas isso esbarra
no problema acima mencionado, ou seja, para calcular yn + 1 uso o valor de xn + 1. Para

15

contornar esta situao obtm-se o valor de yn + 1, atravs de uma aproximao por um

mtodo explcito (convenientemente escolhido). De posse desta aproximao posso
agora usar a frmula impcita, substituindo nesta este valor e encontrando assim uma
nova aproximao muito melhor para yn + 1.
A forma explcita primeiramente usada chamada de um previsor; e a forma
implcita chamada de corretor. Da o nome previsor-corretor.
Quando o previsor e o corretor usado so da mesma ordem e a escolha do h
conveniente a preciso de algoritmo muito boa.
O esforo computacional demandado dobrado em relao aos mtodos 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 dinmica de populaes

(presa-predador)
Um modelo muito simples aquele em que o crescimento (ou decaimento) da
populao proporcional ao nmero de membros da mesma. Escrevendo na forma de
equao diferencial ordinria (edo):

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

sendo: dN/dt a variao da populao em relao ao tempo

No a populao inicial

16

R a taxa de variao

Porm, este modelo est longe da realidade, pois sabemos que, aps um certo
perodo de tempo, a populao ser to grande que surgiro problemas (limitao de
alimentos, espao etc).
Surgiu ento a equao logstica

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

na qual a taxa de variao depende da populao e dada por f(N). Vamos construir uma
funo f(N) que tenha as propriedades desejadas:

a) a populao cresce exponencialmente quando ela for pequena;

b) o crescimento desacelera conforme a populao vai crescendo;
c) observamos mortalidade quando a populao for muito grande. Matematicamente,
escrevemos isso como f(n) < 0 quando N >> 1.
Um modelo seria a funo:
f(N) = r [1 - (N/M)]
sendo: M o ponto a partir do qual observamos a mortalidade de indivduos
Um modelo um pouco mais complexo dado a seguir:

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

17

Finalmente, estudaremos um modelo no qual duas populaes competem para

sobreviver. Sejam N1(t) e N2(t) a populao de presas e predadores, respectivamente.
Suporemos que as presas tem um suprimento abundante de alimento, enquanto que o
predador alimenta-se das presas. Vamos tambm assumir que um bilogo nos forneceu as
seguintes hipteses(todas as constantes ki, i = 1, 2, 3, 4 dadas abaixo so positivas):
1.10.0 PRESA:
Taxa de natalidade: proporcional populao naquele instante: k1N1(t)
Taxa de mortalidade: depende da populao das presas assim como dos predadores. Por
simplicidade, adotaremos a expresso: -k2N1(t)N2(t)
PREDADOR:

Taxa de natalidade: proporcional populao de predadores assim como a das presas:

k3N1(t)N2(t)
Taxa de mortalidade: proporcional populao de predadores: -k4N2(t)
Colocando essas informaes na forma de edos, temos o sistema

dN 1
= k1N1 - k2N1N2
dt
dN 2
= k3N1N2 - k4N2
dt
com N1(0) = N10 e N2(0) = N20.

1.11. Exerccios e Programas

Exerccio 4.1 da apostila Curso Mtodos Numricos - Notas de Aula

18

 Programa desenvolvido em Borland C++ para a soluo deste problema, sendo que o

programa abaixo genrico possuindo a opo de resoluo atravs dos mtodos 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)

19

{
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]);

20

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'
:{
runge2=fopen("rk2.dat","wt");
t[0]=a;
fprintf(runge2,"%2.4f,%2.4f\n",t[0],w2[0]);
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;
fprintf(runge2,"%2.4f,%2.4f\n",t[i],w2[i]);

21

}
fclose(runge2);
for(i=0;i<=n;i++)
printf("%2.4f\n",w2[i]);
break;
}

case '
3'
:{

//open1

runge4=fopen("rk4.dat","wt");
t[0]=a;
fprintf(runge4,"%2.4f,%2.4f\n",t[0],w4[0]);
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;
fprintf(runge4,"%2.4f,%2.4f\n",t[i],w4[i]);
printf("%2.4f\n",w4[i]);
}
fclose(runge4);

22

//close1

Grfico de sada do programa em Borland C++ para h = 0.1 e Mtodo Runge-Kutta 1a.
Ordem (Euler) (plotado no GRAPHER)
2.400
2.300
2.200
2.100
2.000
1.900
1.800

Grfico de sada do programa em Borland C++ para h = 0.01 e Mtodo RungeKutta 1a. Ordem (Euler) (plotado no GRAPHER)

23

2.400
2.300
2.200
2.100
2.000
1.900
1.800

Grfico de sada do programa em Borland C++ para h = 0.001 e Mtodo

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

2.400
2.300
2.200
2.100
2.000
1.900
1.800

Grfico de sada do programa em Borland C++ para h = 0.1 e Mtodo Runge-

Kutta 2a. Ordem (plotado no GRAPHER)

24

2.400
2.300
2.200
2.100
2.000
1.900
1.800

Grfico de sada do programa em Borland C++ para h = 0.01 e Mtodo RungeKutta 2a. Ordem (plotado no GRAPHER)
2.400
2.300
2.200
2.100
2.000
1.900
1.800

Grfico de sada do programa em Borland C++ para h = 0.001 e Mtodo

Runge-Kutta 2a. Ordem (plotado no GRAPHER)

25

2.400
2.300
2.200
2.100
2.000
1.900
1.800

Grfico de sada do programa em Borland C++ para h = 0.1 e Mtodo Runge-

Kutta 4a. Ordem (plotado no GRAPHER)

2.400

2.300

2.200

2.100

2.000

1.900

1.800

Grfico de sada do programa em Borland C++ para h = 0.01 e Mtodo RungeKutta 4a. Ordem (plotado no GRAPHER)

26

2.400
2.300
2.200
2.100
2.000
1.900
1.800

Grfico de sada do programa em Borland C++ para h = 0.001 e Mtodo

Runge-Kutta 4a. Ordem (plotado no GRAPHER)

2.400

2.300

2.200

2.100

2.000

1.900

1.800

Esquema SIMULINK para a soluo da equao diferencial

27

2
Constante
+
+

[T,U]
Matriz contendo
os valores de x

Somatorio
das variaveis

1/s
Integracao para
obter y

y
Saida para y

x
Saida para x

Grafico de X/Y

Gr
Grfico de sada do esquema SIMULINK para h=0.1.
X Y Plot

2.5
2.4
2.3
2.2

Y Axis

2.1
2
1.9
1.8
1.7
1.6
1.5
0

0.1

0.2

0.3

0.4

0.5
X Axis

0.6

0.7

0.8

0.9

Grfico de sada do esquema SIMULINK para h = 0.01

28

X Y Plot

2.5
2.4
2.3
2.2

Y Axis

2.1
2
1.9
1.8
1.7
1.6
1.5

0.1

0.2

0.3

0.4

0.5
X Axis

0.6

0.7

0.8

0.9

Grfico de sada do esquema SIMULINK para h = 0.001

X Y Plot

2.5
2.4
2.3
2.2

Y Axis

2.1
2
1.9
1.8
1.7
1.6
1.5

0.1

0.2

0.3

0.4

0.5
X Axis

0.6

0.7

0.8

0.9

Exerccio 4.2 da apostila Curso Mtodos Numricos - Notas de Aula

Programa desenvolvido em Borland C++ para a soluo deste problema

/* Exercicio 2 : RK4
Linguagem : Borland C++ */

29

#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 equaes 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) : ");

30

scanf("%f",&w[1]);
printf("Entre com o valor de y2(0) : ");
scanf("%f",&w[2]);
printf("Entre com o valor de y3(0) : ");
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

31

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]);

32

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);
}*/
Grfico de sada do programa em Borland C++ para h = 0.001 (plotado no

GRAPHER)

33

Grfico da Acelerao

0.5

-0.5
0

50

100

150

50

100

150

200

Grfico da Velocidade
2
1.5
1
0.5
0
-0.5
-1
-1.5
0

200

Grfico da Velocidade x Acelerao

34

3
2
1
0
-1
-2
-2

-1

Esquema SIMULINK para a soluo da equao diferencial

0.
Gain1
velocidade

4
Gain2
Sum
[T,U]
From
Workspace

0.
Gain

1/s
Integrator

1/s
Integrator1

f(u)
Fcn

du/dt Aceleracao
1
Derivative

V x V`

Grficos de sada do esquema SIMULINK para h = 0.001

Grfico da Acelerao

35

0.5

-0.5

50

100
150
Time (second)

200

Grfico daVelocidade
2
1.5
1
0.5
0
-0.5
-1
-1.5

50

100
150
Time (second)

200

Grfico da Velocidade x Acelerao

36

X Y Plot

Y Axis

2
1
0
-1
-2
-2

-1

0
X Axis

Exerccio 4.3 da apostila Curso Mtodos Numricos - Notas de Aula

Programa desenvolvido em Borland C++ para a soluo 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;

37

float y[3];
float k[4][3];
float w[4]; //valores inicias das equaes 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) : ");
scanf("%f",&w[1]);
printf("Entre com o valor de y2(0) : ");
scanf("%f",&w[2]);
printf("Entre com o valor de y3(0) : ");
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;

38

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;

39

//

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);
}*/

40

 Grfico de sada 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)
5
4.5
4
3.5
3
2.5
2
1.5
1
0.5
0
0

0.2

0.4

0.6

0.8

1.2

1.4

1.6

1.8

Esquema SIMULINK para a soluo da equao diferencial

2
Gain

Product

+
+
+
+
Sum
[T,U]
From
Workspace

1/s
Integrator1

1/s
Integrator

1/s
Integrator2

Mux Mux

Graph

Grficos de sada do esquema SIMULINK para h = 0.001 (onde a 1a., 2a. e 3a.
curvas, rferem-se y1[t], y2[t] e y3[t] respectivamente).

41

5
4.5
4
3.5
3
2.5
2
1.5
1
0.5
0

0.2

0.4

0.6

0.8

1
1.2
Time (second)

1.4

1.6

1.8

Exerccio 1.a do Conjunto 5.1 da apostila Initial-Value Problems for Ordinary

Differential Equations
Esquema SIMULINK para a soluo da equao diferencial

yout
To Workspace
*

1/s
Integrator

Graph

[T,U]
From
Workspace

Product

cos(u)
Fcn

Grfico de sada dp esquema SIMULINK para h=0.001.

42

5
4.5
4
3.5
3
2.5
2
1.5
1
0.5
0

0.1

0.2

0.3

0.4

0.5
0.6
Time (second)

0.7

0.8

0.9

Exerccio 1.b do Conjunto 5.1 da apostila Initial-Value Problems for Ordinary

Differential Equations
Esquema SIMULINK para a soluo da equao diferencial

1/s
y

[T,U]
From
Workspace

Graph

2/u
funcao auxiliar

Product2

u*u
funcao aux1

exp(u)
funcao exponencial

+
+
Sum
*
Product1

Grfico de sada dp esquema SIMULINK para h=0.001

43

5
4
3
2
1
0
-1
-2
-3
-4
-5

1.2

1.4

1.6

1.8

2
2.2
Time (second)

2.4

2.6

2.8

Exerccio 1.d do Conjunto 5.1 da apostila Initial-Value Problems for Ordinary

Differential Equations
Esquema SIMULINK para a soluo da equao diferencial.

1/s
Integrator

Graph
*
Product

[T,U]
From
Workspace

4
Constant

*
Product1

f(u)
Fcn

Grfico de sada de esquema SIMULINK para h=0.001

44

5
4
3
2
1
0
-1
-2
-3
-4
-5

0.1

0.2

0.3

0.4

0.5
0.6
Time (second)

0.7

0.8

0.9

Exerccio 1.d do Conjunto 5.2 da apostila Initial-Value Problems for Ordinary

Differential Equations
Esquema SIMULINK para a soluo da equao diferencial

[T,U]
From
Workspace

f(u)
sen(3*u)
f(u)
cos(2*u)

+
+
Sum

1/s
Integrator1

Graph

Grfico de sada de esquema SIMULINK para h=0.25.

45

2.5

1.5

0.5

0.1

0.2

0.3

0.4

0.5
0.6
Time (second)

0.7

0.8

0.9

Exerccio 5 do Conjunto 5.2 da apostila Initial-Value Problems for Ordinary

Differential Equations
Esquema SIMULINK para a soluo da equao diferencial

[T,U]
From
Workspace

2/u
2/u
f(u)
exp(u)*(u*u)

*
Product

+
+
Sum

1/s
Integrator1

Graph

Grfico de sada de esquema SIMULINK para h=0.1

46

20
18
16
14
12
10
8
6
4
2
0

1.1

1.2

1.3

1.4

1.5
1.6
Time (second)

1.7

1.8

1.9

Atravs do Mtodo de Euler com um passo de 0.1, a soluo obtida possui

um desvio de 21% de erro, sendo que o mtodo do Runge-Kutta de 4a. Ordem
superior na obteno de solues.
Item a) A soluo apresentada para o mtodo de Euler foi 15.3982,
enquanto que a soluo real 18.6831.
Item b) Com a soluo para esses valores (y(1.04), y(1.55) e y(1.97)),
podemos observar que para valores pequenos, perto do inicial, a aproximao
muito boa, enquanto que para valores prximos ao limite superior do intervalo, as
solues so discrepantes. V-se que o erro introduzido cresce numa escala
exponencial.
Item c) Com o uso da frmula abaixo
hm
| y(ti) - wi| <=

[eL(ti-a) - 1]
2L

chegou a um valor para que o erro seja mnimo, tal que h = 0.001

47

 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);

48

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);

49

x 10

Populacao da Presa

3
2
1
0

15000

5
6
x
Populacao do Predador

10

10

10000

5000

5
x

Modelo para calcular a trajetria de uma bola de tnis com topspin:

A bola tem massa m, dimetro d, mas representada por um ponto. As foras

consideradas so: o peso G, a resistencia do ar D e a fora de Magnus M que reflete o
efeito do topspin. Essas foras so dadas por:
G = mg, sendo g = (0, 0, -g) e g a acelerao da gravidade
D = - DL(v) t
sendo v o valor absoluto da velocidade
t o vetor unitrio tangente trajetria

1
DL(v) = CD ( d2/4) v2
2
sendo a densidade do ar
CD a constante emprica
CD = 0,508 [ 1 / (22,053 + 4,196(v/w)5/2)]2/5
w representa a velocidade angular da bola (dada pelo topspin).

50

M = - ML(v) n
n o vetor unitrio normal trajetria e
ML(v) = CM

1
( d2/4) v2
2

A constante emprica dada por

CM = 1/ [2,022 + 0,981 (v/w) ]
A dinmica governada pelo uso da Lei de Newton em cada uma das direes (x
e z). Isto nos leva a um sistema de duas edos de segunda ordem, em que cada uma indica
que fora igual a massa vezes acelerao. Reescrevendo as equaes como um sistema
de edos de primeira ordem, obtemos:

dx
= vx
dt
dvx
= - C D v vx + C M v vZ
dt
dz
= vz
dt
dvz
= -g - CD v vx + CM v vZ
dt
tendo como condies iniciais
x(0) = 0
vx(0) = v0 cos()
z(0) = h
vx(0) = v0 sen()
Adotaremos a seguinte notao para manter as equaes em forma compacta:
v = (vx, vz) = (dx/dt, dz/dt)

51

 = d2 / 8 m

v=

vx + vz

= 1

+1 => topspin e -1 => sentido contrrio

h a altura da bola na hora da raquetada e o ngulo do incio da trajetria dela.
Programas, em Matlab, para o modelo bola de tnis 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;

52

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'
);

53

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

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

54

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;

55

3
2.5
2
1.5
1
0.5
0
0

10

20

30

Trajetrias da bola de tnis

no vcuo (linha pontilhada)
no ar (linha tracejada)
no ar com topspin (linha cheia)

56