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

Cálculo Numérico - Versão Python

10.3 Método de Euler melhorado


O método de Euler estudado na Seção 10.2 é aplicação bastante restrita devido à sua pequena precisão, isto é, normalmente precisamos escolher um passo h muito pequeno para obter soluções de boa qualidade, o que implica um número elevado de passos e, consequentemente, alto custo computacional.

Nesta seção, contruiremos o método de Euler melhorado ou método de Euler modificado ou, ainda, método de Heun. Para tal, considere o problema de valor inicial dado por:

u(t) = f(t,u(t)),t > t(1) u(t(1)) = a. (10.45)

Assim como fizemos para o método de Euler, integramos (10.45) de t(1) até t(2) e obtemos: t(1)t(2) u(t)dt = t(1)t(2) f(t,u(t))dt (10.46) u(t(2)) - u(t(1)) = t(1)t(2) f(t,u(t))dt (10.47) u(t(2)) = u(t(1)) +t(1)t(2) f(t,u(t))dt (10.48)

A invés de aproximar f(t,u(t)) como uma constante igual ao seu valor em t = t(1), aplicamos a regra do trapézio (ver 9.2.2) à integral envolvida no lado direito da expressão, isto é:

t(1)t(2) f(t,u(t))dt = f t(1),u(t(1)) + f t(2),u(t(2)) 2 h + O(h3) (10.49)

onde h = t(2) - t(1). Como o valor de u(t(2)) não é conhecido antes de o passo ser realizado, aproximamos seu valor aplicando o método de Euler: ũ(t(2)) = u(t(1)) + hf t(1),u(t(1)) (10.50)

Assim obtemos: u(t(2)) = u(t(1)) +t(1)t(2) f(t,u(t))dt (10.51) u(t(1)) + f t(1),u(t(1)) + f t(2),u(t(2)) 2 h (10.52) u(t(1)) + f t(1),u(t(1)) + f t(2),ũ(t(2)) 2 h (10.53) (10.54)

Portanto, o método recursivo de Euler melhorado assume a seguinte forma:

ũ(k+1) = u(k) + hf(t(k),u(k)), u(k+1) = u(k) + h 2 f(t(k),u(k)) + f(t(k+1),ũ(k+1)) , u(1) = a(condição inicial). (10.55)

Que pode ser escrito equivalentemente como:

k1 = f(t(k),u(k)), k2 = f(t(k+1),u(k) + k 1), u(k+1) = u(k) + hk1 + k2 2 , u(1) = a(condição inicial). (10.56)

Aqui k1 e k2 são variáveis auxiliares que representam as inclinações e devem ser calculadas a cada passo. Esta notação é compatível com a notação usada nos métodos de Runge-Kutta, uma família de esquemas iterativos para aproximar problemas de valor inicial, da qual o método de Euler e o método de Euler melhorado são casos particulares. Veremos os métodos de Runge-Kutta na Seção 10.7.

Exercícios Resolvidos


ER 10.3.1. Resolva pelo método de Euler melhorado problema de valor inicial do Exercício Resolvido 10.2.1: u(t) = -0,5u(t) + 2 + t (10.57) u(0) = 8 (10.58)

Usando os seguinte passos: h = 10-1, h = 10-2, h = 10-3, h = 10-4 e h = 10-5 e compare a solução aproximada em t = 1 com a solução obtida pelo método de Euler e a solução exata dada por:

u(t) = 2t + 8e-t2u(1) = 2 + 8e-12 6,85224527770107 (10.59)

Solução. Primeramente itentificamos f(t,u) = -0,5u + 2 + t e construímos o processo iterativo do método de Euler melhorado: k1 = f(t(n),u(n)) = -0,5u(n) + 2 + t(n) (10.60) ũ = u(n) + hk 1 (10.61) k2 = f(t(n+1),ũ) = -0,5ũ + 2 + t(n+1) (10.62) u(n+1) = u(n) + h(k 1 + k2),n = 1,2,3, (10.63) u(1) = 8(condição inicial). (10.64)

O seguinte código pode ser usado para implementar no Python a recursão acima:

def euler_mod(h,Tmax):  
u=8  
   itmax = Tmax/h;  
for i in np.arange(0,itmax):  
t=i*h  
k1 = -0.5*u+2+t  
u_til = u + h*k1  
k2 = -0.5*u_til+2+(t+h)  
u=u+h*(k1+k2)/2  
return u  
 
 
 
sol_exata = 2+8*np.exp(-1/2)  
for h in [1e-1, 1e-2, 1e-3, 1e-4, 1e-5]:  
sol_euler=euler_mod(h,1);  
erro_relativo = np.fabs((sol_euler-sol_exata)/sol_exata)  
print("h=%1.0e - u(1) =~ %1.7f - erro_relativo = %1.1e" % (h, sol_euler, erro_relativo) )  

A seguinte tabela resume os resultados obtidos:









h 10-1 10-2 10-3 10-4 10-5








Euler 6,7898955 6,8461635 6,8516386 6,8521846 6,8522392








εrel 9,1e-03 8,9e-04 8,9e-05 8,9e-06 8,9e-07








Euler mod. 6,8532949 6,8522554 6,8522454 6,8522453 6,8522453








εrel 1,5e-04 1,5e-06 1,5e-08 1,5e-10 1,5e-12








Exercícios


Esta seção carece de exercícios. 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!