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

Cálculo Numérico - Versão Python

10.2 Método de Euler


Nesta seção, contruiremos o mais simples dos métodos para resolver problemas de valor inicial: o método de Euler com passo constante. Por passo constante, queremos dizer que os pontos da malha estão todos igualmente espaçados, isto é:

t(i) = (i - 1)h,i = 1,2,,N. (10.14)

onde h é passo, ou seja, a distância entre dois pontos da malha.

Considere então o problema de valor inicial dado por:

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

Ao invés de tentar solucionar o problema para qualquer t > t(1), iremos aproximar u(t) em t = t(2).

Integrando (10.15) de t(1) até t(2), obtemos: t(1)t(2) u(t)dt = t(1)t(2) f(t,u(t))dt (10.16) u(t(2)) - u(t(1)) = t(1)t(2) f(t,u(t))dt (10.17) u(t(2)) = u(t(1)) +t(1)t(2) f(t,u(t))dt (10.18)

Seja un a aproximação de u(tn). Para obter o método numérico mais simples aproximamos f em [t(1),t(2)] pela função constante f(t,u(t)) f(t(1),u(1)), u(2) = u(1) + f(t(1),u(1))t(1)t(2) dt (10.19) u(2) = u(1) + f(t(1),u(1))(t(2) - t(1)) (10.20) u(2) = u(1) + hf(t(1),u(1)) (10.21)

Este procedimento pode ser repetido para t(3), t(4), , obtendo, assim, o chamado método de Euler:

u(n+1) = u(n) + hf(t(n),u(n)), u(1) = u(1) = u(t(1))(condição inicial). (10.22)

Exemplo 10.2.1. Considere o problema de valor inicial

u(t) = 2u(t) u(0) = 1 (10.23)

cuja solução é u(t) = e2t. O método de Euler aplicado a este problema produz o esquema:

u(k+1) = u(k) + 2hu(k) = (1 + 2h)u(k) u(1) = 1, (10.24)

Suponha que queremos calcular o valor aproximado de u(1) com h = 0,2. Então os pontos t(1) = 0, t(2) = 0,2, t(3) = 0,4, t(4) = 0,6, t(5) = 0,8 e t(6) = 1,0 formam os seis pontos da malha. As aproximações para a solução nos pontos da malha usando o método de Euler são:

u(0) u(1) = 1 u(0,2) u(2) = (1 + 2h)u(1) = 1,4u(1) = 1,4 u(0,4) u(3) = 1,4u(2) = 1,96 u(0,6) u(4) = 1,4u(3) = 2,744 u(0,8) u(5) = 1,4u(4) = 3,8416 u(1,0) u(6) = 1,4u(5) = 5,37824 (10.25)

Essa aproximação é bem grosseira quando comparamos com a solução do problema em t = 1: u(1) = e2 7,38906. Não obstante, se tivéssemos escolhido um passo menor, teríamos obtido uma aproximação melhor. Veja tabela abaixo com valores obtidos com diferentes valores de passo h.









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








u(N) 6,1917 6,7275 7,0400 7,2096 7,2980 7,3432 7,3660








De fato, podemos mostrar que quando h se aproxima de 0, a solução aproximada via método de Euler converge para a solução exata e2. Para isto, basta observar que a solução da relação de recorrência (10.24) é dada por

u(k) = (1 + 2h)k-1. (10.26)

Como t(k) = (k - 1)h e queremos a solução em t = 2, a solução aproximada pelo método de Euler com passo h em é dada por:

u(k) = (1 + 2h)k-1 = (1 + 2h)2 h . (10.27)

Aplicando o limite h 0+, temos:

lim h0+(1 + 2h)2 h = e2. (10.28)

Em Python, podemos computar a solução numérica deste problema de valor inicial via o método de Euler com o seguite código:

#define f(t,u)  
def f(t,u):  
    return 2*u  
 
#tamanho e num. de passos  
h = 0.2  
N = 6  
 
#cria vetor t e u  
t = np.empty(N)  
u = np.copy(t)  
 
#C.I.  
t[0] = 0  
u[0] = 1  
 
#iteracoes  
for i in np.arange(N-1):  
    t[i+1] = t[i] + h  
    u[i+1] = u[i] + h*f(t[i],u[i])  
 
#imprime  
for i,tt in enumerate(t):  
    print("%1.1f %1.4f" % (t[i],u[i]))

Vamos agora, analisar o desempenho do método de Euler usando um exemplo mais complicado, porém ainda simples suficiente para que possamos obter a solução exata:

Exemplo 10.2.2. Considere o problema de valor inicial relacionado à equação logística:

u(t) = u(t)(1 - u(t)) u(0) = 12 (10.29)

Podemos obter a solução exata desta equação usando o método de separação de variáveis e o método das frações parciais. Para tal escrevemos:

du(t) u(t)(1 - u(t)) = dt (10.30)

O termo 1 u(t)(1-u(t)) pode ser decomposto em frações parciais como 1 u + 1 1-u e chegamos na seguinte equação diferencial:

1 u(t) + 1 1 - u(t) du = dt. (10.31)

Integrando termo-a-termo, temos a seguinte equação algébrica relacionando u(t) e t:

ln(u(t)) - ln 1 - u(t) = t + C (10.32)

Onde C é a constante de integração, que é definida pela condição inicial, isto é, u = 12 em t = 0. Substituindo, temos C = 0. O que resulta em:

ln u(t) 1 - u(t) = t (10.33)

Equivalente a

u(t) 1 - u(t) = etu(t) = (1 - u(t))et(1 + et)u(t) = et (10.34)

E, finalmente, encontramos a solução exata dada por u(t) = et 1+et.

Vejamos, agora, o esquema iterativo produzido pelo método de Euler:

u(k+1) = u(k) + hu(k)(1 - u(k)), u(1) = 12. (10.35)

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

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

Para fins de comparação, calculamos a solução exata e aproximada para alguns valores de t e de passo h e resumimos na tabela abaixo:





t Exato Eulerh = 0,1 Eulerh = 0,01




0 12 0,5 0,5




12 e12 1+e12 0,6224593 0,6231476 0,6225316




1 e 1+e 0,7310586 0,7334030 0,7312946




2 e2 1+e2 0,8807971 0,8854273 0,8812533




3 e3 1+e3 0,9525741 0,9564754 0,9529609




Exercícios Resolvidos


ER 10.2.1. Aproxime a solução do problema de valor inicial u(t) = -0,5u(t) + 2 + t (10.36) u(0) = 8 (10.37)

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 exata dada por:

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

Solução. Primeramente itentificamos f(t,u) = -0,5u + 2 + t e construímos o processo iterativo do método de Euler: u(n+1) = u(n) + h(-0,5u(n) + 2 + t(n)),n = 1,2,3, (10.39) u(1) = 8 (10.40)

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

def euler(h,Tmax):  
u=8  
   itmax = Tmax/h;  
for i in np.arange(0,itmax):  
t=i*h  
k1 = -0.5*u+2+t  
u = u + h*k1  
return u  
 
 
sol_exata = 2+8*np.exp(-.5)  
h=1e-1  
for i in np.arange(1,5):  
sol_euler=euler(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) )  
h=h/10

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








Exercícios


E 10.2.1. Resolva o problema de valor inicial a seguir envolvendo uma equação não autônoma, isto é, quando a função f(t,u) depende explicitamente do tempo. Use passo h = 0,1 e h = 0,01. Depois compare com a solução exata dada por u(t) = 2e-t + t - 1 nos intantes t = 0, t = 1, t = 2 e t = 3.

u(t) = -u(t) + t, u(0) = 1. (10.41)

Resposta.





t Exato Euler   h = 0,1 Euler   h = 0,01




0 1 1 1




1 2e-1 0,7357589 0,6973569 0,7320647




2 2e-2 + 1 1,2706706 1,2431533 1,2679593




3 2e-3 + 2 2,0995741 2,0847823 2,0980818




E 10.2.2. Resolva o prolema de valor inicial envolvendo uma equação não linear usando passo h = 0,1 e h = 0,01.

u(t) = cos(u(t)) u(0) = 0, (10.42)

Depois compare com a solução exata dada por

u(t) = tan -1 e2t - 1 2et . (10.43)

nos intantes t = 0, t = 1, t = 2 e t = 3.

Resposta.





t Exato Euler   h = 0,1 Euler   h = 0,01




0 0 0 0




1 0,8657695 0.8799602 0.8671764




2 1,3017603 1.3196842 1.3035243




3 1,4713043 1.4827638 1.4724512




E 10.2.3. Resolva a seguinte problema de valor inicial linear com passo h = 10-4 via método de Euler e compare a solução obtida com o valor exato y(t) = esen (t) em t = 2:

y(t) = cos(t)y(t) y(0) = 1. (10.44)

Resposta. Aproximação via Euler: 2,4826529, exata: esen (2) 2,4825777. Erro relativo aproximado: 3 × 10-5.

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!