Implementar o algoritmo do método de Runge-Kutta clássico de quarta ordem em uma linguagem de programação de sua escolha (e.g., Python, MATLAB, C ou C++).

Passo 1

O enunciado pede para implementar o método de Runge–Kutta clássico de quarta ordem (RK4) para resolver problemas de valor inicial do tipo
y' = f(t,y),\quad y(t_{0}) = y_{0}.
Vamos precisar da fórmula dos incrementos
\begin{aligned} k_{1} &= h\,f\bigl(t_{n},\,y_{n}\bigr),\\\ k_{2} &= h\,f\bigl(t_{n}+\tfrac{h}{2},\,y_{n} + \tfrac{k_{1}}{2}\bigr),\\\ k_{3} &= h\,f\bigl(t_{n}+\tfrac{h}{2},\,y_{n} + \tfrac{k_{2}}{2}\bigr),\\\ k_{4} &= h\,f\bigl(t_{n}+h,\,y_{n} + k_{3}\bigr), \end{aligned}
e da regra de atualização
y_{n+1} = y_{n} + \frac{k_{1} + 2k_{2} + 2k_{3} + k_{4}}{6}.

Passo 2

Primeiro escolhemos uma linguagem (aqui usamos Python). Definimos uma função rk4 que recebe como argumentos a função derivada f(t,y), o instante inicial t0, o valor inicial y0, o instante final tf e o número de passos N. O tamanho do passo é
h = \frac{t_{f}-t_{0}}{N}.

Passo 3

Dentro de rk4 inicializamos listas para armazenar os pontos (t_{n},y_{n}). Depois fazemos um loop de n=0 até N-1, calculando k_{1}, k_{2}, k_{3} e k_{4} conforme a fórmula e atualizando
y_{n+1} = y_{n} + \frac{k_{1}+2k_{2}+2k_{3}+k_{4}}{6},\quad t_{n+1}=t_{n}+h.

Passo 4

Ao final, retornamos as listas de tempos e valores aproximados, que podem ser usadas para plotar a solução ou calcular erros.

Resposta

def rk4(f, t0, y0, tf, N):
 """
 Método de Runge–Kutta 4ª ordem para y' = f(t,y), y(t0)=y0.
 Retorna listas de t e y aproximados de t0 até tf em N passos.
 """
 h = (tf - t0) / N
 t = t0
 y = y0
 ts = [t]
 ys = [y]

 for _ in range(N):
 k\(1=\) h * f(t, y)
 k\(2=\) h * f(t \(+0.5\)*h, y \(+0.5\)*k1)
 k\(3=\) h * f(t \(+0.5\)*h, y \(+0.5\)*k2)
 k\(4=\) h * f(t + h, y + k3)
 y = y + (k\(1+2\)*k\(2+2\)*k\(3+\) k4) / 6
 t = t + h
 ts.append(t)
 ys.append(y)

 return ts, ys

# Exemplo de uso
if __name__ \(==\) "__main__":
 # Exemplo: y' = -2*y + t, y(0)\(=1\), de t\(=0\) a t\(=2\) com 100 passos
 def f(t, y):
 return -2*y + t

 \(t_vals\), \(y_vals\) = rk4(f, t\(0=0.0\), y\(0=1.0\), tf\(=2.0\), N\(=100\))
 # Agora \(t_vals\) e \(y_vals\) contêm a solução aproximada em cada passo.
 for t, y in zip(\(t_vals\), \(y_vals\)):
 print(f"t={t:.2f}, y={y:.6f}")

Exercícios relacionados