Use o botão abaixo para reportar erros ou dar sugestões.

Cálculo Numérico - Versão Python

10.10 Método de Adams-Bashforth


Seja o problema de valor inicial u(t) = f(t,u(t)) (10.247) u(t0) = a (10.248)

Nos métodos de passo simples, os valores calculados para f t(n),u(t(n)) nos passos anteriores são desprezados ao calcular o próximo passo. Nos métodos de passo múltiplo, os valores de f t,u), nos passos n, n + 1, ..., n + s - 1 são utilizados ao calcular f em t(n+s).

Integrando a equação diferencial no intervalo [t(n+s-1),t(n+s)], obtemos:

u(n+s) = u(n+s-1) +t(n+s-1)t(n+s) f(t,u(t))dt (10.249)

No método de Adams-Bashforth, o integrando em (10.249) é aproximado pelo polinômio que interpola f(t(k),u(k)) para k = n,n + 1,n + 2,,n + s - 1, isto é: u(n+s) = u(n+s-1) +t(n+s-1)t(n+s) p(t)dt (10.250)

onde p(t) é polinômio de grau s - 1 dado na forma de Lagrange por:

p(t) = j=0s-1 f(t(n),u(n)) k=0,kjs-1 t - t(n+k) t(n+j) - t(n+k) (10.251)

Agora observamos que

t(n+s-1)t(n+s) p(t)dt = h j=0s-1β jf(t(n+j),u(n+j)) (10.252)

onde

βj = 1 ht(n+s-1)t(n+s) k=0,kjs-1 t - t(n+k) t(n+j) - t(n+k)dt (10.253)

e obtemos a relação de recorrência: u(n+s) = u(n+s-1) + h j=0s-1β jf(t(n+j),u(n+j)) (10.254)

Observe que a integral envolvida no cálculo dos coeficientes βj em (10.253) pode ser simplificada via a mudança de variáveis t = t(n+s-1) + hτ: βj = 01 k=0,kjs-1τ + s - k - 1 j - k dτ (10.255) = (-1)s-j-1 j!(s - j - 1)!01 k=0,kjs-1(τ + s - k - 1)dτ (10.256) = (-1)s-j-1 j!(s - j - 1)!01 k=0,ks-j-1s-1(τ + k)dτ (10.257)

Observação 10.10.1 (Ordem do método de Adasm-Bashforth). Da teoria de interpolação (ver capítulos 6 e 9), temos que o erro de aproximação da integral de uma função suficientemente suave por um polinômio interpolador em s pontos é de ordem s + 1. Assim, o erro local de truncamento do método de Adams-Bashforth com s passos é s + 1 e, portanto, o erro global de truncamente é de ordem s.

Exemplo 10.10.1. Calcule os coeficientes de Adams-Bashforth para s = 2 e, depois, construa seu processo iterativo. β0 = -01(τ + 2 - 1 - 1)dτ = -1 2 (10.258) β1 = 01(τ + 2 - 0 - 1)dτ = 3 2 (10.259)

O processo iterativo é dado por:

y(n+2) = y(n) + h 2 3f t(n+1),u(t(n+1)) - f t(n),u(t(n)) (10.260)

Exemplo 10.10.2. Calcule os coeficientes e de Adams-Bashforth para s = 3 e, depois, construa o processo iterativo. β0 = 1 201(τ + 3 - 1 - 1) (τ + 3 - 2 - 1)dτ = 5 12 (10.261) β1 = -01(τ + 3 - 0 - 1) (τ + 3 - 2 - 1)dτ = -4 3 (10.262) β2 = 1 201(τ + 3 - 0 - 1) (τ + 3 - 1 - 1)dτ = 23 12 (10.263)

O processo iterativo é dado por:

y(n+3) = y(n) + h 12 23f t(n+2),u(t(n+2)) - 16f t(n+1),u(t(n+1)) + 5f t(n),u(t(n)) (10.264)

Observação 10.10.2. Os coeficientes do método de Adams-Bashforth de ordem s podem, alternativamente, ser obtidos exigindo que o sistema seja exato para f(t,u) = t0, f(t,u) = t1, f(t,u) = t2, …, f(t,u) = ts-1.

Exemplo 10.10.3. Obtenha o método de Adams-Bashforth para s = 4 como u(n+4) = u(n+3) +t(n+3)t(n+4) f(t,u(t))dt (10.265) u(n+4) = u(n+3) + h m=03b mf(n+m) (10.266) u(n+4) = u(n+3) + h b 3f(n+3) + b 2f(n+2) + b 1f(n+1) + b 0f(n) (10.267)

Para isso devemos obter [b3,b2,b1,b0] tal que o método seja exato para polinômios até ordem 3. Podemos obter esses coeficientes de maneira análoga a obter os coeficientes de um método para integração.

Supondo que os nós t(k) estejam igualmente espaçados, e para facilidade dos cálculos, como o intervalo de integração é [t(n+3),t(n+4)], translade t(n+3) para a origem tal que [t(n),t(n+1),,t(n+4)] = [-3h, - 2h, - h,0,h].

Considere a base [1,t,t2,t3] e substitua f(t) por cada um dos elementos desta basa, obtendo: 0h1dt = h = h b 0(1) + b1(1) + b2(1) + b3(1) (10.268) 0htdt = h2 2 = h b0(0) + b1(-h) + b2(-2h) + b3(-3h) (10.269) 0ht2dt = h3 3 = h b0(0)2 + b 1(-h)2 + b 2(-2h)2 + b 3(-3h)2 (10.270) 0ht3dt = h4 4 = h b0(0)3 + b 1(-h)3 + b 2(-2h)3 + b 3(-3h)3 (10.271)

que pode ser escrito na forma matricial 1 1 1 1 0 - 1 - 2 - 3 0 1 4 9 0 - 1 - 8 - 27 b0 b1 b2 b3 = 1 12 13 14 (10.272)

Resolvendo o sistema obtemos

[b0,b1,b2,b3] = - 9 24,37 24, - 59 24,55 24 (10.273)

fornecendo o método de Adams-Bashforth de 4 estágios u(n+4) = u(n+3) + h 24[55f(n+3) - 59f(n+2) + 37f(n+1) - 9f(n)] (10.274)

A tabela abaixo mostra as coeficientes do método de Adams-Bashforth para até 8 passos.










1 1
2 - 1 2 3 2
3 5 12 - 4 3 23 12
4 - 3 8 37 24 -59 24 55 24
5 251 720 -637 360 109 30 -1387 360 1901 720
6 - 95 288 959 480 - 3649 720 4991 720 - 2641 480 4277 1440
7 19087 60480 - 5603 2520 135713 20160 - 10754 945 235183 20160 - 18637 2520 198721 60480
8 - 5257 17280 32863 13440 - 115747 13440 2102243 120960 - 296053 13440 242653 13440 - 1152169 120960 16083 4480









Observação 10.10.3. Note que os métodos de múltiplo passo requerem o conhecimento dos s valores previamente computados para calcular y(n+s). Assim, para inicializar um algoritmo com mais de um passo, não é suficiente conhecer a condição inicial. Usualmente, calcula-se os primeiros s passos usando um algoritmo de passo simples da mesma ordem do método múltiplo passo a ser aplicado.

Exercícios resolvidos


ER 10.10.1. Resolva numericamente o problema de valor inicial dado por: y(t) = 1 + y(t) (10.275) y(0) = 0 (10.276)

aplicando o método de Adams-Bashforth de dois passos e inicializando o método através do método de Euler modificado. Calcule o valor de y(1) com passo de tamanho h = 0,1.

Solução. Primeiro observamos que o processo resursivo do método de Adams é dado por:
y(n+2) = y(n+1) + h 2 3f t(n+1),u(t(n+1)) - f t(n),u(t(n)) ,n = 1,2, (10.277)

O valor inicial é dado por y(1) = 0. No entanto, para inicializar o método, precisamos calcular y(2), para tal, aplicamos o método de Euler modificado: k1 = 1 + 0 = 1 (10.278) k2 = 1 + 0,1 = 1,1 1,0488088 (10.279) y(2) = 0,1 2 1 + 1,0488088 = 0,10244044 (10.280)

Aplicando o método de Adams-Bashforth, obtemos: y(1) = 0 (10.281) y(2) = 0,10244044 (10.282) y(3) = 0,20993619 (10.283) y(4) = 0,32243326 (10.284) y(5) = 0,43993035 (10.285) y(6) = 0,56242745 (10.286) y(7) = 0,68992455 (10.287) y(8) = 0,82242165 (10.288) y(9) = 0,95991874 (10.289) y(10) = 1,10241584 (10.290) y(11) = 1,24991294 (10.291)

A seguinte rotina implementa o método:

def f(t,u):  
return np.sqrt(1+u)  
 
def adams_bash_2(h,Tmax,u1):  
dim=np.size(u1)  
itmax=np.int(Tmax/h)  
u=np.empty((itmax+1,dim))  
u[0,:]=u1  
 
#inicaliza com RK2  
k1 = f(0,   u[0,:])  
k2 = f(h, u[0,:] + k1* h)  
u[1,:] = u[0,:] + (k1+k2)* h/2  
 
fn_0=k1  
for i in np.arange(0,itmax-1):  
t=(i+1)*h  
fn_1 = f(t,   u[i+1,:])  
u[i+2,:] = u[i+1,:] + h*(-.5*fn_0 + 1.5*fn_1)  
fn_0=fn_1  
return u  
 
 
 
 
 
u0=0  
h=1e-1  
Tmax=1  
u=adams_bash_2(h,Tmax,u0)  
 
print u

Esta parte do material ainda não foi contruída. Clique em e inicie a editá-la agora mesmo. Veja outras formas de participar clicando aqui.

Exercícios


Esta parte do material ainda não foi contruída. Clique em e inicie a editá-la agora mesmo. Veja outras formas de participar clicando aqui.

Creative Commons License Este texto é disponibilizado nos termos da licença Creative Commons Atribuição-CompartilhaIgual 3.0 Não Adaptada (CC-BY-SA 3.0). Página gerada em 15/5/2019 às 15:24:50.

Informe erros ou edite você mesmo!