Fiscomp FA-09 2011-1

Instituto de Fsica Armando Dias Tavares
Departamento de Fsica Aplicada e Termodinmica
Fsica Computacional A
DFAT/
FiscompFA
Equaes Diferenciais Ordinrias

Professor: Anibal Leonardo Pereira
ltima atualizao: junho 2011
Estagirios:
2004/1 a 2005/2 Luciana Conceio Iecker Lima
2010/1
Magali dos Santos Leodato
2009/1 a 2010/2 Filipe da Fonseca Cordovil
Monitores:
2001/1
2002/2
2003/1 a 2003/2
2003/1 a 2003/2
2003/1 a 2005/2
2004/1 a 2005/2
2006/1 a 2007/2
2006/1 a 2007/2
2008/1 a 2008/2
2008/1 a 2009/2
2011/1 a
Diego Chagas Garcia

Erick Azevedo Meirelles
Luciana Maria dos Santos Azevedo
Tatiana Gonalves Martins
Renato Nascente Jnior
Pblio Martins Romano M. Carreiro
Luiz Fernando Rosalba Telles Souza
Paulo Henrique Pfitzner
Filipe da Fonseca Cordovil
Magali dos Santos Leodato
Filipe da Fonseca Cordovil
1. Introduo
O mtodo de Euler o mtodo numrico mais simples que pode ser usado para resolver uma equao
diferencial ordinria de primeira ordem ( Equao Diferencial Ordinria EDO).
Uma equao diferencial ordinria uma equao que envolve s uma varivel independente. Por exemplo, a
equao diferencial que descreve o movimento de um pndulo simples de massa m e comprimento l
2
d g
sen =0
2
l
dt
d
g
= sen
2
l
dt
ou
que uma equao diferencial ordinria de primeira ordem pois a nica varivel independente o tempo.
As equaes
dy
=x8
dx
d2 y
dy
3 2y=0
2
dx
dx
d3 y
d2 y
dy
2
=cos x
3
2
dx
dx
dx
dy
x y=3
dx
2
d2y
dy
3y=x 2 so equaes diferenciais ordinrias

2
dx
dx
DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias
z
z
z x
=0
x
y
2 z 2 z
2 = x 2 y no so, pois possuem duas variveis independentes x e y.
2
x y
enquanto as equaes
As equaes diferenciais podem ser classificadas quanto ao tipo, a ordem e a linearidade:
Tipo
podem ser ordinrias ou parciais. Ordinrias quando as funes forem somente funes de uma
varivel, por exemplo: y= f x . Parciais quando as funes forem funes de mais de uma
varivel independente: z = f x , y
Ordem
pode ser de 1a, 2a , 3a, , ensima ordem, dependendo da derivada de maior ordem presente na
2
equao. A equao
d
g
= sen uma equao diferencial ordinria de segunda ordem
2
l
dt
Linearidade
Ser linear quando as incgnitas e suas derivadas aparecem de forma linear na equao e no
dy
y=3 uma equao diferencial ordinria de primeira
dx
linear caso contrrio. A equao x

ordem linear
Equaes diferenciais ordinrias de primeira ordem so equaes que podem ser escritas assim:
ou ento
F t , y , y ' =0
ou
dy
= f t , y
dt
F x , y , y '=0
ou
dy
= f x , y
dx
2. Mtodo de Euler
Vrios problemas encontrados na fsica envolvem equaes diferenciais ordinrias de primeira ordem, por
exemplo:
movimento de projtil
movimento harmnico
so exemplos clssicos.
O mtodo de Euler (mtodo de Euler padro; mtodo de Euler progressivo; Forward Euler method ) para uma equao
diferencial ordinria de primeira ordem pode ser apresentado assim:
Considere a equao diferencial
dy
= f x , y onde x e y so as variveis independentes e dependentes e
dx
f x , y a funo derivada.
A funo derivada pode ser determinada usando-se as diferenas finitas, ento:
y i1 y i
y y
dy
y
= lim
= lim
=lim i1 i
dx x 0 x x 0 x i1 xi h 0
h
onde se fez x= h=x i1xi
dy y i1 y i
dx
h
(geralmente h chamado de passo e feito constante)
portanto, considerando a derivada como sendo representada pela sua expresso aproximada pode-se escrever:
f x , y =
y i1 y i
h
o que nos leva a
y i1= yi h f x i , yi
Esta forma de chegar ao novo valor de y, o valor y i1 , conhecido o valor anterior, y i , chamada de
mtodo de Euler (Euler padro ou Euler progressivo).
No problema do valor inicial (Problema do Valor Inicial PVI)
dy
= f x , y
dx
y x 0 = y 0 valores iniciais:
x0, y0
os pares de valores (x, y) so encontrados utilizando-se recursivamente a equao
y i1= y ih f x i , y i
00 atividades exemplos
Esta Folha contm 03 atividade exemplo com ajustes e/ou acrscimos

00 atividades para serem feitas
03 Atividades
00 atividades para serem ajustadas e/ou acrescidas
Seu professor de laboratrio (e/ou teoria) poder alterar esta relao !
Cdigo da folha de atividades

Acesse a Home Page da disciplina, entre no link Datas-e-Atividades, para obter o cdigo da
folha de atividades. Toda atividade tem que ter o "xx" substitudo pelo cdigo indicado.
Exemplos: cdigo 02 fxxa3.f03 f02a3.f03
Atividade 01
Entregar em meio magntico:
1.
programa:
euler1_prog
fxxa1.f03
2.
mdulos:
fc_constantes.f03
m_rotinas.f03
m1func.f03
3.
scripts:
euler1.plt
4.
arquivos:
euler1-h05.dados
euler1-h02.dados
euler1-h005.dados
euler.gif
Exemplo/Acrscimo/Ajuste:
Exemplifica o uso do mtodo de Euler progressivo para a soluo de equao diferencial ordinria com valor inicial especificado
Observao:
As solues, exata e as numricas so colocadas num mesmo grfico para evidenciar o erro nos valores da soluo,
conforme h vai aumentando
Fazer:
a1.1) Gere os arquivos de dados euler1-h05.dados, euler1-h02.dados e euler1-h005.dados contendo a soluo do problema
do valor inicial:
dy
=cos 4x x 2
dx
y x 0 = y 0=2
grfico (arquivo euler.gif) contendo a soluo exata
no intervalo [0,1] com h=0.5, h=0.2 e h=0.05. Construa o
1
1
y=2 x 3 sin 4x
3
4
e as trs solues encontradas pelo
mtodo de Euler progressivo.

a1.2) A velocidade de queda de um corpo descrita pela equao
dv
=g
dt
onde v a velocidade e a acelerao da
gravidade vale g=9.8067 m/s2. Calcule v como funo da velocidade para um corpo com (a) saindo do repouso e (b) com
velocidade inicial diferente de zero, no intervalo de t=o at t=10s. Construa o grfico com a soluo numrica e a soluo
analtica.
a1.3) um corpo move-se segundo a equao
dx
=v x
dt
. Se a velocidade constante e igual a 40 m/s uma tabela com as
posies x como funo do tempo. Entregue o grfico correspondente.

a1.4) A equao
dI
=aI bI 2
dt
descreve o crescimento populacional, sendo I o nmero de indivduos. O termo aI
corresponde ao nmero de nascimentos e -bI2 o nmero de mortes. Solucione o problema (a) com b=0 e (b) com a=10 e b=3
No deixe de substituir os xx pelo cdigo adequado.

Escreva o programa euler1_prog e salve-o no arquivo fxxa1.f03
Escreva os mdulos e os scripts
Gere os arquivos de dados e os grficos solicitados
No deixe de atualizar o cabealho de forma adequada.
________________________________________________________________________________________
arquivo: fxxa1.f03
program euler1_prog
!
!------------------------------------------------------------------------! Propsito: Constri tabela de valores (x,y) soluo da equao
!
diferencial ordinria de 1a ordem com valor inicial y0
! utilizando o mtodo de Euler (Euler progressivo)
!------------------------------------------------------------------------! Arquivo:fxxa1.f03
!
Autor: Anibal L. Pereira
14/02/2009
!Revises:
!------------------------------------------------------------------------use fc_constantes
use fc_rotinas
use fc_m1func
implicit none
integer::i,
& !contador
npassos
! nmero de passos inteiros
real::x0,y0,
& ! valor inicial
a,b,
& ! intervalo - ponto inicial e ponto final
h,
& ! incremento h
delta
! incremento mais prximo de h
real,allocatable,dimension(:)::xt,yt
!pontos da tabela
!--------------------------------------------------! Entrada pontos da tabela
!--------------------------------------------------print*, "===================================="
print*, "Entre com o valor inicial x(0) e y(0)"
print*, "===================================="
read*, x0,y0
print*, "===================================="
print*, "Entre com o valor intervalo: A B "
print*, "===================================="
read*, a,b

print*, "===================================="
print*, "Entre com o incremento h "
print*, "===================================="
read*, h
!---nmero de passos inteiros no intervalo a-b
call incremento(a,b,h,npassos,delta)
print*,"npassos,delta",npassos,delta
!---cria vetores x e y da tabela
allocate(xt(npassos+1),yt(npassos+1))
xt=0.0
yt=0.0
!---------------------------------------------------! clculo da tabela soluo da EDO
!---------------------------------------------------!---funo derivada: fun6=f(x)=cos(4*x)+x*x
call euler_tab(fun6,x0,y0,a,b,delta,xt,yt)
!---------------------------------------------------! preserva resultado num arquivo
!---------------------------------------------------open(unit=10, file="euler-h05.dados", status="replace",action="readwrite")
!open(unit=20, file="euler-h02.dados", status="replace",action="readwrite")
!open(unit=30, file="euler-h005.dados", status="replace",action="readwrite")
do i=1,size(xt)
write(unit=10,fmt=*) xt(i),yt(i)
end do
close(unit=10)
program euler1_prog
_______________________________________________________________________________________
arquivo: fc_constantes.f03
Utilize os mdulos existentes:
_______________________________________________________________________________________
arquivo: fc_rotinas.f03
module fc_rotinas
!------------------------------------------------------------------------------!Propsito:
! Guarda funes e sub-rotinas
!------------------------------------------------------------------------------!USO:
! Coloque no seu programa fonte as declaraes
!
use fc_constantes
!
use fc_rotinas
!
!COMPILAO:
! (1) deste mdulo fiscomp_rotinas
!
f03 -c fc_constantes.o fc_rotinas
!
! (2) para usar o mdulo com o programa <prog.f03>
!
f03 -o <prog> fc_constantes.o fc_rotinas.o <prog.f03>
!------------------------------------------------------------------------------! Arquivo: fc_rotinas.f03
!
Autor: Anibal L. Pereira 23/01/2009
!Revises: Anibal L. Pereira 11/02/2009
!Revises: Anibal L. Pereira 16/04/2010
!
implicit none
!------------------------------------------------------------------------! Interfaes
(funes e sub-rotinas sobrecarregadas)
!-------------------------------------------------------------------------
interface copia_matriz
module procedure
copia_matriz_i, copia_matriz_r, copia_matriz_d
end interface
interface swap
module procedure
end interface
swap_i, swap_r, swap_rv, swap_c, swap_cv
interface incremento
module procedure
end interface
incr_r, incr1_rv, incr2_rv
interface entra_linha_matriz
module procedure
entra_linha_matriz_t, entra_linha_matriz_a
end interface
!------------------------------------------------------------------------! Funes
!------------------------------------------------------------------------public:: derivada
!------------------------------------------------------------------------! Sub-rotinas
!------------------------------------------------------------------------public:: gauss,
& !gauss elimination AX=B
entra_linha_matriz,
& !entra linha de uma matriz
!rotina sobrecarregada
!1)entra_linha_matriz_t(mat)
!
entra linha da matriz pelo teclado
!2)entra_linha_matriz_a(mat,arq)
!
entra linha da matriz via arquivo
inversa_matriz,
& !inversa matriz - mtodo eliminao Gauss
copia_matriz,
& !copia matriz em outra matriz
!1)copia_matriz(src,dest,n_cop,n_ncop)
!
copia matriz de valores inteiros
!
copia matriz de valores reais, sp
!
copia matriz de valores reais, dp
swap,
& !troca valores
!1)swap(a,b)
!
troca valores inteiros
!2)swap(a,b)
!
troca valores reais, sp
!3)swap(a,b)
!
troca valores de vetor reais, sp
!4)swap(a,b)
!
troca valores complexos, sp
!5)swap(a,b)
!
troca valores de vetor complexo, sp
incremento,
& !calcula incremento e gera vetor de pontos
!1)incremento(a,b,incr,ninterv,incrp)
!
retorna nmero de intervalos inteiro para a-b e incremento
!(ou incremento prximo)
!2)incremento(a,b,vet)
!
Retorna um vetor com 100 pontos no intervalo a-b
!3)incremento(a,b,incrp,vet)
!
Retorna um vetor com os N pontos gerados pelo incremento em a-b
interp_lagrange,
& !interpolao polinomial de Lagrange
interp_newton,
& !interpolao polinomial diferenas divididas
interp_polinomial,
& !interpolao polinomial diferenas divididas
! similar ao (Numerical Recipes)
dif_finita_asc,
& !constri tabela de diferenas finitas ascendente
dif_divididas_asc,
& !constri tabela de diferenas divididas ascendente
! incrementos desiguais
bissecao,
& !zero de funo pelo mtodo da bisseo
newton_raphson,
& !zero de funo pelo mtodo de Newton-Raphson
integ_trapezio,
& !integral definida entre a e b pelo mtodo trapzio
simpson_1_3,
& !integral definida entre a e b pelo mtodo simpson 1/3
der1,
& !derivada primeira da funo usando diferena central
!ok
!ok
!ok
!ok
!ok
!ok
!ok
!ok
!ok
!ok
!ok
!ok
!ok
!ok
!ok
der2,
fit_poli,
euler1_tab,
euler2_tab,
euler_mod_tab
! 3-pontos
& !derivada segunda da funo usando diferena central
! 3-pontos
& !ajuste mnimos quadrados
& !tabela com soluo EDO 1a ordem
! PVI - Euler progressivo
& !tabela com soluo EDO 2a ordem
! PVI - Euler progressivo
!tabela com soluo EDO 1a ordem
! PVI - Euler modificado
contains
!!@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
!!@@@@@@@@@@@@@@@@@@@@
SUB-ROTINAS
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
!!@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine copia_matriz_i(src,dest,n_cop,n_ncop)
!-----------------------------------------------------------------------------!Propsito:
! Copia matriz do tipo inteiro de qualquer tamanho
! Adaptao de sub-rotina do numerical recipes
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
26/01/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
mdulos]: nenhum
![
funes]: nenhuma
![sub-rotinas]: nenhuma
!-----------------------------------------------------------------------------!Argumentos:
! copia_matriz_i(src,dest,n_cop,n_ncop)
!
! src
!
(in) matriz inteira
!
matriz original
! dest
!
(out) matriz inteira
!
matriz copiada
! n_cop
!
(out) inteiro
!
nmero de elementos copiados
! n_ncop
!
(out) inteiro
!
nmero de elementos no copiados
!-----------------------------------------------------------------------------integer,intent(in) ,dimension(:)::src ! fonte
integer,intent(out),dimension(:)::dest ! copia
integer,intent(out)::n_cop,
& ! nmero de dados copiados
n_ncop
! nmero de dados no copiados
n_cop = min(size(src),size(dest))
n_ncop = size(src)- n_cop
dest(1:n_cop) = src(1:n_cop)
end subroutine copia_matriz_i
! menor valor entre os tamanhos

! diferena entre os valores
! copia a matriz
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine copia_matriz_r(src,dest,n_cop,n_ncop)
!-----------------------------------------------------------------------------!Propsito:
! Copia matriz do tipo real de preciso simples de qualquer tamanho
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
26/01/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
7
!ok
!ok
!ok
!ok
!ok
!ok
![
mdulos]: nenhum
![
funes]: nenhuma
!-----------------------------------------------------------------------------!Argumentos:
! copia_matriz_r(src,dest,n_cop,n_ncop)
!
! src
!
(in) matriz real
!
matriz original
! dest
!
(out) matriz real
!
matriz copiada
! n_cop
!
(out) inteiro
!
! n_ncop
!
(out) inteiro
!
!-----------------------------------------------------------------------------real,intent(in) ,dimension(:)::src ! fonte
real,intent(out),dimension(:)::dest ! copia
n_ncop
end subroutine copia_matriz_r

! copia a matriz
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine copia_matriz_d(src,dest,n_cop,n_ncop)
!-----------------------------------------------------------------------------!Propsito:
! Copia matriz do tipo real de preciso dupla de qualquer tamanho
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
26/01/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
mdulos]: nenhum
![
funes]: nenhuma
!-----------------------------------------------------------------------------!Argumentos:
! copia_matriz_d(src,dest,n_cop,n_ncop)
!
! src
!
(in) matriz real,dp
!
matriz original
! dest
!
(out) matriz real,dp
!
matriz copiada
! n_cop
!
(out) inteiro,I4B
!
! n_ncop
!
(out) inteiro
!
!-----------------------------------------------------------------------------real(kind=dp),intent(in) ,dimension(:)::src ! fonte
real(kind=dp),intent(out),dimension(:)::dest ! copia
n_ncop
end subroutine copia_matriz_d
!@@@@@@@@@

! copia a matriz

!-----------------------------------------------------------------------------subroutine swap_i(a,b)
!-----------------------------------------------------------------------------!Propsito:
! Troca posio de dois inteiros
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
26/01/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
mdulos]: nenhum
![
funes]: nenhuma
!-----------------------------------------------------------------------------!Argumentos:
! swap_i(a, b)
!
! a
!
(inout) inteiro
!
primeiro valor
! b
!
(inout) inteiro
!
segundo valor
!-----------------------------------------------------------------------------integer,intent(inout):: a, &! primeiro valor
b
! segundo valor
integer:: temp
! valor temporrio
temp = a
a = b
b = temp
end subroutine swap_i
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine swap_r(a,b)
!-----------------------------------------------------------------------------!Propsito:
! Troca posio de dois reais, preciso simples
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
26/01/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
mdulos]: nenhum
![
funes]: nenhuma
!-----------------------------------------------------------------------------!Argumentos:
! swap_r(a, b)
!
! a
!
(inout) real
!
primeiro valor
! b
!
(inout) real
!
segundo valor
!-----------------------------------------------------------------------------real,intent(inout):: a, &! primeiro valor
b
! segundo valor
real:: temp
! valor temporrio
temp = a
a = b
b = temp
end subroutine swap_r
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine swap_rv(a,b)
!-----------------------------------------------------------------------------!Propsito:
10
! Troca contedo de dois vetores reais, preciso simples, tamanho qualquer

!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
26/01/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
mdulos]: nenhum
![
funes]: nenhuma
!-----------------------------------------------------------------------------!Argumentos:
! swap_rv(a, b)
!
! a
!
(inout) vetor real
!
vetor primeiro valor
! b
!
(inout) vetor real
!
vetor segundo valor
!-----------------------------------------------------------------------------real,intent(inout),dimension(:):: a, &! vetor primeiro valor
b
! vetor segundo valor
real,dimension(size(a))::temp
! vetor temporrio
temp = a
a = b
b = temp
end subroutine swap_rv
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine swap_c(a,b)
!-----------------------------------------------------------------------------!Propsito:
! Troca posio de dois nmeros complexos, preciso simples
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
26/01/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
mdulos]: nenhum
![
funes]: nenhuma
!-----------------------------------------------------------------------------!Argumentos:
! swap_c(a, b)
!
! a
!
(inout) complex
!
primeiro valor
! b
!
(inout) complex
!
segundo valor
!-----------------------------------------------------------------------------complex,intent(inout):: a, &! primeiro valor
b
! segundo valor
complex:: temp
! valor temporrio
temp = a
a = b
b = temp
end subroutine swap_c
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine swap_cv(a,b)
!-----------------------------------------------------------------------------!Propsito:
! Troca contedo de dois vetores complexos, preciso simples, tamanho qualquer
!------------------------------------------------------------------------------

!Autor:
Anibal L. Pereira
26/01/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
mdulos]: nenhum
![
funes]: nenhuma
!-----------------------------------------------------------------------------!Argumentos:
! swap_cv(a, b)
!
! a
!
(inout) vetor complex
!
vetor primeiro valor
! b
!
(inout) vetor complexo
!
vetor segundo valor
!-----------------------------------------------------------------------------complex,intent(inout),dimension(:):: a, &! vetor primeiro valor
b
! vetor segundo valor
complex,dimension(size(a))::temp
! vetor temporrio
temp = a
a = b
b = temp
end subroutine swap_cv
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine gauss(n,a)
!-----------------------------------------------------------------------------!Propsito:
! Soluo numrica de sistema de equaes lineares pelo mtodo da eliminao
! de Gauss
!
! Ateno: pelo menos um dos coeficientes no homogneos tem que ser diferente
!
de zero. Caso contrrio no h garantia de funcionamento correto
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
23/01/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
mdulos]: nenhum
![
funes]: nenhuma
!-----------------------------------------------------------------------------!Argumentos:
! gauss(n, a )
!
! n
!
(in) inteiro
!
nmero de equaes lineares
! a
!
(in/out) matriz real,dp, shape(:,:)
!
na entrada: matriz aumentada original Nx(N+1)
!
na sada : matriz aumentada contendo solues na coluna N+1
!-----------------------------------------------------------------------------real(kind=dp),dimension(:,:),intent(inout)::a
integer,intent(in)::n ! nmero de equaes lineares
integer:: i,
& !
j,
& ! contador
jc, & ! contador, anda pela coluna
jr, &
k,
&
kc, &
nv, &
pv
!nmero da coluna com maior valor absoluto do coeficiente
integer::i9
real(kind=dp):: det=1.0, & ! determinante
eps,
& ! epsilon da mquina
eps2,
& ! dobro de epsilon
r,
& !
temp,
& ! valor temporrio para troca
11
12
tm,
va
!-----------------------------------------------------------------------------!----------------------------------! Determina psilon da mquina
!----------------------------------eps=epsilon(det)
eps2 = eps*2
!-------------------------------------------------! gera a matriz triagonal
!-------------------------------------------------do i=1,n-1
! anda nas colunas, 1,2,...,N-1 (at penltima)
pv=i
! identifica o pivot
!----------------------------do j=i+1,n !na coluna i anda da linha 2 at ltima para achar o maior valor absoluto
if(abs(a(pv,i)) < abs(a(j,i))) pv=j
!pv = nmero da linha que contm maior valor absoluto
end do
!----------------------------if(pv /= i) then
! coloca linha com maior valor nesta posio
do jc=1,n+1
! anda pelas colunas
tm=a(i,jc)
! guarda temporariamente valor da linha i
a(i,jc)=a(pv,jc) ! escreve valor da linha pv na linha i
a(pv,jc)=tm
! escreve valor da linha i na linhas pv
end do
det=-det ! valor do determinante
end if
!----------------------------if(a(i,i) == 0) then
! matriz singular - primeiro pivot igual a zero --> para o processo
print*,"a(",i,i,") = 0 Matriz singular! "
stop
end if
!----------------------------do jr=i+1,n
!eliminao dos coeficientes abaixo do pivot da linha i
if(a(jr,i) /= 0) then
r = a(jr,i)/a(i,i)
do kc=i,n+1
! anda na linha coluna a coluna ate a ltima
temp=a(jr,kc)
a(jr,kc)=a(jr,kc)-r*a(i,kc)
! se o valor for menor que 2*epsilon ele zerado
if(abs(a(jr,kc))<eps2*temp) a(jr,kc)=0.0
end do
end if
end do
end do
!-------------------------------------------------! calcula o determinante
!-------------------------------------------------do i=1,n
det = det*a(i,i)
end do
if(det == 0) then
print*,"Determinante = 0
Matriz singular"
stop
else
! soluo das equaes
a(n,n+1)=a(n,n+1)/a(n,n)
do nv= (n-1),1,-1
va = a(nv,n+1)
do k=(nv+1),n
va = va - a(nv,k)*a(k,n+1)
end do
a(nv,n+1)=va/a(nv,nv)
end do
return
end if
end subroutine gauss
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine entra_linha_matriz_t(mat)
!-----------------------------------------------------------------------------!Propsito:
! Entra valores da linha de uma matriz via teclado

!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
23/01/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
mdulos]: nenhum
![
funes]: nenhuma
!-----------------------------------------------------------------------------!Argumentos:
! entra_linha_matriz_t(mat)
!
! mat
!
(out) real, shape(:,:)
!
matriz com dados obtidos via teclado
!-----------------------------------------------------------------------------real,dimension(:,:),intent(out)::mat
integer::i,n,m
n = size(mat,dim=1)
m = size(mat,dim=2)
! nmero de linhas
! nmero de colunas
do i=1,n
read*, mat(i,1:m)
end do
end subroutine entra_linha_matriz_t
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine entra_linha_matriz_a(mat,arq)
!-----------------------------------------------------------------------------!Propsito:
! Entra valores da linha de uma matriz via arquivo
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
23/01/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
mdulos]: nenhum
![
funes]: nenhuma
!-----------------------------------------------------------------------------!Argumentos:
! entra_linha_matriz_a(mat,arq)
!
! mat
!
(out) real, shape(:,:)
!
matriz com dados obtidos do arquivo
! arq
!
(in) caractere
!
nome do arquivo de dados
!-----------------------------------------------------------------------------real,dimension(:,:),intent(out)::mat
character(len=*),intent(in)::arq
integer::i,n,m
n = size(mat,dim=1)
m = size(mat,dim=2)
! nmero de linhas
! nmero de colunas
open(unit=20, file=arq, status="old", action="read")

do i=1,n
read(unit=20,fmt=*) mat(i,1:m)
end do
close(unit=20)
end subroutine entra_linha_matriz_a
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine inversa_matriz(n,mat,inv)
!-----------------------------------------------------------------------------!Propsito:
! Inverter uma matriz quadrada utilizando o mtodo da eliminao de Gauss
13
14
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
24/01/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
mdulos]: nenhum
![
funes]: nenhuma
!-----------------------------------------------------------------------------!Argumentos:
! inversa_matriz(n,mat,inv)
!
! n
!
(in) inteiro
!
nmero de linhas da matriz quadrada NxN
! mat
!
(in) matriz quadrada real, shape(:,:)
!
matriz a ser invertida
! inv
!
(out) matriz quadrada real,shape(:,:)
!
matriz inversa
!-----------------------------------------------------------------------------real,dimension(:,:),intent(in) ::mat ! matriz
real,dimension(:,:),intent(out)::inv ! matriz inversa
integer,intent(in)::n ! nmero de linhas na matriz original
real,allocatable,dimension(:,:)::mat_aum ! matriz aumentada N x M
integer::m ! nmero de colunas na matriz aumentada => m=2*n
integer:: cci,ccj! contadores
integer:: i,
& ! contador, anda pelas colunas de 1 at n-1
j,
& ! contador, anda pelas linhas de i+1 at n
jc, & ! contador, anda pelas colunas de 1 at m
jr, & ! contador, anda pelas linhas de i+1 at n
k,
&
kc, & ! contador, anda pelas colunas de 1 at m
ma, & ! contador, indo de n+1 at m --> n elementos
nv, &
pv
! nmero da linha que tem o maior valor absoluto
real:: det=1.0, & ! inicializao do determinante
eps,
& ! epsilon da mquina
eps2,
& ! dobro de epsilon
r,
& !
temp,
tm,
va
!-----------------------------------------------------------m = 2*n
allocate(mat_aum(n,m))
mat_aum = 0
!-------------------------------------------------------------! copia a matriz e agrega matriz unitria na matriz aumentada
!-------------------------------------------------------------do cci=1,n
mat_aum(cci,1:n) = mat(cci,1:n)
end do
do cci=1,n
do ccj=n+1,m
if ((cci+n) == ccj)then
mat_aum(cci,ccj) = 1.0
end if
end do
end do
!----------------------------------! Determina psilon da mquina
!----------------------------------eps=epsilon(det)
eps2 = eps*2
!-------------------------------------------------do i=1,n-1
! i=nmero da coluna -- (forward elimination) (n-1)passos
pv=i
! pv=nmero da linha com maior valor absoluto
do j=i+1,n
! j=nmero da linha, sempre comeando 1 unidade a mais que a coluna
if(abs(mat_aum(pv,i)) < abs(mat_aum(j,i))) pv=j
end do
if(pv /= i) then

! se esta linha no contm o maior valor troca as linhas de posio pivota a linha
do jc=1,m
!jc=coluna
tm = mat_aum(i,jc)
mat_aum(i,jc)= mat_aum(pv,jc)
mat_aum(pv,jc)= tm
end do
det = - det ! cada mudana de linha muda o sinal de det
end if
do jr=i+1,n
! anda pela linhas debaixo do pivot
! zera os valores abaixo do pivot
if(mat_aum(jr,i) /= 0) then
r = mat_aum(jr,i)/mat_aum(i,i)
do kc=i,m
! escreve novos valores na linha
temp= mat_aum(jr,kc)
mat_aum(jr,kc)= mat_aum(jr,kc)-r*mat_aum(i,kc)
! se o valor for menor que 2*epsilon ele zerado
if(abs(mat_aum(jr,kc))< eps2*temp) mat_aum(jr,kc)=0.0
end do
end if
end do
end do
!-------------------------------------------------! calcula o terminante da matriz NxN pivotada
!-------------------------------------------------do i=1,n
det = det*mat_aum(i,i)
end do
if(mat_aum(n,n) /= 0) then
!backward elimination
do ma=n+1, m
!coloca a matriz I esquerda da matriz aumentada
mat_aum(n,ma)= mat_aum(n,ma)/mat_aum(n,n)
do nv=n-1,1,-1
va = mat_aum(nv,ma)
do k=nv+1,n
va = va - mat_aum(nv,k)* mat_aum(k,ma)
end do
mat_aum(nv,ma)=va/mat_aum(nv,nv)
end do
end do
end if
!---------------------------------! copia inversa para matriz inv
!---------------------------------do i=1,n
inv(i,:)=mat_aum(i,n+1:m)
end do
deallocate(mat_aum)
end subroutine inversa_matriz
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine interp_lagrange(np,xt,yt,x,yans)
!-----------------------------------------------------------------------------!Propsito:
! Interpola e extrapola usando a frmula de Lagrange (polinmio de Lagrange)
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
26/01/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
mdulos]: nenhum
![
funes]: nenhuma
!-----------------------------------------------------------------------------!Argumentos:
! lagrange_interp(n,xt,yt,x,yans)
!
! np
!
(in) inteiro
!
nmero de pontos da tabela
! xt
!
(in) vetor real
!
vetor com pontos x da tabela
15
16
! yt
!
(in) vetor real
!
vetor com pontos y da tabela
! x
!
(in) real
!
ponto x para o qual a interpolao ser calculada
! yans
!
(out) real
!
ponto y interpolado
!-----------------------------------------------------------------------------integer,intent(in)::np
! nmero de pontos da tabela
real,dimension(0:np-1),intent(in)::xt ! ponto x da tabela
real,dimension(0:np-1),intent(in)::yt ! ponto y da tabela
real,intent(in)::x
! ponto x para interpolao
real,intent(out)::yans
! ponto y interpolado
!------------------------------integer:: i, j
! contadores
real::z ! produto dos fatores
!------------------------------yans=0.0
do i=0,np-1
z=1.0
do j=0,np-1
if(i /= j) z=z*(x-xt(j))/(xt(i)-xt(j))
end do
yans=yans+z*yt(i)
end do
end subroutine interp_lagrange
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine incr_r(a,b,incr,ninterv,incrp)
!-----------------------------------------------------------------------------!Propsito:
! Retorna o prprio incremento ou o incremento mais prximo do incremento solicitado
! que gera um nmeros inteiro de intervalos iniciando em a e terminando em b.
! Tambm retorna o nmero de incrementos
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
27/01/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
mdulos]: nenhum
![
funes]: nenhuma
!-----------------------------------------------------------------------------!Argumentos:
! incr_r(a,b,incr,ninterv,incrp)
!
! a
!
(in) real
!
ponto inicial
! b
!
(in) real
!
ponto final
! incr
!
(in) real
!
increvento sugerido
! ninterv
!
(out) inteiro
!
nmero de intervalos
! incrp
!
(out) real
!
incremento igual ou prximo do desejado para gerar um nmeros de intervalos
!
inteiro em a-b
!-----------------------------------------------------------------------------real,intent(in):: a,
&! ponto inicial
b,
&! ponto final do intervalo
incr
! incremento desejado
integer,intent(out)::ninterv ! nmeros de intervalos em a-b
real,intent(out):: incrp
! incremento mais prximo
!------------------------real::N_pontos

integer::iN_pontos
!--------------------------------------------------! clculo do incremento e nmero de intervalos
!--------------------------------------------------N_pontos=(b-a)/incr
iN_pontos=int(N_pontos)
ninterv=iN_pontos
if(N_pontos /= iN_pontos) then
!Incremento mais prximo
incrp=(b-a)/iN_pontos
else
!Mesmo incremento
incrp=incr
end if
end subroutine incr_r
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine incr1_rv(a,b,vet)
!-----------------------------------------------------------------------------!Propsito:
! Retorna um vetor com 100 pontos no intervalo a-b
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
27/01/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
mdulos]: nenhum
![
funes]: nenhuma
!-----------------------------------------------------------------------------!Argumentos:
! incr1_rv(a,b,vet)
!
! a
!
(in) real
!
ponto inicial
! b
!
(in) real
!
ponto final
! vet
!
(out) vetor real, shape(:)
!
vetor com 100 pontos no intervalo a,b
!-----------------------------------------------------------------------------real,intent(in):: a,
& ! ponto inicial
b
! ponto final do intervalo
real,intent(out),dimension(100):: vet ! vetor de pontos no intervalo a-b
!---------------------------------real(sp)::delta
integer:: i
delta=(b-a)/100
vet=[ a,((a+i*delta),i=2,100) ]
end subroutine incr1_rv
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine incr2_rv(a,b,incrp,vet)
!-----------------------------------------------------------------------------!Propsito:
! Retorna um vetor com os N pontos gerados com o incremento especificado
! iniciando em a e terminando em b
!
!
!ATENO: porque o tamanho do vetor tem que ser conhecido pelo programa que chama
!
esta sub-rotina, esta sub-rotina s possa ser camada depois do vetor
!
ter sido alocado com o tamanho certo, ento:
!
!
primeiro:
call incremento(a,b,incr,ninterv,incrp)
!
!
depois:
allocate(vet(ninterv+1))
!
call incremento(a,b,incrp,vet)
17
18
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
27/01/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
mdulos]: nenhum
![
funes]: nenhuma
!-----------------------------------------------------------------------------!Argumentos:
! incr2_rv(a,b,incrp,vet)
!
! a
!
(in) real
!
ponto inicial
! b
!
(in) real
!
ponto final
! incrp
!
(in) real
!
tamanho dos intervalos em a-b
! vet
!
(out) vetor real
!
vetor com N posies gerado com incrp no intervalo a-b
!-----------------------------------------------------------------------------real,intent(in):: a,
&! ponto inicial
b,
&! ponto final do intervalo
incrp
! incremento
real,intent(out),dimension(:)::vet ! vetor com pontos de a at b
!---------------------------------integer:: i,n
n=size(vet)
vet=[ a,((a+i*incrp),i=1,n-1) ]
end subroutine incr2_rv
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine interp_newton(xt,yt,x,y)
!-----------------------------------------------------------------------------!Propsito:
! Interpolao progressiva de Newton - intervalos iguais, aceita tabela de
! dados com tamanho N (qualquer, maior que 2)
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
24/01/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
mdulos]: nenhum
![
funes]: nenhuma
!-----------------------------------------------------------------------------!Argumentos:
! interp_newton(xt,yt,x,y)
!
! xt
!
(in) vetor real
!
X - pontos da tabela
! yt
!
(in) vetor real
!
Y - pontos da tabela
! x
!
(in) real
!
ponto desejado
! y
!
(out) real
!
ponto interpolado
!-----------------------------------------------------------------------------real,intent(in),dimension(:)::xt,yt ! tabela original
real,intent(in) :: x
! ponto
real,intent(out):: y
! ponto interpolado
!---------------------------------------------------real,allocatable,dimension(:)::hi
! |x-xt| -> diferenas

real,allocatable,dimension(:)::xti,yti ! tabela para interpolao
real,allocatable,dimension(:,:)::dd
! diferenas finitas
real,dimension(1)::po !posio da menor diferena
real,dimension(0:9)::pr ! produtos
real::s,
& ! varivel local
fator
! fatorial
integer:: i,i1,j , &! contador
ipo,
&! posio do ponto mais prximo de x
tam,
&! tamanho do vetor
k
! posio de x0 para criar a tabela de interpolao
!---------------------!--- cria os vetores com tamanho certo
tam=size(xt)
if(tam < 2) stop "tabela necessita de pelo menos 2 pontos"
if(tam >= 10) then
allocate(xti(0:9),yti(0:9),hi(tam),dd(0:9,0:9))
xti=0.0
yti=0.0
hi=0.0
dd=0.0
else
!---tamanho maior que 2 e menor que 10
allocate(xti(tam),yti(tam),hi(tam),dd(tam,tam))
xti=0.0
yti=0.0
hi=0.0
dd=0.0
end if
!--- cria vetor com diferenas
hi=abs(x-xt)
!------------------------------------------------------! tabela original com 10 ou mais pontos
!------------------------------------------------------!
!---localiza a posio mais prxima do ponto x
po=minloc(hi)
ipo=po(1)
if (x == xt(ipo)) then
y=yt(ipo) ! ponto-base no necessita interpolao
return
end if
!--- gera tabela de interpolao com 10 pontos, iniciando em x0
if(ipo-4 >= 0) then
!--- tem 4 elementos anteriores
if(size(xt)-ipo >=5) then
!--- tem 5 elementos posteriores
k=ipo-4
!---cria tabela de interpolao
do i=0,9
xti(i)=xt(k+i)
yti(i)=yt(k+i)
end do
else
!--- no tem 5 elementos depois
k=ipo-(9-(size(xt)-ipo))
do i=0,9
xti(i)=xt(k+i)
yti(i)=yt(k+i)
end do
end if
else
!--- no tem 4 elementos anteriores
k=1
!---cria tabela de interpolao
do i=0,9
xti(i)=xt(k+i)
yti(i)=yt(k+i)
end do
end if
!------------------------------------------------------! tabela com 10 pontos e tabela com menos de 10 pontos
19
20
!------------------------------------------------------!
!---clculos das diferenas finitas
dd(0:9,0)=yti
do i=1,9
! completando a tabela de diferena finita iniciando
k=9-i
do j=0,k
dd(j,i)=dd(j+1,i-1)-dd(j,i-1)
end do
end do
!--- varivel local
s=(x-xti(0))/(xti(1)-xti(0))
!--- gera os produtos
pr(0)=1.0
pr(1)=s
pr(9)=0.0
do j=2,8
pr(j)=pr(j-1)*(s-(j-1))
end do
!--- ponto interpolado
y=dd(0,0)
fator=1.0
do i=1,9
fator=fator*i
y=y+(pr(i)/fator)*dd(0,i)
end do
end subroutine interp_newton
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine interp_polinomial(xt,yt,x,y)
!-----------------------------------------------------------------------------!Propsito:
! Interpolao polinomial - intervalos no necessitam ser iguais, tamanho da
! tabela N (com N qualquer)
!
! Adaptao da sub-rotina polint do numerical recipes
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
24/01/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
mdulos]: nenhum
![
funes]: nenhuma
!-----------------------------------------------------------------------------!Argumentos:
! interp_polinomial(xt,yt,x,y)
!
! xt
!
(in) vetor real
!
X - pontos da tabela - mximo de 10
! yt
!
(in) vetor real
!
Y - pontos da tabela - mximo de 10
! x
!
(in) real
!
ponto desejado
! y
!
(out) real
!
ponto interpolado
!-----------------------------------------------------------------------------real,intent(in),dimension(:):: xt,yt ! pontos x,y da tabela
real,intent(in):: x
! ponto para interpolao
real,intent(out):: y
! valor interpolado
!---------------------------integer:: i,
& ! contador do loop
tn,
& ! tamanho dos vetores
ipvmp
! posio na tabela do menor valor de x-xt
integer,dimension(1):: pvmp
! posio do menor valor de x-xt
real,dimension(size(xt)):: copy1, &
! vetor
copy2, &
! vetor

den,
&
! vetor
d1,
&
! vetor com diferena obtida por xt-x
vdax
! vetor diferena absoluta para x
real::dy ! flutuao no valor y
!-----------------------------------------------------------------------------------tn=size(xt)
! tamanho do vetor xt
if(tn /= size(yt)) stop "<== Programa terminou porque vetores tem tamanhos diferentes"
copy1=yt
! copia o vetor yt nos vetores copy1 e
copy2=yt
!
copy2
d1=xt-x
! subtrai x de todos os pontos x da tabela
vdax=abs(x-xt)
! vetor com diferenas absolutas entre x e os pontos xt
pvmp=minloc(vdax)
ipvmp=pvmp(1)
! ndice do valor tabelado mais perto de x
y=yt(ipvmp)
! valor inicial da interpolao
ipvmp=ipvmp-1
!
do i=1,tn-1
!
den(1:tn-i)=d1(1:tn-i)- d1(1+i:tn)
if (any(den(1:tn-i) == 0.0)) stop "<== Calculo falhou"
den(1:tn-i)=(copy1(2:tn-i+1)-copy2(1:tn-i))/den(1:tn-i)
copy2(1:tn-i)=d1(1+i:tn)*den(1:tn-i)
copy1(1:tn-i)=d1(1:tn-i)*den(1:tn-i)
if (2*ipvmp < tn-i) then
dy=copy1(ipvmp+1)
else
dy=copy2(ipvmp)
ipvmp=ipvmp-1
end if
y=y+dy
end do
end subroutine interp_polinomial
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine dif_finita_asc(xt,yt,dif)
!-----------------------------------------------------------------------------!Propsito:
! Constri a tabela de diferenas finitas ascendente - incrementos equidistantes
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
30/01/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
mdulos]: nenhum
![
funes]: nenhuma
!-----------------------------------------------------------------------------!Argumentos:
! dif_finita_asc(xt,yt,dif)
!
! xt
!
(in) vetor real, shape(:)
!
valores X da tabela
! yt
!
!
valores Y da tabela
! dif
!
(out) matriz, shape(:,:)
!
contm x e as diferenas finitas: y,Dy,D^2y,...
!-----------------------------------------------------------------------------real,dimension(:),intent(in)::xt, yt
real,dimension(:,:),intent(out)::dif
!-----------------------integer:: i,j,k,
& ! contadores
n_pontos
! nmero de pontos
!--------------------------------------------! copia xt e yt para a matriz dif
n_pontos=size(xt)
if(n_pontos > 10) stop "Maximo 10 pontos"
do i=1,n_pontos
dif(i,1)=xt(i)
dif(i,2)=yt(i)
21
22
end do
!print*,"----------- matriz dif ---------"
!print"(8f12.5)",((dif(i,j),j=1,n_pontos+1),i=1,n_pontos)
!stop
do k=3,n_pontos+1 ! anda pelas colunas
j=n_pontos - (k-2)
do i=1,j
dif(i,k)=dif(i+1,k-1)-dif(i,k-1)
end do
end do
end subroutine dif_finita_asc
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine dif_divididas_asc(xt,yt,dif)
!-----------------------------------------------------------------------------!Propsito:
! Constri a tabela de diferenas divididas ascendente - incrementos podem ser
! desiguais
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
30/01/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
mdulos]: nenhum
![
funes]: nenhuma
!-----------------------------------------------------------------------------!Argumentos:
! dif_divididas_asc(xt,yt,dif)
!
! xt
!
!
valores X da tabela
! yt
!
!
valores Y da tabela
! dif
!
(out) matriz, shape(:,:)
!
contm x e as diferenas divididas
!-----------------------------------------------------------------------------real,dimension(:),intent(in)::xt, yt
real,dimension(:,:),intent(out)::dif
!-----------------------integer:: i,j,k,
& ! contadores
n_pontos
! nmero de pontos
!--------------------------------------------! copia xt e yt para a matriz dif
n_pontos=size(xt)
if(n_pontos > 10) stop "Maximo 10 pontos"
do i=1,n_pontos
dif(i,1)=xt(i)
dif(i,2)=yt(i)
end do
do k=3,n_pontos+1
j=n_pontos - (k-2) ! anda dentro da coluna
do i=1,j
! diferena dividida
dif(i,k)=(dif(i+1,k-1)-dif(i,k-1))/(dif(i+(k-2),1)-dif(i,1))
end do
end do
end subroutine dif_divididas_asc
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine bissecao(func,a,b,tol,zero,ifail)
!-----------------------------------------------------------------------------!Propsito:
! Calcula a integral da funo usando o mtodo da bisseo
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
30/01/2009
!Revises:
!------------------------------------------------------------------------------

!DEPENDNCIA:
![
mdulos]: <<<<<< especificado pelo usurio >>>>>>
![
funes]: <<<<<< especificada pelo usurio >>>>>>
!-----------------------------------------------------------------------------!Argumentos:
! bissecao(func,a,b,tol,zero,ifail)
!
! func
!
(in) funo, real, dp
!
funoespecidicada pelo usurio
! a
!
(in) real, dp
!
valores inicial da integral definida
! b
!
(in) real, dp
!
valores final da integral definida
! zero
!
(out) real, dp
!
valores da integral definida
! ifail
!
(out) inteiro
!
valores indicando o status
!-----------------------------------------------------------------------------real(kind=dp),external::func
real(kind=dp),intent(in)::a,b,tol
real(kind=dp),intent(out)::zero
integer,intent(out)::ifail
! indicador de erro
!------------------------real(kind=dp)::a1,b1
! copia local dos limites iniciais
integer:: i,
& ! contador
num_int
! nmero de iteraes
real(kind=dp)::meio_intr ! meio do intervalo
!-----------------------------------------! status e causas de erro
ifail=0
if(func(a)*func(b)>0) then
! 0 raiz pode ser encontrada
ifail=1
! 1 raiz no est dentro do intervalo a-b
return
endif
if(tol < 0) then
ifail=2
! 2 tolerncia invlida tolerncia<0
return
endif
if(a > b) then
ifail=3
! 3 intervalo invlido a>b
return
endif
a1=a
b1=b
num_int=ceiling(log(tol/(b1-a1))/log(0.5_dp))
do i=1,num_int
meio_intr=(a1+b1)/2
if(func(a1)*func(meio_intr)<0)then
b1=meio_intr
else
a1=meio_intr
end if
end do
zero=(a1+b1)/2
end subroutine bissecao
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine newton_raphson(func,x,tol,zero)
!-----------------------------------------------------------------------------!Propsito:
! Calcula zero da funo pelo mtodo de Newton-Raphson
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
04/02/2009
!Revises:
!------------------------------------------------------------------------------
23
24
!DEPENDNCIA:
![
![
!-----------------------------------------------------------------------------!Argumentos:
! newtom_raphson(func,x,tol,zero)
!
! func
!
(in) funo real,dp
!
funo especificada pelo usurio
! x
!
(in) real,dp
!
valores x da abcissa
! tol
!
(in) real,dp
!
valor da tolerncia - erro
! zero
!
(out) real,dp
!
zero da funo
real(kind=dp),intent(in)::x, tol
real(kind=dp),intent(out)::zero
!--------------------------------------------real(kind=dp)::erro,
& !erro
xb,
& !valor prvio de x
y_deriv, & !derivada no ponto x
xt
!raiz
integer:: n
! nmero de iteraes
!----------------------------------erro=1.0D10
xt=x
xb=xt
n=0
do while (erro > tol)
n=n+1
y_deriv=derivada(func,xt)
xt=xt-func(xt)/y_deriv
erro=abs(xt-xb)
xb=xt
end do
zero=xt
end subroutine newton_raphson
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine integ_trapezio(func,a,b,n,it)
!-----------------------------------------------------------------------------!Propsito:
! Calcula a integral da funo entre os pontos a e b utilizando n intervalos
! pelo mtodo do trapzio
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
04/02/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
![
!-----------------------------------------------------------------------------!Argumentos:
! integ_trapezio(func,a,b,n,it)
!
! func
!
(in) funo real,dp
!
! a
!
(in) real,dp
!
! b
!
(in) real,dp
!
valor final da integral definida

! n
!
(in) inteiro
!
nmero de intervalos
! it
!
(out) real,dp
!
valor da integral definida
real(kind=dp),intent(in)::a, b
integer,intent(in)::n
real(kind=dp),intent(out)::it
!--------------------------------------------real(kind=dp)::dx,
& !incremento
s1,
& !parte da soma
s2,
& !parte da soma
p
!ponto
integer:: i
! contador
!----------------------------------dx=(b-a)/n
s1=func(a)+func(b)
p=a
s2=0.0_dp
do i=1,n-1
p=p+dx
s2=s2+func(p)
end do
it=(dx/2.0_dp)*(s1+2_dp*(s2))
end subroutine integ_trapezio
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine simpson_1_3(func,a,b,n,simp)
!-----------------------------------------------------------------------------!Propsito:
! Calcula a integral da funo entre os pontos a e b utilizando n1 intervalos
! pelo mtodo de simpson 1/3
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
04/02/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
![
!-----------------------------------------------------------------------------!Argumentos:
! simpson_1_3(func,a,b,n,it)
!
! func
!
(in) funo real,dp
!
! a
!
(in) real,dp
!
! b
!
(in) real,dp
!
valor final da integral definida
! n
!
(in) inteiro
!
nmero de intervalos
! simp
!
(out) real,dp
!
valor da integral definida
real(kind=dp),intent(in)::a, b
! ponto inicial e final
integer,intent(in)::n
! nmero sugerindo de intervalos
real(kind=dp),intent(out)::simp
! valor da integral
!--------------------------------------------real(kind=dp)::h, & !tamanho do incremento
x
!ponto
integer:: n1, & ! nmeros de intervalos prximo de n, mas sempre par
i
! contador
25
26
!---------------!--------------------------------------------------------------! garante que o nmero de intervalos sempre par, o que garante

! numeros impares de pontos
!
(n=par)===> n1=n (n=impar) ===> n1=n+1
!--------------------------------------------------------------n1=max(n,2)
n1=n1+modulo(n1,2)
h=(b-a)/n1
x=a
simp=func(x)
! simp=f(a)
do i=1,n1-1
x=a+i*h
! anda por cada um dos pontos de x(2) at x(n-1)
simp = simp + (3 -(-1)**i)*func(x) ! soma 4*f(x_impares) e 2*f(x_pares)
end do
x=b
simp = simp + func(x) ! soma ltimo ponto f(b)
simp = h*(simp/3)
end subroutine simpson_1_3
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine der1(func,x,tol,der)
!-----------------------------------------------------------------------------!Propsito:
! Calcula a derivada primeira da funo fornecida no ponto x usando a
! aproximao da diferena central para 3-pontos
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
07/02/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
![
!-----------------------------------------------------------------------------!Argumentos:
! der1(func,x,tol,der)
!
! func
!
(in) funo real,dp
!
! x
!
(in) real,dp
!
valores do ponto no qual ser calculada a derivada primeira
! tol
!
(in) real,dp
!
tolerncia
! der
!
(out) real,dp
!
valor da derivada no ponto x
real(kind=dp),intent(in)::x,tol
real(kind=dp),intent(out)::der
!-----------------------real(kind=dp)::h
! incremento
real(kind=dp),dimension(0:100)::d,
& ! derivadas
e
! diferena entre as derivadas
integer::i ! contador
!--------------------------------------h=1.0
d(0) =0.5*(func(x+h)-func(x-h))/h
do i=1,2
h=h/2
d(i)= 0.5*(func(x+h)-func(x-h))/h
e(i)= abs(d(i))-abs(d(i-1))
end do
i=1

do while ( e(i) > tol .and. (i < 100) )
h=h/2
d(i+2) = 0.5*(func(x+h)-func(x-h))/h
e(i+2) = abs(d(i+2) - d(i+1))
i=i+1
end do
der=d(i+1)
end subroutine der1
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine der2(func,x,tol,der)
!-----------------------------------------------------------------------------!Propsito:
! Calcula a derivada segunda da funo fornecida no ponto x usando a
! aproximao da diferena central para 3-pontos
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
10/02/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
![
!-----------------------------------------------------------------------------!Argumentos:
! der2(func,x,tol,der)
!
! func
!
(in) funo real,dp
!
! x
!
(in) real,dp
!
valores do ponto no qual ser calculada a derivada primeira
! tol
!
(in) real,dp
!
tolerncia
! der
!
(out) real,dp
!
valor da derivada no ponto x
real(kind=dp),intent(in)::x,tol
real(kind=dp),intent(out)::der
!-----------------------real(kind=dp)::h
! incremento
real(kind=dp),dimension(0:100)::d2, & ! derivadas
e
! diferena entre as derivadas
integer::i ! contador
!--------------------------------------h=1.0
d2(0) = (func(x+h)-2*func(x)+func(x-h))/(h*h)
do i=1,2
h=h/2
d2(i)= (func(x+h)-2*func(x)+func(x-h))/(h*h)
e(i)= abs(d2(i))-abs(d2(i-1))
end do
i=1
do while ( e(i) > tol .and. (i < 100) )
h=h/2
d2(i+2) = (func(x+h)-2*func(x)+func(x-h))/(h*h)
e(i+2) = abs(d2(i+2) - d2(i+1))
i=i+1
end do
der=d2(i+1)
end subroutine der2
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine fit_poli(n,xt,yt,coef)
!-----------------------------------------------------------------------------!Propsito:
! Determina os coeficientes do polinmio que ajusta-se a curva pelo mtodo
27
28
! dos mnimos quadrados

!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
11/02/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
mdulos]: fc_rotinas (arquivo fc_rotinas.f03)
![
funes]: nenhuma
![sub-rotinas]: gauss
!-----------------------------------------------------------------------------!Argumentos:
! fit_poli(n,xt,yt,coef)
!
! n
!
(in) inteiro
!
grau do polinmio de ajuste
! xt
!
(in) vetor real
!
vetor com pontos x da tabela
! yt
!
(in) vetor real
!
vetor com pontos y da tabela
! coef
!
(out) vetor real, size(:)
!
coeficientes do polinmio de ajuste
!-----------------------------------------------------------------------------integer,intent(in)::n
! grau do polinmio
real,dimension(:),intent(in)::xt
! ponto x da tabela
real,dimension(:),intent(in)::yt
! ponto y da tabela
real,dimension(:),intent(out)::coef ! coeficientes do polinmio
!------------------------------integer:: i, j,
& ! contadores
je,ij
! contadores
real,dimension(2*n)::xx
! somatorios x
real,dimension(n+1)::B
! vetor B
real,dimension(n+1,n+2)::A
! matriz aumentada
real(kind=dp),dimension(n+1,n+2)::Ad
! matriz aumentada-dupla preciso
!------------------------------!---testa nmero de pontos para o grau do polinmio desejado
if(size(xt) < n+1) stop "Grau do polinmio maior ou igual ao numero de pontos"
!---termos para as equaes normais
do i=1,2*n
xx(i)=sum(xt**i)
end do
!---calculo dos B's
B(1)=sum(yt)
do i=2,n+1
B(i)=sum(yt*xt**(i-1))
end do
!---matriz aumentada
!-----primeira linha
A=0.0
A(1,1)=size(xt)
A(1,n+2)=B(1)
A(1,2:n+1)=xx(1:n+1)
!-----segunda linha em diante
do i=2,n+1
A(i,n+2)=B(i)
A(i,1:n+1)=xx(i-1:i+n)
end do
!---calcula os coeficientes
Ad=A
call gauss(n+1,Ad)
!---coeficientes
coef=Ad(:,n+2)
end subroutine fit_poli

!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine euler1_tab(func,x0,y0,a,b,h,xt,yt)
!-----------------------------------------------------------------------------!Propsito:
! calcula os pares (x,y) do problema do valor inicial da equao diferencial
! ordinria de 1a ordem no intervalo a-b, com passo h
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
14/02/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
![
!-----------------------------------------------------------------------------!Argumentos:
! euler1_tab(func,x0,y0,a,b,h,xt,yt)
!
! func
!
(in) real
!
funo derivada da equao
! x0
!
(in) real
!
valor x inicial
! y0
!
(in) real
!
valor y inicial
! a
!
(in) real
!
valor inicial do intervalo
! b
!
(in) real
!
valor final do intervalo
! h
!
(in) real
!
passo incremental
! xt
!
!
vetor com pontos x
! yt
!
!
vetor com pontos y
!-----------------------------------------------------------------------------real, external::func
! funo derivada
real,intent(in)::x0,
& ! valor x inicial
y0,
& ! valor y inicial
a,
& ! valor inicial do intervalo
b,
& ! valor final do intervalo
h
! passo
real,dimension(:),intent(out)::xt, & ! ponto x da tabela
yt
! ponto y da tabela
!------------------------------------integer:: i
! contador
!------------------------------xt(1)=x0
yt(1)=y0
do i=1,size(xt)-1
xt(i+1)=xt(i)+ h
yt(i+1)=yt(i)+ h * func(xt(i))
end do
end subroutine euler1_tab
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine euler2_tab(edo2f,x0,y0,z0,a,b,h,xt,yt,zt)
!-----------------------------------------------------------------------------!Propsito:
! calcula (x,y,z) do problema do valor inicial da equao diferencial
! ordinria de segunda ordem no intervalo a-b, com passo h
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
14/02/2009
29
30
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
![
![sub-rotinas]:
!-----------------------------------------------------------------------------!Argumentos:
! euler2_tab(edo2f,x0,y0,z0,a,b,h,xt,yt,zt)
!
! edo2f
!
(in) real
!
funo derivada da varivel z
! x0
!
(in) real
!
valor inicial da varivel independente
! y0
!
(in) real
!
valor inicial da varivel y
! z0
!
(in) real
!
valor inicial da varivel z
! a
!
(in) real
!
! b
!
(in) real
!
! h
!
(in) real
!
passo incremental
! xt
!
!
vetor com pontos x
! yt
!
!
vetor com pontos y
! zt
!
!
vetor com pontos z
!-----------------------------------------------------------------------------real, external::edo2f
! funo derivada
& ! valor inicial da varivel independente
y0,
& ! valor inicial y
z0,
& ! valor inicial z
a,
b,
h
! passo
real,dimension(:),intent(out)::xt, & ! pontos x da tabela
yt, & ! ponto y da tabela
zt
! ponto z da tabela
!------------------------------------integer:: i
! contador
!------------------------------!---construo da tabela
xt(1)=x0
yt(1)=y0
zt(1)=z0
do i=1,size(yt)-1
xt(i+1)=xt(i)+h
yt(i+1)=yt(i) + zt(i)* h
zt(i+1)=zt(i)+ edo2f(xt(i),yt(i),zt(i)) * h
end do
end subroutine euler2_tab
!@@@@@@@@@
!-----------------------------------------------------------------------------subroutine euler_mod_tab(edof,x0,y0,a,b,h,tol,xt,yt)
!-----------------------------------------------------------------------------!Propsito:
! calcula (x,y,z) do problema do valor inicial da equao diferencial

! ordinria de primeira ordem no intervalo a-b, com passo h pelo mtodo
! de Euler modificado
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
21/02/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
![
![sub-rotinas]:
!-----------------------------------------------------------------------------!Argumentos:
! euler_mod_tab(edof,x0,y0,a,b,h,tol,xt,yt)
!
! edof
!
(in) real
!
funo derivada
! x0
!
(in) real
!
valor inicial da varivel independente
! y0
!
(in) real
!
valor inicial da varivel y
! a
!
(in) real
!
! b
!
(in) real
!
! h
!
(in) real
!
passo incremental
! tol
!
(in) real
!
tolerncia
! xt
!
!
vetor com pontos x
! yt
!
!
vetor com pontos y
!-----------------------------------------------------------------------------real, external::edof
! funo derivada
& ! valor inicial da varivel independente
y0,
& ! valor inicial y
a,
b,
tol,
& ! tolerncia
h
! passo
real,dimension(:),intent(out)::xt, & ! pontos x da tabela
yt
! ponto y da tabela
!------------------------------------integer:: i,k
! contador
real::yant
! valor anterior
!------------------------------!---construo da tabela
xt(1)=x0
yt(1)=y0
yt(2)=y0+10
do i=1,size(yt)-1
xt(i+1)=xt(i)+h
!---preditor
yt(i+1)=yt(i) + edof(yt(i),xt(i)) * h
yant=yt(i+1)
do k=1,20
!---corretor (processo iterativo)
yt(i+1)=yt(i) + (h/2.0)*(edof(yt(i+1),xt(i+1)) + edof(yt(i),xt(i)))
if (abs(yt(i+1)- yant) > tol) then
yant=yt(i+1)
else
exit
end if
31
32
end do
end do
end subroutine euler_mod_tab
!!@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
!!@@@@@@@@@@@@@@@@@@@@
FUNES
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
!!@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
!@@@@@@@
!-----------------------------------------------------------------------------function derivada(func,x) result(df)
!-----------------------------------------------------------------------------!-----------------------------------------------------------------------------!Propsito:
! Calcula a derivada primeira da funo no ponto x usando diferena central
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
03/02/2009
!Revises:
!-----------------------------------------------------------------------------!DEPENDNCIA:
![
![
!-----------------------------------------------------------------------------!Argumentos:
! derivada(func,x) result(df)
!
! func
!
(in) real,dp
!
! x
!
(in) real,dp
!
valores x especificado pelo usurio
!------------------------------------------! result(df)
!
df - real,dp
!
sada da funo
real(kind=dp),intent(in)::x
real(kind=dp):: df,
& ! derivada
dd1, & ! delta
dd2
! 2*dd1
!-----------------------dd1=1.0D-5
dd2=2.0D-5
df = (func(x+dd1)-func(x-dd1))/dd2
end function derivada
!@@@@@@@
!@@@@@@@
end module fc_rotinas
_______________________________________________________________________________________
arquivo: fc_m1func.f03
module fc_m1func
!------------------------------------------------------------------------------!Propsito:
! Guarda funes definidas pelo usurio
!
!USO:
! Coloque no seu programa fonte a declarao
!
use fc_m1func
!
!COMPILAO:
! (1) deste mdulo
!
f03 fc_constantes.o -c fc_m1func.f03
!

! (2) para usar o mdulo com o programa <prog.f03>
!
f03 -o<prog> fc_constantes fc_rotinas fc_m1func.o <prog.f03>
!------------------------------------------------------------------------------! Arquivo: fc_m1func.f03
!
03/02/2009
!Revises:
implicit none
!------------------------------------------------------------------------! Funes
!------------------------------------------------------------------------public:: fun1,
& !f(x) = x**3 - 3*x**2 - x + 3
!ok
fun2,
& !f(x) = x**3 - 5.0*x**2 + 3.0*x
fun3,
& !f(X) = X**2
fun4,
& !f(x) = (1 + (x/2.0)**2)**2)*pi
fun5,
& !f(x) = cos(x)
fun6,
& !f(x) = cos(4*x)+x*x
edo2f_1!,
& !f(x,y,z)= 2*log(x)+6*x**2+5
!edo2f_2,
& !f(x,y,z)=
!edo2f_4,
& !f(x,y,z)=
!edo2f_5,
& !f(x,y,z)=
!edof_m1,
& !f(y,x)=
!edof_m2,
& !f(y,x)=
!edof_m3,
& !f(y,x)=
!edof_m4
!f(y,x)=
contains
!@@@@@@@
!-----------------------------------------------------------------------------real(kind=dp) function fun1(x)
!-----------------------------------------------------------------------------!Propsito:
! Define funo: f(x)=x**3 - 3*x**2 - x + 3
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
03/02/2009
!Revises: Anibal L. Pereira
16/04/2010
!-----------------------------------------------------------------------------!Argumentos:
! fun1(x)
!
! x
!
(in) real, dp
!
valor da abcissa
!--------------------------------! resultado
!
real,dp
!-----------------------------------------------------------------------------real(kind=dp),intent(in)::x ! valor da abcissa
!------------------------------------fun1 = x**3 - 3.0_dp * x**2 - x + 3_dp
end function fun1
!@@@@@@@
!-----------------------------------------------------------------------------!Propsito:
! Define funo: f(x) = x**3 - 5.0*x**2 + 6.0*x
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
03/02/2009
16/04/2010
!-----------------------------------------------------------------------------!Argumentos:
! fun2(x)
!
! x
!
(in) real, dp
!
valor da abcissa
33
34
!--------------------------------! resultado
!
real,dp
!------------------------------------fun2 = x**3 - 5.0_dp * x**2 + 6.0_dp *x
end function fun2
!@@@@@@@
!-----------------------------------------------------------------------------!Propsito:
! Define funo: f(x) = x**2
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
03/02/2009
16/04/2010
!-----------------------------------------------------------------------------!Argumentos:
! fun3(x)
!
! x
!
(in) real, dp
!
valor da abcissa
!--------------------------------! resultado
!
y - real,dp
!------------------------------------fun3 = x**2
end function fun3
!@@@@@@@
!-----------------------------------------------------------------------------!Propsito:
! Define funo: f(x) = (1 + (x/2.0)**2)**2)*pi
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
03/02/2009
16/04/2010
!-----------------------------------------------------------------------------!Argumentos:
! fun4(x)
!
! x
!
(in) real, dp
!
valor da abcissa
!--------------------------------! resultado
!
y - real,dp
!------------------------------------fun4 = ((1_dp + (x/2.0_dp)**2)**2)*pi_d
end function fun4
!@@@@@@@
!-----------------------------------------------------------------------------!Propsito:
! Define funo: f(x) = cos(x)
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
06/02/2009

16/04/2010
!-----------------------------------------------------------------------------!Argumentos:
! fun5(x)
!
! x
!
(in) real, dp
!
valor da abcissa
!--------------------------------! resultado
!
y - real,dp
!------------------------------------fun5 = cos(x)
end function fun5
!@@@@@@@
!-----------------------------------------------------------------------------real function fun6(x)
!-----------------------------------------------------------------------------!Propsito:
! Define funo: f(x) = cos(4*x)+x*x
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
14/02/2009
16/04/2010
!-----------------------------------------------------------------------------!Argumentos:
! fun6(x)
!
! x
!
(in) real, dp
!
valor da abcissa
!--------------------------------! resultado
!
y - real,dp
!-----------------------------------------------------------------------------real,intent(in)::x ! valor da abcissa
!------------------------------------fun6 = cos(4*x)+x*x
end function fun6
!@@@@@@@
!-----------------------------------------------------------------------------real function fxy1(x,y)
!-----------------------------------------------------------------------------!Propsito:
! Define funo: f(x,y) = (x**3+y**3)/(3*x*y**2)
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
14/02/2009
16/04/2010
!-----------------------------------------------------------------------------!Argumentos:
! fxy1(x,y)
!
! x
!
(in) real
!
valor x
! y
!
(in) real
!
valor y
!--------------------------------! resultado
!
z - real
!-----------------------------------------------------------------------------real,intent(in)::x,y
!------------------------------------fxy1 = (x**3+y**3)/(3*x*y**2)
35
36
end function fxy1

!@@@@@@@
!-----------------------------------------------------------------------------real function edo2f_1(x,y,z)
!-----------------------------------------------------------------------------!Propsito:
! Define funo: edo2f_1(x) = 2*log(x)+6*x**2+5
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
14/02/2009
16/04/2010
!-----------------------------------------------------------------------------!Argumentos:
! edo2f_1(x,y,z)
!
! x
!
(in) real
!
valor da varivel independente
! y
!
(in) real
!
valor da varivel dependente
! z
!
(in) real
!
valor da funo derivada
!--------------------------------! resultado
!
real
!-----------------------------------------------------------------------------real,intent(in)::x,y,z
edo2f_1 = 2*log(x) + 6*x**2 + 5
end function edo2f_1
!@@@@@@@
!-----------------------------------------------------------------------------real function edof_m1(y,x)
!-----------------------------------------------------------------------------!Propsito:
! Define funo: edof_m1(y,x) =
!-----------------------------------------------------------------------------!Autor:
Anibal L. Pereira
21/02/2009
16/04/2010
!-----------------------------------------------------------------------------!Argumentos:
! edof_m1(y,x)
!
! y
!
(in) real
!
valor da varivel dependente
! x
!
(in) real
!
valor da varivel independente
!--------------------------------! resultado
!
real
!-----------------------------------------------------------------------------real,intent(in)::x,y
!------------------------------------edof_m1 = x - y
end function edof_m1
end module fc_m1func
_______________________________________________________________________________________
arquivo: euler1.plt
37

#----------------------------------------------------------# Propsito: mostrar o grfico das solues da equao
#
diferencial cos(4x)+x^2 com y(0)=2
#----------------------------------------------------------# script: euler1.plt
#
#Revises:
#----------------------------------------------------------reset
set pointsize 0.7
set title "Soluo da EDO - cos(4x)+x^2"
set xlabel "x "
set ylabel "f(x) "
plot [0:1] [2:2.35] 2+0.333*x**3 + 0.25*sin(4*x) lt -1
replot "euler1-h05.dados" w p 4 7
set terminal gif
set output "euler1.gif"
replot
set output
set terminal wxt
3. Mtodo de Euler para EDO de ordem superior

O mtodo de Euler padro resolve equaes diferencias ordinrias de primeira ordem.
possvel aplicar o mtodo padro na resoluo de uma equao diferencial ordinria de ordem superior,
decompondo a equao original em um conjunto de equaes diferencias ordinrias de primeira ordem.
Considere a EDO y ' ' ' ' ay ' ' ' by ' 'cy 'ey=g onde o apstrofo indica derivada com relao ao
tempo, assim y ' a derivada primeira, y ' ' a derivada segunda e assim por diante e os valores a, b, c, e e g
constantes ou ento funes conhecidas da varivel independente.
A condio inicial para esta EDO de quarta ordem especificada por: y 0= y 0 , y ' 0= y '0 ,
''
'''
'
''
'''
y ' ' 0= y 0 e y ' ' ' 0= y 0 onde y 0, y 0, y 0 e y 0 so valores conhecidos.
Definindo-se a seguinte mudana de variveis
y ' =u
u ' =v
v '=w
w ' =gawbvcuey
u= y ' , v= y' ' e w= y ' ' ' pode-se escrever:
y 0= y 0
u0= y'0
' ' ou
v 0= y 0
w 0= y '0' '
dy
=u
dt
du
=v
dt
dv
=w
dt
dw
=g awbvcuey
dt
y 0= y 0
u 0= y '0
v 0= y '0'
w 0= y '0' '
que, pelo mtodo de Euler tem a seguinte soluo:
y i1= y iu i h
u i1=u iv i h
v i1=v iw i h
w i1=wi[ gaw ibv icu iey i]h
Por exemplo, admita o caso de um pndulo simples, que descrito pela equao diferencial ordinria de
2
segunda ordem linear
d
g
= .
2
l
dt
38
A soluo deste problema bastante conhecida e tem a seguinte forma: = 0 sin t onde
e 0
so duas constantes a serem determinadas.
g
l
Ento, aplicando o processo de descomposio da equao diferencial ordinria de segunda ordem em duas
equaes diferencias ordinrias de primeira ordem tem-se:
d
g
=
2
l
dt
d
=
dt
onde a velocidade angular do pndulo.
d
g
=
dt
l
O sistema de equao diferencial ordinria de primeira ordem que descreve o problema pode ser resolvido pelo
mtodo de Euler (Euler padro).
i1= i i h
i1= i
g
i h
l
Outro exemplo, bastante similar, o movimento de uma mola (constante elstica k) satisfazendo a lei de
2
d x
k
= x . A soluo deste problema usando o mtodo de Euler
2
m
dt
Hooke. Este problema descrito pela EDO

:
dx
=v
dt
dv
k
= x
dt
m
x i1=x i v i h
k
v i1=v i x i h
m
Atividade 02
1.
programa:
euler2_prog
fxxa2.f03
2.
mdulos:
fc_constantes.f03
fc_rotinas.f03
fc_m1func.f03
3.
scripts:
euler21.plt
4.
arquivos:
euler21.dados
euler21.gif
Exemplifica o uso do mtodo de Euler para a soluo de equao diferencial ordinria de segunda ordem com valor inicial especificado
a2.1) Gere o arquivo de dados euler21.dados que mostra a
2
d y
2 ln x6 x 2=5
2
dx
com
x 0=1
y x 0 = y 1=1
h=0.05. O arquivo euler21.gif contm a soluo exata,

mtodo de Euler progressivo.
soluo do PVI (problema do valor inicial):
y ' x 0= y ' 1=0
e
2
y x =x x ln x 0.5x
a2.2) Gere o arquivo de dados euler22.dados que mostra a
soluo do PVI:
no intervalo [1,10] com
, e a soluo encontradas pelo
y ' ' y '=0
com
x 0=0
y x 0 = y 0=13 e
exata, y t=10 e x 3
y ' x 0= y ' 0=10
39
no intervalo [0,2] com h=0.02. O arquivo euler22.gif contm a soluo
, e a soluo encontradas pelo mtodo de Euler.
a2.3) Gere o arquivo de dados euler23-h03.dados, euler23-h01.dados, euler23-h005.dados e euler23-h001.dados que mostra
t 0=0 , y 0=10 e
as solues do PVI com h=0.03,h=0.01,h=0.005 e h=0.001: y ' '9y ' =0 com
y ' 0=18
soluo exata,
no intervalo [0,2]. Os arquivos euler23-h03.gif, euler23-h01.gif, euler23-h005.gif e euler23-h001.gif contm a
y t=10 e x 3
, e a soluo encontradas pelo mtodo de Euler.
Escreva o programa euler2_prog e salve-o no arquivo fxxa2.f03

________________________________________________________________________________________
arquivo: fxxa2.f03
program euler2_prog
!
!------------------------------------------------------------------------! Propsito: Constri tabela de valores (y,y') soluo da equao
!
diferencial ordinria de 2a ordem com valores iniciais
! x0, y(x0)=y0 e y'(x0)=y'0 utilizando o mtodo de Euler progressivo
!------------------------------------------------------------------------! Arquivo:fxxa2.f03
!
14/02/2009
!Revises:
use fc_rotinas
use fc_m1func
implicit none
integer::i,
& !contador
npassos
real::x0,y0,z0, & ! valores iniciais
a,b,
h,
& ! incremento h
delta
real,allocatable,dimension(:)::xt,yt,zt
!pontos da tabela
!--------------------------------------------------print*, "========================================"
print*, "Entre com o valor inicial x0, y(0) e z(0)"
print*, "========================================"
read*, x0,y0,z0
print*, "============================================"
print*, "Entre com o valor intervalo:",x0,"--- B "
print*, "============================================"
a=x0
read*, b
print*, "===================================="
print*, "Entre com o incremento h "
print*, "===================================="
read*, h
print*,"npassos,delta",npassos,delta
allocate(xt(npassos+1),yt(npassos+1),zt(npassos+1))
xt=0.0
yt=0.0
zt=0.0
!---------------------------------------------------!---funo derivada: edo2f_1= 2*log(x)+6*x**2+5
!
40
call euler2_tab(edo2f_1,x0,y0,z0,a,b,delta,xt,yt,zt)
!---------------------------------------------------open(unit=10, file="euler2.dados", status="replace",action="readwrite")
do i=1,size(yt)
write(unit=10,fmt=*) xt(i),yt(i),zt(i)
end do
close(unit=10)
program euler2_prog
_______________________________________________________________________________________
MDULOS
ver atividade 01
_______________________________________________________________________________________
arquivo: euler2.plt
#----------------------------------------------------------# Propsito: mostrar o grfico da soluo da equao

#
diferencial ordinria de segunda ordem com
# valores iniciais
#----------------------------------------------------------# script: euler2.plt
#
#Revises:
#----------------------------------------------------------reset
set pointsize 0.3
set title "Soluo da EDO - y'' - 2 ln(x) -6x^2 = 5"
set xlabel "x "
set ylabel "f(x) "
plot [0:10] [-1000:6000] x**2 + (x**2)*(log(x))+ 0.5*x**4 lt -1
replot "euler2.dados" w p 4 7
set terminal gif
set output "euler2.gif"
replot
set output
set terminal wxt
4. Mtodo de Euler modificado

O mtodo de Euler padro sofre com dois tipos de erros:
erros de arredondamentos
instabilidade
( truncamentos )
( ou oscilao )
O mtodo de Euler modificado mais acurado e mais estvel que o mtodo de Euler padro.
O mtodo de Euler modificado obtido quando se aplica a regra do trapzio para integrar a equao diferencial
ordinria y ' = f y , x , ento a soluo do tipo:
y i1= y i
h
[ f yi 1 , x i1 f y i , x i ]
2
ou
41
h
y i1= y i [ f y i1 , x i1 f y i , x i ]
2
Este mtodo as vezes chamado de mtodo do ponto do meio, pois utiliza o valor mdio entre os pontos
i1 da funo derivada f, ou seja:
f yi 1 , x i1 f yi , x i
.
2
Caso f x , y seja linear em y, a equao soluo, y i1= y i
h
[ f y i 1 , xi 1 f y i , xi ] , ser linear
2
em y i1 e pode ser resolvida facilmente explicitando-se y i1 .

Se, por outro lado, f y , x no for linear em y, a equao soluo tambm no ser linear em
mtodo de substituio sucessiva deve ser utilizado para encontrar a soluo.
y i1 e o
A soluo pelo mtodo de Euler modificado feita assim:
clculo de y 1
y 1= y 0
h
[ f y 1 , x 1 f y 0 , x 0 ]
2
para o lado direito da equao, a melhor estimativa de

1
y1 = y0
y 1 y 0 , ento:
h
[ f y 0 , x 0 f y 0 , x 0 ]
2
Este o primeiro passo (k=1) do processo iterativo para o clculo de

este primeiro passo se torna idntico ao mtodo de Euler padro.
y 1 . Observe que ao proceder assim
Passa-se ento para a prxima iterao (k=2):
y 21 = y 0
h
f y 11 , x 1 f y 0 , x 0 ] onde y 1= f y 1, x 1 ser o valor y 1
previamente calculado.
[
1
2
Se o processo iterativo do clculo de y 1 parar neste passo, o mtodo chamado de mtodo de Euler preditorcorretor (Euler predictor-corretor method) onde a primeira estimativa (predio) depois corrigida pelo clculo
subsequente (corretor). Se o clculo parar na primeira correo, o mtodo preditor-corretor idntico ao mtodo
Runge-Kutta de segunda ordem.
Mas, no mtodo de Euler modificado o processo no para no clculo da primeiro correo, ele continua
(iterativamente) at que o mdulo da diferena entre o ltimo valor calculado e o penltimo valor calculado seja
menor que um valor especificado (uma tolerncia). Ento:
(k=2)
y 21 = y 0
h
f y 11 , x 1 f y 0 , x 0 ]
[
2
verifica se
y12 y11tol
(k=3)
y 3
1 = y0
h
[ f y 21 , x 1 f y0 , x 0 ]
2
verificase
y 31 y 12tol
(k=4)
y 1 = y 0
h
[ f y 13 , x 1 f y 0 , x 0 ]
2
verificase
y 41 y 31 tol
at a iterao k
42
k 1
y1
(k)
= y 0
h
k
f y1 , x 1 f y 0 , x 0 ]
[
2
verificase
k
y 1 tol
y k1
1
se na iterao k a diferena entre o novo valor calculado e o previamente calculado for menor que a tolerncia o
processo iterativo para e o valor y 1 feito igual a y k1 1 , para ento se passar ao ao clculo do prximo
valor desejado (se for o caso)
calculo do valor, y 2
aplica-se o mesmo processo preditor-corretor descrito para o calculo de

k 1
y2
= y 1
h
k
f y 2 , x 2 f y 1 , x1 ]
[
2
verificase
y2 .
y2k1 y2k tol
calculo do valor y i
O clculo para qualquer ponto feito sempre desta forma, ou seja, repete-se estes procedimentos at o ponto
desejado
y ki11= y i
h
f yi k1 , x i1 f y i , x i ]
[
2
verificase
k1
k
y i1
y i1
tol
Atividade 03
1.
programa:
euler_m_prog
fxxa2.f03
2.
mdulos:
fc_constantes.f03
fc_rotinas.f03
fc_m1func.f03
3.
scripts:
euler_m.plt
4.
arquivos:
euler_m-h05.dados
euler_m-h02.dados
euler_m-h005.dados
euler_m.gif
Exemplifica o uso do mtodo de Euler modificado para a soluo de equao diferencial ordinria com valor inicial especificado
a3.1) Gere o arquivo de dados euler_m1.dados que mostra a soluo do problema do valor inicial:
no intervalo [0,10] com h=0.1 e tolerncia 0.001. O arquivo euler_m1.gif contm a soluo exata,
soluo encontrada pelo mtodo de Euler modificado.
a3.2) Gere o arquivo de dados euler_m2.dados que mostra a
dy
y 0=1
=x y
dx
x
,ea
y=x 12 e
soluo do problema do valor inicial:
y 0=1
no intervalo [0,10]. O arquivo euler_m2.gif contm a soluo exata,

pelo mtodo de Euler modificado.
y=12 x0.45
, e a soluo encontrada
dy
=x e x 2x ,
dx
y x 0 =0.00454 no intervalo [-10,1]. O arquivo euler_m3.gif contm a soluo exata, y=x 2 e x com
a3.3) Gere o arquivo de dados euler_m3.dados que mostra a soluo do problema do valor inicial:
x 0=10
dy 0.9 y
=
dx 12x
x=[-10,5] e y=[0:1] e a soluo encontrada pelo mtodo de Euler modificado.
43
a3.4)
Gere
1
x
2
dy
=e
dx
soluo exata,
arquivo
de
dados
euler_m4.dados
1
2 cos 2 x sin 2 x
2
y=e
1
x
2
sin 2 x
que
y 0=0
mostra
soluo
do
problema
do
valor
inicial:
no intervalo [0,10]. O arquivo euler_m4.gif contm a
com x=[0,10] e y=[-0.8:1] e a soluo encontrada pelo mtodo de Euler modificado.
Escreva o programa euler_m_prog e salve-o no arquivo fxxa3.f03

________________________________________________________________________________________
arquivo: fxxa3.f03
program euler_m_prog
!
!------------------------------------------------------------------------! Propsito: Constri tabela de valores (y,y') soluo da equao
!
diferencial ordinria de 1a ordem com valores iniciais
! y'(0)= utilizando o mtodo de Euler modificado
!------------------------------------------------------------------------! Arquivo:fxxa3.f03
!
21/02/2009
!Revises:
use fc_rotinas
use fc_m1func
implicit none
integer::i,
& !contador
npassos
real::x0,y0,z0, & ! valores iniciais
a,b,
h,
& ! incremento h
tol,
& ! tolerncia
delta
real,allocatable,dimension(:)::xt,yt
!pontos da tabela
!--------------------------------------------------print*, "========================================"
print*, "Entre com o valor inicial x0 e y(0) "
print*, "========================================"
read*, x0,y0
print*, "============================================"
print*, "Entre com o valor intervalo:",x0,"ate B "
print*, "============================================"
a=x0
read*, b
print*, "========================================="
print*, "Entre com o incremento h e a tolerncia"
print*, "========================================="
read*, h,tol
allocate(xt(npassos+1),yt(npassos+1))
xt=0.0
yt=0.0
!---------------------------------------------------!---funo derivada: edof_m1= x-y
call euler_mod_tab(edof_m1,x0,y0,a,b,delta,tol,xt,yt)
44

!---------------------------------------------------open(unit=10, file="euler_m1.dados", status="replace",action="readwrite")
do i=1,size(yt)
write(unit=10,fmt=*) xt(i),yt(i)
end do
close(unit=10)
end program euler_m_prog
_______________________________________________________________________________________
MDULOS
ver atividade 01
_______________________________________________________________________________________
arquivo: euler_m1.plt
#----------------------------------------------------------# Propsito: mostrar o grfico da soluo da equao

#
diferencial ordinria de segunda ordem com
# valores iniciais
#----------------------------------------------------------# script: euler_m1.plt
#
#Revises:
#----------------------------------------------------------reset
set pointsize 0.3
set title "Soluo da EDO - y' = x - y"
set xlabel "x "
set ylabel "f(x) "
plot [0:10] [0:10] x - 1 + 2*exp(-x) lt -1
replot "euler_m1.dados" w p 4 7
set terminal gif
set output "euler_m1.gif"
replot
set output
set terminal wxt

Fiscomp FA-09 2011-1

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Fiscomp FA-09 2011-1

Caricato da

Copyright:

Formati disponibili

Instituto de Fsica Armando Dias Tavares

Departamento de Fsica Aplicada e Termodinmica

Equaes Diferenciais Ordinrias

ltima atualizao: junho 2011

Diego Chagas Garcia

3y=x 2 so equaes diferenciais ordinrias

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

As equaes diferenciais podem ser classificadas quanto ao tipo, a ordem e a linearidade:

linear caso contrrio. A equao x

(geralmente h chamado de passo e feito constante)

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

o que nos leva a

os pares de valores (x, y) so encontrados utilizando-se recursivamente a equao

Esta Folha contm 03 atividade exemplo com ajustes e/ou acrscimos

00 atividades para serem ajustadas e/ou acrescidas

Seu professor de laboratrio (e/ou teoria) poder alterar esta relao !

Cdigo da folha de atividades

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

grfico (arquivo euler.gif) contendo a soluo exata

no intervalo [0,1] com h=0.5, h=0.2 e h=0.05. Construa o

e as trs solues encontradas pelo

mtodo de Euler progressivo.

onde v a velocidade e a acelerao da

. Se a velocidade constante e igual a 40 m/s uma tabela com as

posies x como funo do tempo. Entregue o grfico correspondente.

descreve o crescimento populacional, sendo I o nmero de indivduos. O termo aI

No deixe de substituir os xx pelo cdigo adequado.

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

swap_i, swap_r, swap_rv, swap_c, swap_cv

incr_r, incr1_rv, incr2_rv

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

! menor valor entre os tamanhos

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

! menor valor entre os tamanhos

! menor valor entre os tamanhos

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

! Troca contedo de dois vetores reais, preciso simples, tamanho qualquer

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

open(unit=20, file=arq, status="old", action="read")

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

!---------------!--------------------------------------------------------------! garante que o nmero de intervalos sempre par, o que garante

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

! dos mnimos quadrados

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias

DFAT/Folha Atividades/FiscompFA Equaes Diferenciais Ordinrias