Equações Diferenciais Ordinárias (EDOs)

Documentação das funções do módulo codigos.edos relacionadas à resolução de equações diferenciais ordinárias usando métodos numéricos como Runge-Kutta e Euler.

Documentação

As funções listadas abaixo implementam métodos numéricos para resolver EDOs de primeira e segunda ordem, sistemas de EDOs, com opções para diferentes ordens de Runge-Kutta e visualização de resultados.

Módulo para solução numérica de equações diferenciais ordinárias.

Este módulo implementa métodos numéricos para EDOs: Euler, Runge-Kutta (1ª a 4ª ordem) e diferenças finitas.

Author: Pedro Henrique Rocha de Andrade Date: Dezembro 2025

codigos.edos.runge_kutta(func_input, x0, y0, h, xn, ordem)

Resolve EDOs escalares usando métodos de Runge-Kutta de ordem 1 a 4.

Esta função implementa os métodos de Runge-Kutta para resolver numericamente equações diferenciais ordinárias da forma dy/dx = f(x,y). Os métodos implementados vão da ordem 1 (Euler) até a ordem 4 (Runge-Kutta clássico).

Parâmetros:

• func_input (str) – Expressão matemática para f(x, y) como string. Deve ser uma função válida das variáveis x e y. Exemplos: ‘y’, ‘y - x**2’, ‘sin(x)*y’. Espaços são ignorados e ‘^’ é convertido para ‘**’.

• x0 (float) – Ponto inicial da integração (condição inicial para x). Deve ser um número finito.

• y0 (float) – Valor inicial y(x0). Deve ser um número finito.

• h (float) – Tamanho do passo de integração. Deve ser positivo e dividir exatamente o intervalo (xn - x0), caso contrário será truncado.

• xn (float) – Ponto final da integração. Deve ser diferente de x0.

• ordem (int) – Ordem do método Runge-Kutta. Deve ser 1, 2, 3 ou 4: - 1: Método de Euler (primeira ordem) - 2: Euler modificado (segunda ordem) - 3: Runge-Kutta de terceira ordem - 4: Runge-Kutta clássico (quarta ordem)

Retorna:

• x_vals (list of float) – Lista dos pontos x onde a solução foi calculada, incluindo x0 e xn.

• y_vals (list of float) – Lista dos valores aproximados y(x) correspondentes aos pontos em x_vals.

Levanta:

• ValueError – Se os parâmetros forem inválidos (ver _validate_edo_inputs).

• TypeError – Se os tipos de entrada não forem adequados.

• RuntimeError – Se ocorrer erro durante a avaliação da função f(x,y).

Notas

Os métodos de Runge-Kutta seguem as fórmulas clássicas (Euler, Euler modificado e RK4). Por exemplo, para Euler: y_{n+1} = y_n + h * f(x_n, y_n). Para RK4: y_{n+1} = y_n + (h/6) * (k1 + 2*k2 + 2*k3 + k4), onde k1..``k4`` são os incrementos padrões do método. A estabilidade e precisão aumentam com a ordem do método, mas também o custo computacional.

Exemplos

>>> # Resolver dy/dx = y com y(0) = 1 no intervalo [0, 1]
>>> x_vals, y_vals = runge_kutta('y', 0, 1, 0.1, 1, 4)
>>> print(f"Solução em x=1: {y_vals[-1]:.6f}")  # Aproxima e^1 ≈ 2.718282

>>> # EDO não-linear: dy/dx = y - x²
>>> x_vals, y_vals = runge_kutta('y - x**2', 0, 1, 0.1, 1, 2)

codigos.edos.runge_kutta_sistema(funcs_input, u0, t0, tf, h, ordem)

Resolve sistemas de EDOs usando métodos de Runge-Kutta vetoriais.

Esta função resolve numericamente sistemas de equações diferenciais ordinárias da forma dy/dt = f(t,y), onde y é um vetor de variáveis dependentes. Implementa os métodos de Runge-Kutta de ordem 1 a 4 para sistemas.

Parâmetros:

• funcs_input (list of str) – Lista de expressões matemáticas para as funções f_i(t, y) do sistema. Cada string deve usar notação y[1], y[2], … para as variáveis (indexação 1-based). Exemplo: [‘y[2]’, ‘y[1] - y[2]’].

• u0 (array_like) – Vetor de condições iniciais y(t0). Deve ter o mesmo comprimento que funcs_input. Todos os valores devem ser finitos.

• t0 (float) – Tempo inicial da integração. Deve ser finito.

• tf (float) – Tempo final da integração. Deve ser diferente de t0.

• h (float) – Tamanho do passo de integração. Deve ser positivo.

• ordem (int) – Ordem do método Runge-Kutta (1, 2, 3 ou 4).

Retorna:

• t_vals (list of float) – Lista dos pontos temporais onde a solução foi calculada, incluindo t0 e tf (aproximadamente).

• u_vals (ndarray) – Array de shape (n_pontos, n_equacoes) contendo os valores da solução em cada ponto temporal.

Levanta:

• ValueError – Se as entradas não forem válidas (ver _validate_sistema_edo_inputs).

• TypeError – Se os tipos de entrada não forem adequados.

• RuntimeError – Se ocorrer erro durante a integração do sistema.

Notas

O sistema é resolvido usando a formulação vetorial dos métodos de Runge-Kutta. Em termos práticos, aplica-se a versão vetorial das fórmulas escalares (Euler, RK2/3/4). Por exemplo, em RK4 cada \(k_i\) é um vetor de incrementos e a combinação final segue a soma ponderada usual: y_{n+1} = y_n + (h/6)*(k1+2*k2+2*k3+k4).

Exemplos

>>> # Sistema linear: dy1/dt = y2, dy2/dt = -y1
>>> funcs = ['y[2]', '-y[1]']
>>> y0 = [1, 0]  # y1(0)=1, y2(0)=0
>>> t_vals, y_vals = runge_kutta_sistema(funcs, y0, 0, 2*np.pi, 0.1, 4)
>>> # y_vals[-1] ≈ [cos(2π), -sin(2π)] ≈ [1, 0]

codigos.edos.executar_sistema_edos()

Interface para resolução de sistemas de EDOs usando Runge-Kutta.

codigos.edos.executar_edo_2ordem()

Interface para resolução de EDOs de 2ª ordem convertidas em sistemas.

Exemplo de Uso

"""Exemplo: resolver EDOs com Runge-Kutta (scalar e sistemas).

Executar: python tests/exemplos/exemplo_edos.py
"""
from codigos import EDOs
import numpy as np

if __name__ == '__main__':
    # Exemplo escalar: dy/dx = y, y(0)=1
    x_vals, y_vals = EDOs.runge_kutta('y', 0.0, 1.0, 0.1, 1.0, 4)
    print('RK4 escalar: y(1) ≈', y_vals[-1], 'exato e ≈', np.exp(1.0))

    # Exemplo de sistema
    funcs = ['y[1]', '2*y[2]']
    t_vals, u_vals = EDOs.runge_kutta_sistema(funcs, np.array([1.0, 1.0]), 0.0, 1.0, 0.1, 4)
    print('RK4 sistema: u(1) ≈', u_vals[-1], 'exato [e, e^2] ≈', np.exp(1.0), np.exp(2.0))

Testes de Integração

Coberto pelos seguintes testes:

• Teste global: pytest -q (roda todos os testes do projeto)

• Teste de calcnum: pytest tests/test_inputs_calcnum.py::test_calcnum_inputs_basic -q (valida integração via menu principal)

• Teste individual: pytest tests/test_edos.py -v (testes específicos do módulo)

Teste correspondente: tests/inputs/inputEDOS.txt

Testes Unitários (visíveis)

Testes: test_edos

Links rápidos

• Teste de integração relacionado: tests/test_inputs_calcnum.py::test_calcnum_inputs_basic

• Testes unitários (arquivo): tests/test_edos.py

• Página de testes (docs): Testes: test_edos