Método de Euler

Euler explícito

A grande maioria das equações diferenciais de primeira ordem não podem ser resolvidas analiticamente. Para o comportamento a longo prazo de uma solução podemos tentar esboçar um campo de direções, mas se precisamos conhecer mais especificamente como uma solução se comporta, precisamos de outra ferramenta. Os métodos numéricos nos permitem obter soluções aproximadas para as equações diferenciais.

Começando com uma problema genérico de valor inicial:

$${\frac {dy}{dt}}=f\left(t,y\right)\qquad y\left(t_{0}\right)=y_{0}$$

Considerando que conhecemos a função ${\textstyle f\left(t,y\right)}$ e os valores na condição inicial, assumimos que é tudo contínuo de forma que sabemos que uma solução de fato vai existir. Temos então para ${\textstyle t=t_{0}}$:

$$\left.{\frac {dy}{dt}}\right|_{t=t_{0}}=f\left(t_{0},y_{0}\right)$$

Dessa forma podemos escrever uma reta tangente à curva ${\textstyle y\left(t\right)}$ no ponto ${\textstyle \left(t_{0},y_{0}\right)}$ usando a inclinação ${\textstyle f\left(t_{0},y_{0}\right)}$:

$$y=y_{0}+f\left(t_{0},y_{0}\right)\left(t-t_{0}\right)$$

Para visualizar melhor esta equação, podemos fazer ${\textstyle t_{0}=0}$, ficmos então com ${\textstyle y=y_{0}+f\left(t_{0},y_{0}\right)t}$. Desta forma, fica ainda mais evidente que esta é uma equação de reta com inclinação ${\textstyle f\left(t_{0},y_{0}\right)}$, e quando ${\textstyle t=t_{0}}$ temos ${\textstyle y=y_{0}}$, ou seja, uma reta que passa pelo ponto ${\textstyle \left(t_{0},y_{0}\right)}$. Para ${\textstyle t_{0}\neq 0}$ temos apenas um deslocamento no eixo.

Então se ${\textstyle t_{1}}$ é perto o suficiente de ${\textstyle t_{0}}$, a equação da reta vai estar perto do valor atual da solução em ${\textstyle t_{1}}$. Então podemos escrever:

$$y_{1}=y_{0}+f\left(t_{0},y_{0}\right)\left(t_{1}-t_{0}\right)$$

Podemos repetir o processo, usando agora ${\textstyle y_{1}=y\left(t_{1}\right)}$ como valor inicial, então:

$$y_{2}=y_{1}+f\left(t_{1},y_{1}\right)\left(t_{2}-t_{1}\right)$$

Ou de maneira genérica:

$$y_{n+1}=y_{n}+f\left(t_{n},y_{n}\right)\left(t_{n+1}-t_{n}\right)$$

Podemos ainda reescrever o passo como ${\textstyle t_{n+1}-t_{n}=\Delta t}$, de forma que ficamos com:

$$y_{n+1}=y_{n}+f\left(t_{n},y_{n}\right)\Delta t$$

Outra forma de visualizar o resultado, é considerar a reta:

$$y=y_{n}+f\left(t_{n},y_{n}\right)\left(t-t_{n}\right)$$

Como a solução aproximada para o intervalo ${\textstyle \left[t_{n},t_{n+1}\right]}$. Então com um conjunto de retas podemos ter uma aproximação para a solução como um todo.

Exemplo: Decaimento

O primeiro exemplo de aplicação é o decaimento radiativo, cuja equação diferencial é:

$${\frac {dN}{dt}}=-\lambda N$$

Onde ${\textstyle N}$ é a quantidade de partículas que sofrem o decaimento e ${\textstyle \lambda }$ a taxa no qual o decaimento ocorre.

• Notem que a mesma equação pode descrever a diminuição de uma população estéril (${\textstyle N}$ sendo a quantidade de indivíduos vivos e ${\textstyle \lambda }$ a taxa de mortalidade) ou a descarga de um circuito RC.
• A aplicação do método a este exemplo de primeira ordem nos leva a seguinte relação de recorrência

$${\begin{aligned}N_{n+1}&=N_{n}+f\left(t_{n},N_{n}\right)\Delta t\\N_{n+1}&=N_{n}-\lambda N_{n}\Delta t\\N_{n+1}&=N_{n}\left(1-\lambda \Delta t\right)\end{aligned}}$$

Ou mais explicitamente:

$${\begin{aligned}N\left(t_{n+1}\right)&=\left[1-\lambda \Delta t\right]N\left(t_{n}\right)\\N\left(t_{n}+\Delta t\right)&=\left[1-\lambda \Delta t\right]N\left(t_{n}\right)\end{aligned}}$$

Implementando:

import matplotlib.pyplot as plt   #Biblioteca para plotar gráficos
import numpy as np                #Biblioteca com funções matemáticas
N =[10**6];nt=6;lam=0.1;dt=0.1    #Parâmetros

tau=np.log(2)/lam                 #Tempo final em que vamos obter o erro
fac = 1-lam*dt                    #Função calculada
for i in range(int(nt*tau/dt)+1): #Vamo calcular um múltiplo da meia vida
  N.append(fac*N[i])              #Salvamos o novo valor
  print(i*dt,N[i])                #printamos o resultado

plt.plot(N)                       #Construimos o gráfico
plt.show()                        #Plotamos

Euler implícito

A equação da reta obtida no euler explícito pode ser obtida a partir da definição da derivada:

$${\frac {dy}{dt}}=f\left(t,y\right)\approx {\frac {y\left(t+\Delta t\right)-y\left(t\right)}{\Delta t}}\longrightarrow y\left(t+\Delta t\right)\approx y\left(t\right)+f\left(t,y\right)\Delta t$$

Mas também podemos escrever a derivada como:

$${\frac {dy}{dt}}=f\left(t,y\right)\approx {\frac {y\left(t\right)-y\left(t-\Delta t\right)}{\Delta t}}\longrightarrow y\left(t\right)\approx y\left(t-\Delta t\right)+f\left(t,y\right)\Delta t$$

Mantendo a notação:

$$y_{n+1}=y_{n}+f\left(t_{n+1},y_{n+1}\right)\Delta t$$

O termo ${\textstyle f\left(t_{n+1},y_{n+1}\right)}$ não é conhecido, por isso temos uma equação implícita para ${\textstyle y_{n+1}}$. Métodos implícitos podem ser usados quando temos restrições muito rigorosas no método explícito devido a condições de estabilidade.

Exemplo: Decaimento

Trabalhando novamente com o decaimento radioativo:

$${\frac {dN}{dt}}=-\lambda N$$

Vamo ter então:

$${\begin{aligned}N_{n+1}&=N_{n}+f\left(t_{n+1},N_{n+1}\right)\Delta t\\N_{n+1}&=N_{n}-\lambda N_{n+1}\Delta t\\N_{n+1}\left(1+\lambda \Delta t\right)&=N_{n}\\N_{n+1}&={\frac {N_{n}}{1+\lambda \Delta t}}\end{aligned}}$$

Ou mais explicitamente:

$${\begin{aligned}N\left(t_{n}+\Delta t\right)&={\frac {N\left(t\right)}{1+\lambda \Delta t}}\end{aligned}}$$

Uma comparação entre os dois métodos de Euler para o caso do decaimento é simples. Lembando da fórmula recursiva de ambos os casos:

$$N\left(t_{n}+\Delta t\right)=N\left(t\right)\left[1-\lambda \Delta t\right]\qquad e\qquad N\left(t_{n}+\Delta t\right)=N\left(t\right)\left[{\frac {1}{1+\lambda \Delta t}}\right]$$

E fazendo uma expansão em série de Taylor em torno de ${\textstyle 0}$, escrevendo ${\textstyle x=\lambda \Delta t}$, temos:

$${\frac {1}{1+x}}=\sum _{n=0}^{\infty }{\frac {f^{\left(n\right)}\left(a\right)\left(x-a\right)^{n}}{n!}}=\left(1-x\right)+\sum _{n=2}^{\infty }{\frac {f^{\left(n\right)}\left(a\right)\left(x-a\right)^{n}}{n!}}$$

Então os termos são iguais até a primeira ordem, sendo assim uma boa aproximação.

Implementando o método de euler implícito, temos:

import matplotlib.pyplot as plt   #Biblioteca para plotar gráficos
import numpy as np                #Biblioteca com funções matemáticas
N =[10**6];nt=6;lam=0.1;dt=0.1    #Parâmetros

tau=np.log(2)/lam                 #Meia-vida
fac = 1+lam*dt                    #Função calculada
for i in range(int(nt*tau/dt)+1): #Vamo calcular um múltiplo da meia vida
  N.append(N[i]/fac)              #Salvamos o novo valor
  print(i*dt,N[i])                #printamos o resultado

plt.plot(N)                       #Construimos o gráfico
plt.show()                        #Plotamos

Avaliação de erro

Para o cálculo de erros deste exemplo, utilizamos bastante a meia-vida como um valor caratectístico do sistema, principalmente para nos basearmos até definir até onde a simulação vai rodar. A meia vida é simplesmente o tempo necessário para a quantidade de núcleos cair para a metade do valor inicial. Isto é, primeiro temos que a solução analítica é simplesmente:

$$N=N_{0}e^{-\lambda t}$$

Então a meia vida é quando ${\textstyle t=\tau }$:

$${\frac {N_{0}}{2}}=N_{0}e^{-\lambda \tau }\longrightarrow \tau ={\frac {\ln \left(2\right)}{\lambda }}$$

Erros computados

Erro 1: curva numérica vs exata

import numpy as np                #Biblioteca com recursos matemáticos
import matplotlib.pyplot as plt   #Biblioteca para plotar gráficos
N0=10**6;nt=6;lam=0.001;dt=100    #Parâmetros

exp = 1-lam*dt                    #Função calculada para o método explícito
imp = 1+lam*dt                    #Função calculada para o método implícito
NE  = [N0]                        #Lista de valore para o método explícito
NI  = [N0]                        #Lista de valore para o método implícito
T   = [0]                         #Lista de tempos no qual vamos calcular N

tau=np.log(2)/lam                 #Tempo final em que vamos obter o erro

#Solução numérica
for i in range(int(nt*tau/dt)+1): #Vamo calcular um múltiplo da meia vida
  NE.append(exp*NE[i])            #Explícito
  NI.append(NI[i]/imp)            #Implícito
  T.append((i+1)*dt)              #Tempo

#Solução analítica
t = np.arange(0.0,nt*tau, 1)      #Tempo
NA =N0*np.exp(-lam*t)             #Solução

#Construimos o gráfico
plt.plot(T,NE,color='blue', label='Explícito')                             #Solução explícita
plt.plot(T,NI,color='orange', label='Implícito')                           #Solução implícita    
plt.plot(t,NA,color='green', label='Sol. Exata')                           #Solução exata           
plt.title('Decaimento radioativo para  λ = '+str(lam)+' e dt = '+str(dt))  #Título
plt.legend()                                                               #Legenda das curvas
plt.xlabel('Tempo [s]');plt.ylabel('Número de Núcleos [N]')                #Legenda dos eixos
plt.ticklabel_format(style='plain')                                        #Desativar a notação científica
plt.show()                                                                 #Exibir o resultado

Erro 2: Curva de erro pra diferentes dt

import numpy as np                #Biblioteca com recursos matemáticos
import matplotlib.pyplot as plt   #Biblioteca para plotar gráficos
N0 =10**6;lam=0.001;nt=6          #Parâmetros
dt1=100;dt2=200;dt3=50

def sol_metodo(dt,N0,lam,nt):
  """Função para calcular a solução de acordo com o método de Euler e
  retornar o erro comparado a solução analítica e o tempo equivalente"""
  #dt   - Intervalo do passo
  #N0   - Número inicial de Núcleos
  #lam  - Lambda
  #nt  - Quantidade de meia vidas que vamos caclular
  N=[N0]            #Solução
  D=[0]             #Erro
  T=[0]             #Tempo
  frac = (1-lam*dt) #Funçao calculada
  tau=np.log(2)/lam                    #Meia-vida
  for i in range(1,int(nt*tau/dt)+1):  #Vamo calcular um múltiplo da meia vida
    N.append(frac*N[i-1])              #Solução numérica
    T.append(i*dt)                     #Tempo no qual achamos a solução
    err=abs(N[i]-N0*np.exp(-lam*T[i])) #Erro
    D.append(err)                      #Guardamos o erro
  return(D,T)                          #Retorno o erro

(D1,T1) = sol_metodo(dt1,N0,lam,nt)    #Solução para dt1
(D2,T2) = sol_metodo(dt2,N0,lam,nt)    #Solução para dt2
(D3,T3) = sol_metodo(dt3,N0,lam,nt)    #Solução para dt3

#Construimos o gráfico
plt.plot(T1,D1,color='blue', label='dt = '+str(dt1)+' s')              #Solução para dt1
plt.plot(T2,D2,color='orange', label='dt = '+str(dt2)+' s')            #Solução para dt2
plt.plot(T3,D3,color='green', label='dt = '+str(dt3)+' s')             #Solução para dt3
plt.title('Comparação dos erros para dierentes dt (Euler explícito)')  #Título
plt.legend()                                                           #Legenda das curvas
plt.xlabel('Tempo [s]');plt.ylabel('Erro[abs(N-Nmétodo)]')             #Legenda dos eixos
plt.ticklabel_format(style='plain')                                    #Desativar a notação científica
plt.show()                                  

Erro 3: Erro em relação a dt com um t fixo

import numpy as np                         #Biblioteca com recursos matemáticos
import matplotlib.pyplot as plt            #Biblioteca para plotar gráficos
N0 =10**6;lam=0.001                        #Parâmetros
dt=[1/10**(i) for i in np.arange(2.9,-0.1,-0.3)]
tfin=[(1,'ob','-k'),(4,'sr','-m')]         #Tuplas com os tempos finais e os marcadores principais e do fit
y="log";x="log"                            #Se os eixos vão ser "linear" ou "log" 

def sol_metodo(dtT,N0,lam,t):
  """Função para calcular a solução de acordo com o método de Euler e
  retornar o erro comparado a solução analítica"""
  #dtT  - Intervalo do passo em unidade de tau
  #N0   - Número inicial de Núcleos
  #lam  - Lambda
  #t    - Tempo em que vamos pegar a solução, múltiplo da meia-vida
  N=N0
  T=np.log(2)/lam                  #Tempo final em que vamos obter o erro
  dt=dtT*T                         #Intervalo de tempo em segundos
  frac = (1-lam*dt)                #Funçao calculada
  for i in range(1,int(t*T/dt)+1): #Vamo calcular os passos necessários para 4000s
    N=frac*N                       #Solução numérica
  err =abs(N-N0*np.exp(-lam*i*dt)) #Erro
  return(err)                      #Retorno o erro

for t in tfin:                                  #Percorremos todos os tempos finais
  E=[]                                          #Lista para guardar todos os erros com
  for d in dt:
    E.append (sol_metodo(d,N0,lam,t[0]))               #Computamos o erro para cada dt
  plt.plot(dt,E,t[1], label='t = '+str(t[0])+' τ')     #Plot dos marcadores
  plt.plot(dt,E,'--'+t[1][1])                          #Plot Tracejado
  m, b = np.polyfit(np.log(np.array(dt)),np.log(np.array(E)), 1) #Uma curva para fitar os logaritmos
  label='ln(erro) = {:.2f} + {:.2f} ln(Δt)'.format(b,m)
  plt.plot(dt, np.e**b*np.array(dt)**m,t[2],label=label)         #Tiramos a exponencial do logaritmo

#Configuramos o gráfico
plt.title('Erro X dt')                               #Título
plt.legend()                                         #Legenda das curvas
plt.xlabel('Δt  [τ]')                                #Legenda dos eixos
plt.ylabel('Erro[abs(N-Nmétodo)]')  
plt.ticklabel_format(style='plain')                  #Desativar a notação científica
plt.xscale(x);plt.yscale(y)                          #Escala
plt.show()                                           #Exibir o resultado

Erro teórico

Outro caminho que podemos tomar para obtermos o método de Euler, é através da expansão em série de Taylor de uma função ${\textstyle y\left(t+\Delta t\right)}$ em torno do ponto ${\textstyle y\left(t\right)}$. Lembrando que a expansão em série de Taylor de uma função ${\textstyle f\left(x\right)}$ em torno de ${\textstyle a}$ é dada por:

$$f\left(x\right)=\sum _{n=0}^{\infty }{\frac {f^{\left(n\right)}}{n!}}\left(a\right)\left(x-a\right)^{n}$$

Então fazendo esta expansão e escrevendo ${\textstyle t'=t+\Delta t}$

$${\begin{aligned}y\left(t'\right)&=\sum _{n=0}^{\infty }{\frac {y^{\left(n\right)}}{n!}}\left(t\right)\left(t'-t\right)^{n}\\&=y\left(t\right)+\Delta ty'\left(t\right)+\sum _{n=2}^{\infty }{\frac {y^{\left(n\right)}}{n!}}\left(t\right)\Delta ^{n}\end{aligned}}$$

Podemos olhar ${\textstyle f^{\left(n\right)}\left(a\right)}$ com mais atenção uma vez que tecnicamente nosssa variável da função que estamos expandindo é ${\textstyle t'}$.

$${\frac {d}{dt'}}y\left(t'\right)\approx {\frac {y\left(t'+\Delta t'\right)-y\left(t'\right)}{\Delta t'}}$$

Considerando que ${\textstyle \Delta t}$ é constante, então: ${\textstyle \Delta t'=\Delta t}$, e sendo o ponto ${\textstyle a=t}$, temos:

$${\frac {d}{dt'}}y\left(t'\right)\approx {\frac {y\left(t'+\Delta t\right)-y\left(t'\right)}{\Delta t}}={\frac {d}{dt}}f\left(t'\right)\longrightarrow \left.{\frac {d}{dt}}y\left(t'\right)\right|_{t'=t}=y'\left(t\right)$$

De forma que ficamos então apenas com:

$${\begin{aligned}y\left(t+\Delta t\right)&=y\left(t\right)+f\left(t,y\right)\Delta t+\sum _{n=2}^{\infty }{\frac {y^{\left(n\right)}\left(t\right)}{n!}}\Delta t^{n}\end{aligned}}$$

Os primeiros dois termos então correspondem ao método de Euler, e o somatório se torna o erro ao jogarmos fora. O menor grau que desprezamos é ${\textstyle n=2}$, então o erro local é ${\textstyle Err\left(\Delta t\right)\propto \Delta t^{2}}$. E como o número de passos é dado por ${\textstyle N=t/\Delta t}$ então após ${\textstyle N}$ passos temos uma estimativa de erro global dada por ${\textstyle Err\left(\Delta t,t\right)\propto N\cdot \Delta t^{2}}$ ou apenas ${\textstyle Err\left(\Delta t,t\right)\propto \Delta t}$. Cálculos mais detalhados da estimativa do erro podem ser encontrados em textos matemáticos.

Exemplo: SIR

O modelo SIR é um modelo de epidemia compartimental no qual separamos a população em três compartimentos:

• ${\textstyle S}$: População suscetível
• ${\textstyle I}$: População infectada
• ${\textstyle R}$: População de recuperados

O modelo SIR é descrito então pelo seguinte conjunto de equações:

$${\begin{aligned}{\frac {dS}{dt}}&=-\beta SI\\{\frac {dI}{dt}}&=\beta SI-\gamma I\\{\frac {dR}{dt}}&=\gamma I\end{aligned}}$$

Onde temos as seguintes variáveis:

• ${\textstyle \beta }$: transmissibilidade
• ${\textstyle \gamma }$: taxa de recuperação
  • É o inverso do tempo que a pessoa permanece infectada ${\textstyle \tau ={\frac {1}{\gamma }}}$.

Neste modelo, as pessoas podem se transferir entre os compartimento apenas em um sentido ${\textstyle S\rightarrow I\rightarrow R}$, e pode-se destacar que ${\textstyle R}$ comporta tanto pessoas que se curaram e tornaram-se imunes, quanto falecimentos, em todo, caso, são pessoas que não podem ser suscetíveis a infecção novamente. Como a população total ${\textstyle N}$ é constante, temos ${\textstyle {\dot {N}}=0}$ e por conservação:

$${\dot {S}}+{\dot {I}}+{\dot {R}}=0$$

Desta forma só precisamos resolver duas equações a cada passo. Além disso podemos considerar que a transmissibilidade de uma doença depende da população total, de forma que ${\textstyle \beta \left(N\right)={\widehat {\beta }}/N}$, sendo ${\textstyle {\widehat {\beta }}}$ um parâmetro próprio da doença e independente da população. Substituindo e reescrevendo cada compartimento como uma fração da população total, ao invés de números totais, isto é ${\textstyle x=X/N}$, seja ${\textstyle x}$ um compartimento qualquer, então podemos reescrever o sistema como:

$${\begin{aligned}{\frac {ds}{dt}}&=-{\widehat {\beta }}si\\{\frac {di}{dt}}&={\widehat {\beta }}si-\gamma i\\{\frac {dr}{dt}}&=-\left({\frac {ds}{dt}}+{\frac {di}{dt}}\right)\end{aligned}}$$

Um ponto interessante é a condição de epidemia. A segunda equação nos dá a variação de infectados, para termos epidemia precisamos que este valor positivo, isto é ${\textstyle {\frac {di}{dt}}>0}$, logo:

$${\begin{aligned}\left({\widehat {\beta }}s-\gamma \right)i&>0\\{\widehat {\beta }}s&>\gamma \\{\widehat {\beta }}\tau &>{\frac {1}{s}}\end{aligned}}$$

Considerando como condição inicial que ${\textstyle S\approx N}$, isto é, praticamente toda população é suscetível, logo ${\textstyle s=1}$ e temos então o seguinte limiar ${\textstyle {\widehat {\beta }}\tau \gtrapprox 1}$ para uma condição inicial de epidêma. Podemos definir assim o número reprodutivo básico:

$$R_{0}\equiv {\widehat {\beta }}\tau >1$$

Além disso, um modelo SIRS (no qual recuperados podem tornar-se suscetíveis novamente) e com atraso foi discutido aqui

import matplotlib.pyplot as plt            #Biblioteca para plotar gráficos

b   = 0.1  #Transmissibilidade
tau = 11   #Tempo que a pessoa permanece infectada
g   = 1/tau#Taxa de recuperação
N   = 1000  #População total
Np  = 5000  #Número de passos
dt  = 0.5  #Intervalo de tempo
#Valores iniciais
i=[1/N]; s=[1-i[0]]; r=[0]; t=[0]
T=[s[0]+i[0]+r[0]]  #Total

for it  in range(Np):
  s.append(s[it]-dt*b*s[it]*i[it])
  i.append(i[it]+dt*(b*s[it]*i[it]-g*i[it]))
  r.append(1-(i[it+1]+s[it+1]))
  t.append(dt+it*dt)
  T.append(s[it+1]+i[it+1]+r[it+1])

plt.plot(t,i) #Infectados 
plt.plot(t,s) #Suscetíveis
plt.plot(t,r) #Recuperados
plt.plot(t,T) #Total

Exemplo: Sistema massa-mola

Podemos escrever o problema geral da mecânica clássica como:

$$m{\frac {d^{2}x}{dt^{2}}}=f\left(x,v,t\right)$$

O método de Euler é um método para equações de 1ª ordem, então transformando em um sistema de equações de primeira ordem, escrevendo ${\textstyle {\frac {dx}{dt}}=v}$, temos:

$${\begin{aligned}m{\frac {dv}{dt}}&=f\left(x,v,t\right)\\{\frac {dx}{dt}}&=v\left(t\right)\end{aligned}}$$

E pela segunda lei de Newton ${\textstyle f=ma}$, então ficamos simplesmente com:

$${\begin{aligned}{\frac {dv}{dt}}&=a\left(t\right)\\{\frac {dx}{dt}}&=v\left(t\right)\end{aligned}}$$

E aplicando o método de Euler:

$${\begin{aligned}v\left(t+\Delta t\right)&=v\left(t\right)+a\left(t\right)\Delta t\\x\left(t+\Delta t\right)&=x\left(t\right)+v\left(t\right)\Delta t\end{aligned}}$$

Agora tendo a lei de Hooke:

$$m{\frac {d^{2}x}{dt^{2}}}=-kx$$

E reescrevendo ${\textstyle \omega ^{2}={\frac {k}{m}}}$, temo que:

$${\begin{aligned}{\frac {dv}{dt}}&=-\omega ^{2}x\left(t\right)\\{\frac {dx}{dt}}&=v\left(t\right)\end{aligned}}$$

Onde ${\textstyle -\omega ^{2}x\left(t\right)=a\left(t\right)}$. Então o método de Euler fica:

$${\begin{aligned}v\left(t+\Delta t\right)&=v\left(t\right)-\omega ^{2}x\left(t\right)\Delta t\\x\left(t+\Delta t\right)&=x\left(t\right)+v\left(t\right)\Delta t\end{aligned}}$$

A solução analítica do sistema é dada por:

$${\begin{aligned}v\left(t\right)&=-\omega x_{0}\sin \left(\omega t+\phi \right)\\x\left(t\right)&=x_{0}\cos \left(\omega t+\phi \right)\end{aligned}}$$

Onde podemos ver que a energia e conserva:

$$E=V+T={\frac {1}{2}}kx\left(t\right)^{2}+{\frac {1}{2}}mv\left(t\right)^{2}$$

Sendo ${\textstyle v\left(0\right)=0}$, então:

$$E={\frac {1}{2}}kx_{0}^{2}={\text{constante}}$$

import matplotlib.pyplot as plt            #Biblioteca para plotar gráficos

Np  = 200000              #Número de passos
dt  = 0.001               #Intervalo de tempo
m=1  ; k= 1.; w2= k/m     #Constantes
x=[1]; v=[0]; t=[0]; E=[k*(x[0]**2)/2+m*(v[0]**2)/2] #Valores iniciais

#Método de Euler
for it  in range(Np):
  x.append(x[it]+dt*v[it])
  v.append(v[it]-dt*x[it]*w2)
  E.append(k*x[it+1]**2/2+m*v[it+1]**2/2)
  t.append(dt+it*dt)

plt.plot(t,x) #Posição 
plt.plot(t,v) #Velocidade
plt.plot(t,E) #Energia

Exemplo: Modelo de Lotka Volterra

Além disso temos uma discussão sobre o Modelo de Lotka-Volterra e também sobre Modelo de Lotka-Volterra amortecido, que além da discussão apresenta uma solução numérica utilizando o Método de Euler, com a única diferença de um termo de amortecimento. Uma vez que zerarmos este termo, retornamos ao Modelo de Lotka-Volterra clássico.

Principais materiais utilizados

1. Erro de truncamento (REAMAT, UFRGS)
2. Euler's Method (Paul Dawkins, Universidade Lamar)
3. Forward and Backward Euler Methods (Michael Zeltkevic, Instituto de Tecnologia de Massachusetts)
4. Método de Euler (REAMAT, UFRGS)