Módulos

Módulos visíveis do pacote codigos.

Módulo principal do projeto de Cálculo Numérico.

Este módulo fornece uma interface interativa unificada para todos os algoritmos implementados: conversões de bases, sistemas lineares, interpolação, ajuste de curvas, integração e EDOs.

Author: Pedro Henrique Rocha de Andrade Date: Dezembro 2025

codigos.calcnum.menu_bases()

codigos.calcnum.menu_sistemas()

codigos.calcnum.menu_interpolacao()

codigos.calcnum.menu_ajustes()

codigos.calcnum.menu_integracoes()

codigos.calcnum.menu_edos()

Submenu interativo para resolver Equações Diferenciais Ordinárias (EDOs). Oferece métodos RK1..RK4, sistemas e EDOs de segunda ordem.

codigos.calcnum.menu_raizes()

Menu interativo para os métodos de cálculo de raízes (Bisseção, Newton, Secante).

codigos.calcnum.menu_principal()

Menu principal do pacote de Cálculo Numérico.

Apresenta as opções principais (Bases, Sistemas, Interpolações, Ajustes de EDOs, Integração Numérica e Métodos de Raízes).

codigos.calcnum.main()

Módulo para métodos de busca de raízes de equações.

Este módulo implementa algoritmos numéricos para encontrar raízes de funções: bisseção, Newton-Raphson e secante.

Author: Pedro Henrique Rocha de Andrade Date: Fevereiro 2026

codigos.raizes.f(x, func_str)

Avalia func_str em x com ambiente seguro (sem builtins).

Parâmetros:

• x (float) – Valor de avaliação.

• func_str (str) – Expressão Python da função em x (ex.: ‘x**2 - 4’).

Retorna:

Valor de f(x).

Tipo de retorno:

float

Levanta:

ValueError – Em caso de erro na avaliação.

codigos.raizes.plotar_funcao(func_str, a=None, b=None, raiz=None, grafico=None, verbose=False, title=None)

Plota a função f(x) opcionalmente mostrando a raiz.

Parâmetros:

• func_str (str) – Expressão Python de f(x).

• a (float, optional) – Intervalo de plotagem (padrão: [-10, 10] se None).

• b (float, optional) – Intervalo de plotagem (padrão: [-10, 10] se None).

• raiz (float, optional) – Ponto da raiz a ser destacado.

• grafico (bool or None, optional) – Controla se o gráfico será exibido. Se None, segue verbose (True mostra o gráfico).

• verbose (bool, optional) – Habilita saídas e, por padrão, ativa o gráfico.

codigos.raizes.bissecao(func_str, a, b, tol, max_iter, verbose=False, grafico=None)

Método da bisseção para encontrar raiz de uma função dada por string.

Parâmetros:

• func_str (str) – Expressão Python de f(x) (ex.: 'x**2 - 4').

• a (float) – Intervalo inicial [a, b] com sinais opostos.

• b (float) – Intervalo inicial [a, b] com sinais opostos.

• tol (float) – Tolerância para critério de parada.

• max_iter (int) – Número máximo de iterações.

• verbose (bool, optional) – Se True, imprime detalhes de cada iteração e ativa o gráfico por padrão.

• grafico (bool or None, optional) – Controla plotagem: se None e verbose for True, o gráfico é mostrado.

Retorna:

Tupla (raiz_aproximada, n_iter) ou (None, 0) se os sinais em a/b não forem opostos.

Tipo de retorno:

(float, int)

codigos.raizes.newton(func_str, x0, tol, max_iter, verbose=False, a=None, b=None)

Método de Newton-Raphson para encontrar raiz de função dada por string.

Parâmetros:

• func_str (str) – Expressão Python de f(x).

• x0 (float) – Chute inicial.

• tol (float) – Tolerância para critério de parada.

• max_iter (int) – Número máximo de iterações.

• verbose (bool, optional) – Se True imprime detalhes de cada iteração.

Retorna:

Tupla (raiz_aproximada, n_iter) ou (None, n_iter) se houver erro.

Tipo de retorno:

(float, int)

codigos.raizes.secante(func_str, x0, x1, tol, max_iter, verbose=False, a=None, b=None)

Método da secante para encontrar raiz de função dada por string.

Parâmetros:

• func_str (str) – Expressão Python de f(x).

• x0 (float) – Dois chutes iniciais.

• x1 (float) – Dois chutes iniciais.

• tol (float) – Tolerância para critério de parada.

• max_iter (int) – Número máximo de iterações.

• verbose (bool, optional) – Se True imprime detalhes de cada iteração.

Retorna:

Tupla (raiz_aproximada, n_iter) ou (None, n_iter) em caso de erro.

Tipo de retorno:

(float, int)

codigos.raizes.pedir_dados_raizes(metodo=None)

Lê os dados necessários para o método de raízes.

Se metodo for None, comporta-se como modo interativo completo (executa o método e plota o resultado). Se metodo for uma das strings 'bissecao', 'newton' ou 'secante', apenas lê os parâmetros e retorna uma tupla (func_str, tol, max_iter, params) para uso por menus externos (compatibilidade com menu_raizes).

Em modo interativo, protege contra EOFError para permitir execuções em ambientes não interativos (scripts/tests).

codigos.raizes.dados()

Menu interativo para métodos de busca de raízes.

Módulo para métodos de integração numérica.

Este módulo implementa algoritmos de integração numérica: Regra dos trapézios, Simpson 1/3 e suas versões repetidas.

Author: Pedro Henrique Rocha de Andrade Date: Dezembro 2025

codigos.integracoes.plotar_funcoes(funcs, a, b, pontos=400)

Plota uma ou várias funções simbólicas no intervalo [a, b].

Parâmetros:

• funcs (str) – String com expressões separadas por vírgula (ex.: 'sin(x), cos(x)').

• a (float) – Limites do intervalo de plotagem.

• b (float) – Limites do intervalo de plotagem.

• pontos (int, optional) – Número de pontos no eixo x usados para amostragem (padrão: 400).

codigos.integracoes.plotar_funcao_e_aproximacao(func, a, b, m, metodo=None, pontos=400)

Plota a função e a aproximação composta baseada em nós igualmente espaçados.

Parâmetros:

• func (str) – Expressão da função em termos de x.

• a (float) – Intervalo da integração.

• b (float) – Intervalo da integração.

• m (int) – Número de subintervalos (m > 0).

• metodo (str, optional) – Legenda para a aproximação (ex.: 'Trapézio composta').

• pontos (int, optional) – Número de pontos para plotagem da função exata.

codigos.integracoes.pedir_dados_integral()

Lê interativamente a função e limites para integração.

Retorna:

func : str ou None - expressão da função a, b : float - limites do intervalo composta : bool - se deve usar regra composta Retorna (None, None, None, None) em caso de erro de parsing.

Tipo de retorno:

(func, a, b, composta)

codigos.integracoes.pedir_m_ou_h(a, b, regra)

Auxiliar que solicita m (número de subintervalos) ou h (tamanho do passo).

Parâmetros:

• a (float) – Intervalo de integração.

• b (float) – Intervalo de integração.

• regra (str) – Identificador da regra (‘trapezio’, ‘simpson13’, ‘simpson38’) usado para validar requisitos (paridade, múltiplos).

Retorna:

Tupla (m, h) calculada, ou (None, None) em caso de entrada inválida.

Tipo de retorno:

(int, float) or (None, None)

codigos.integracoes.erro_truncamento_composta(a, b, m, derivada_max, metodo)

Estimativa do erro de truncamento para regras compostas.

Parâmetros:

• a (float) – Intervalo de integração.

• b (float) – Intervalo de integração.

• m (int) – Número de subintervalos.

• derivada_max (float) – Valor máximo estimado da derivada relevante no intervalo (ex.: segunda derivada para trapézio).

• metodo (str) – ‘trapezio’, ‘simpson13’ ou ‘simpson38’.

Retorna:

Estimativa do erro de truncamento (pode ser negativa conforme fórmula) ou None se método desconhecido.

Tipo de retorno:

float or None

codigos.integracoes.trapezio_tabela()

Regra do Trapézio para dados em tabela (x, y).

Requer que o número de pontos seja pelo menos 2 Fórmula: int_a^b f(x) dx ≈ (h/2) * [f(x0) + f(xn)]

codigos.integracoes.simpson_1_3_tabela()

Regra de Simpson 1/3 para dados em tabela (x, y).

Requer que o número de pontos seja ímpar Fórmula: int_a^b f(x) dx ≈ (h/3) * [f(x0) + 4f(x1) + 2f(x2) + … + 4f(xn-1) + f(xn)]

codigos.integracoes.simpson_3_8_tabela()

‘ Regra de Simpson 3/8 para dados em tabela (x, y).

Requer que os intervalos sejam multiplo de 3 Fórmula: int_a^b f(x) dx ≈ (3h/8) * [f(x0) + 3f(x1) + 3f(x2) + 2f(x3) + … + 3f(xn-1) + f(xn)]

codigos.integracoes.calcular_integral_analitica()

Calcula a integral de uma função simbolicamente usando SymPy.

Requer a função e os limites de integração. Fórmula: int_a^b f(x) dx

codigos.integracoes.newton_cotes(func, a, b, ordem, verbose=False, grafico=None)

Newton-Cotes para integração numérica (ordens 1,2,3).

Otimizações

• Tenta usar sympy.lambdify para avaliar a função de forma vetorizada quando possível.

Verbose & Gráficos

• verbose=False (padrão): execução silenciosa (comportamento compatível com testes automatizados).

• verbose=True: imprime detalhes auxiliares e, por padrão, habilita grafico=True.

Parâmetros

funcstr

Expressão da função em termos de x.

a, bfloat

Limites do intervalo de integração (números finitos, distintos).

ordemint

Ordem da regra (1, 2 ou 3).

verbosebool, optional

Habilita saídas detalhadas e gráficos (padrão: False).

graficobool or None, optional

Controla plotagem: se None e verbose for True, é habilitado; caso contrário, respeitado.

Retorno

float

Aproximação da integral.

Notas de teste

Os testes unitários que cobrem Newton-Cotes e regras compostas estão em tests/test_integracoes.py.

codigos.integracoes.trapezio_composta(func, a, b, verbose=False, grafico=None)

Regra do Trapézio composta para integração numérica.

Parâmetros:

• func (str) – Expressão da função em termos de x.

• a (float) – Limites do intervalo de integração.

• b (float) – Limites do intervalo de integração.

• verbose (bool, optional) – Se True, imprime detalhes e habilita (por padrão) a plotagem e estimativa de erro.

• grafico (bool or None, optional) – Controla plotagem: se None e verbose for True, habilita-a.

Retorna:

Aproximação da integral ou None em caso de erro/entrada inválida.

Tipo de retorno:

float or None

Notas

Testes para regras compostas estão em tests/test_integracoes.py.

codigos.integracoes.simpson_1_3_composta(func, a, b, verbose=False, grafico=None)

Regra de Simpson 1/3 composta para integração numérica.

Parâmetros:

• func (str) – Expressão da função em termos de x.

• a (float) – Limites do intervalo de integração.

• b (float) – Limites do intervalo de integração.

• verbose (bool, optional) – Se True, imprime detalhes, habilita plot e estimativa de erro.

• grafico (bool or None, optional) – Controla plotagem: se None e verbose for True, habilita-a.

Retorna:

Aproximação da integral ou None em caso de erro/entrada inválida.

Tipo de retorno:

float or None

codigos.integracoes.simpson_3_8_composta(func, a, b, verbose=False, grafico=None)

Regra de Simpson 3/8 composta para integração numérica.

Parâmetros:

• func (str) – Expressão da função em termos de x.

• a (float) – Limites do intervalo de integração.

• b (float) – Limites do intervalo de integração.

• verbose (bool, optional) – Se True, imprime detalhes e habilita plot/estimativa de erro.

• grafico (bool or None, optional) – Controla plotagem: se None e verbose for True, habilita-a.

codigos.integracoes.dados()

Menu interativo para métodos de integração numérica.

codigos.integracoes.menu()

codigos.interpolacoes.dados_interpolacao()

Lê interativamente pontos para interpolação com validação robusta.

Esta função solicita ao usuário os dados necessários para interpolação: número de pontos, coordenadas x e y, e ponto de interpolação. Inclui validações para garantir que os dados sejam adequados.

Retorna:

Tupla (x_vals, y_vals, x_interp) onde: - x_vals: list of float, coordenadas x dos pontos - y_vals: list of float, coordenadas y dos pontos - x_interp: float, ponto onde avaliar a interpolação

Tipo de retorno:

tuple

Levanta:

• ValueError – Se os dados inseridos forem inválidos.

• KeyboardInterrupt – Se o usuário interromper a entrada (Ctrl+C).

codigos.interpolacoes.obter_max_grau(n)

Solicita ao usuário o grau máximo para interpolação.

Parâmetros:

n (int) – Número de pontos disponíveis.

Retorna:

Grau máximo escolhido ou None para usar o máximo disponível.

Tipo de retorno:

int or None

codigos.interpolacoes.verifica_espaçamento_uniforme(x, tol=1e-15)

Verifica se os pontos x possuem espaçamento uniforme.

Parâmetros:

• x (sequence of float) – Pontos x ordenados.

• tol (float, optional) – Tolerância absoluta para comparação (padrão 1e-15).

Retorna:

Tupla (eh_uniforme, h) onde h é o passo estimado entre pontos.

Tipo de retorno:

(bool, float)

codigos.interpolacoes.tabela_diferencas_divididas(x, y)

Calcula a tabela de diferenças divididas (Newton).

Parâmetros:

• x (sequence of float) – Nós e valores correspondentes.

• y (sequence of float) – Nós e valores correspondentes.

Retorna:

Tabela em que cada linha j contém as diferenças divididas de ordem j.

Tipo de retorno:

list of lists

codigos.interpolacoes.imprimir_tabela_diferencas_divididas(tabela, verbose=True)

codigos.interpolacoes.tabela_diferencas_finitas(y)

Calcula tabela de diferenças finitas progressivas.

Parâmetros:

y (sequence of float) – Valores y nos nós igualmente espaçados.

Retorna:

Tabela de diferenças finitas progressivas.

Tipo de retorno:

list of lists

codigos.interpolacoes.imprimir_tabela_diferencas_finitas(tabela, verbose=True)

codigos.interpolacoes.perguntar_erro(x_vals, x_interp, grau, valor_interpolado)

codigos.interpolacoes.calcular_erro(func_str, x_vals, x_interp, grau, valor_interpolado)

Calcula estimativa do erro de truncamento do polinômio interpolador.

Parâmetros:

• func_str (str) – Expressão simbólica de f(x).

• x_vals (sequence) – Nós usados na interpolação.

• x_interp (float) – Ponto em que a interpolação foi avaliada.

• grau (int) – Grau do polinômio usado.

• valor_interpolado (float) – Valor interpolado (não usado diretamente no cálculo aqui).

Retorna:

Erro de truncamento máximo estimado e None (placeholder para erro real).

Tipo de retorno:

(float, None)

codigos.interpolacoes.newton_dif_divididas(x, tabela_diferencas, xp, max_grau=None, verbose=False, tabela=None, grafico=None)

Avalia o polinômio interpolador de Newton usando diferenças divididas.

Esta função implementa o método de interpolação polinomial de Newton baseado em diferenças divididas, que é numericamente mais estável que o método de Lagrange para avaliação em múltiplos pontos.

Parâmetros:

• x (array_like) – Nós (pontos x) onde os valores são conhecidos. Devem ser números reais únicos e finitos.

• tabela_diferencas (list of lists) – Tabela de diferenças divididas calculada previamente (como retornada por tabela_diferencas_divididas). Cada linha j contém as diferenças divididas de ordem j.

• xp (float) – Ponto onde avaliar o polinômio interpolador. Deve ser um número finito.

• max_grau (int or None, optional) – Grau máximo do polinômio interpolador. Se None (padrão), usa o grau máximo possível (n-1, onde n é o número de pontos). Deve estar no intervalo [1, n-1].

• verbose (bool, optional) – Se True, imprime os cálculos detalhados do processo de interpolação. Se False (padrão), executa silenciosamente.

• tabela (bool or None, optional) – Se True, mostra a tabela de diferenças divididas utilizada. Se None (padrão), usa o valor da variável global ‘tabela’ ou False.

• grafico (bool or None, optional) – Se True, gera um gráfico mostrando os pontos originais, a curva interpolada e o ponto de interpolação. Se None (padrão), usa o valor da variável global ‘grafico’ ou False. Requer matplotlib instalado.

Retorna:

Valor interpolado do polinômio de Newton no ponto xp.

Tipo de retorno:

float

Levanta:

• ValueError – Se as entradas não forem válidas ou se a tabela de diferenças não for consistente com os pontos x.

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

• RuntimeError – Se ocorrer erro na avaliação do polinômio.

Notas

O método de Newton com diferenças divididas é definido pela fórmula:

\[P_n(x) = f[x_0] + f[x_0,x_1](x-x_0) + f[x_0,x_1,x_2](x-x_0)(x-x_1) + \cdots\]

onde \(f[x_0,x_1,\dots,x_k]\) são as diferenças divididas de ordem k.

A complexidade computacional é O(n) para avaliação em um ponto, após a pré-computação da tabela de diferenças divididas O(n²).

Exemplos

>>> x = [0, 1, 2]
>>> y = [0, 1, 4]
>>> tabela = tabela_diferencas_divididas(x, y)
>>> newton_dif_divididas(x, tabela, 1.5)
2.25

>>> # Interpolação quadrática
>>> newton_dif_divididas(x, tabela, 1.5, max_grau=2)
2.25

codigos.interpolacoes.gregory_newton_progressivo(x, y, xp, max_grau=None, verbose=False, tabela=None, grafico=None)

Avalia o polinômio interpolador de Gregory-Newton progressivo.

Esta função implementa o método de interpolação polinomial de Gregory-Newton progressivo, que utiliza diferenças finitas para interpolação em pontos igualmente espaçados. É uma variante do método de Newton otimizada para nós com espaçamento uniforme.

Parâmetros:

• x (array_like) – Nós (pontos x) e valores correspondentes (pontos y). Os pontos x devem estar igualmente espaçados e ser únicos. Ambos devem ser sequências de números reais finitos.

• y (array_like) – Nós (pontos x) e valores correspondentes (pontos y). Os pontos x devem estar igualmente espaçados e ser únicos. Ambos devem ser sequências de números reais finitos.

• xp (float) – Ponto onde avaliar o polinômio interpolador. Deve ser um número finito.

• max_grau (int or None, optional) – Grau máximo do polinômio interpolador. Se None (padrão), usa o grau máximo possível (n-1, onde n é o número de pontos). Deve estar no intervalo [1, n-1].

• verbose (bool, optional) – Se True, imprime os cálculos detalhados do processo de interpolação. Se False (padrão), executa silenciosamente.

• tabela (bool or None, optional) – Se True, mostra a tabela de diferenças finitas utilizada. Se None (padrão), usa o valor da variável global ‘tabela’ ou False.

• grafico (bool or None, optional) – Se True, gera um gráfico mostrando os pontos originais, a curva interpolada e o ponto de interpolação. Se None (padrão), usa o valor da variável global ‘grafico’ ou False. Requer matplotlib instalado.

Retorna:

Valor interpolado do polinômio de Gregory-Newton no ponto xp.

Tipo de retorno:

float

Levanta:

• ValueError – Se as entradas não forem válidas ou se os pontos x não estiverem igualmente espaçados.

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

Notas

O método de Gregory-Newton progressivo é definido pela fórmula:

\[P_n(x) = y_0 + \binom{s}{1} \Delta y_0 + \binom{s}{2} \Delta^2 y_0 + \cdots + \binom{s}{n} \Delta^n y_0\]

onde \(s = (x - x_0)/h\) é a variável reduzida, \(h\) é o passo entre pontos, e \(\Delta^k y_0\) são as diferenças finitas progressivas.

Este método requer que os pontos x estejam igualmente espaçados. Para pontos não-uniformemente espaçados, use newton_dif_divididas.

A complexidade computacional é O(n) para avaliação em um ponto, após a pré-computação da tabela de diferenças finitas O(n²).

Exemplos

>>> x = [0, 1, 2, 3]
>>> y = [1, 3, 7, 13]  # y = x² + 1
>>> gregory_newton_progressivo(x, y, 1.5)
3.25

>>> # Interpolação cúbica
>>> gregory_newton_progressivo(x, y, 1.5, max_grau=3)
3.25

codigos.interpolacoes.lagrange_interpol(x, y, xp, max_grau=None, verbose=False, tabela=None, grafico=None)

Avalia o polinômio interpolador de Lagrange em um ponto específico.

Esta função implementa o método de interpolação polinomial de Lagrange, que constrói um polinômio que passa exatamente pelos pontos dados. O método é numericamente estável e não requer ordenação prévia dos pontos.

Parâmetros:

• x (array_like) – Nós (pontos x) e valores correspondentes (pontos y). Devem ser sequências de números reais com o mesmo comprimento. Os pontos x devem ser únicos.

• y (array_like) – Nós (pontos x) e valores correspondentes (pontos y). Devem ser sequências de números reais com o mesmo comprimento. Os pontos x devem ser únicos.

• xp (float) – Ponto onde avaliar o polinômio interpolador. Deve ser um número finito.

• max_grau (int or None, optional) – Grau máximo do polinômio interpolador. Se None (padrão), usa o grau máximo possível (n-1, onde n é o número de pontos). Deve estar no intervalo [1, n-1].

• verbose (bool, optional) – Se True, imprime os cálculos detalhados do processo de interpolação. Se False (padrão), executa silenciosamente.

• tabela (bool or None, optional) – Se True, mostra tabela com os pontos de interpolação utilizados. Se None (padrão), usa o valor da variável global ‘tabela’ ou False.

• grafico (bool or None, optional) – Se True, gera um gráfico mostrando os pontos originais, a curva interpolada e o ponto de interpolação. Se None (padrão), usa o valor da variável global ‘grafico’ ou False. Requer matplotlib instalado.

Retorna:

Valor interpolado do polinômio de Lagrange no ponto xp.

Tipo de retorno:

float

Levanta:

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

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

• RuntimeError – Se ocorrer divisão por zero durante o cálculo (pontos x duplicados).

Notas

O método de Lagrange é definido pela fórmula:

\[P(x) = \sum_{i=0}^{n-1} y_i \cdot L_i(x)\]

onde \(L_i(x)\) são os polinômios base de Lagrange:

\[L_i(x) = \prod_{j=0, j\neq i}^{n-1} \frac{x - x_j}{x_i - x_j}\]

A complexidade computacional é O(n²) para avaliação em um ponto.

Exemplos

>>> x = [0, 1, 2]
>>> y = [0, 1, 4]
>>> lagrange_interpol(x, y, 1.5)
2.25

>>> # Interpolação quadrática
>>> lagrange_interpol(x, y, 1.5, max_grau=2)
2.25

codigos.interpolacoes.dispositivo_pratico_lagrange(x, y, xp, max_grau=None, verbose=False, tabela=None, grafico=None)

codigos.interpolacoes.menu()

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.coletar_dados_edo()

Obtém entradas do usuário para resolução de EDOs com validação robusta.

Esta função solicita interativamente ao usuário os dados necessários para resolver uma equação diferencial ordinária: a função f(x,y), o intervalo de integração [a,b], as condições iniciais (x0,y0), e o passo de integração. Também permite especificar uma solução exata opcional para comparação.

A função inclui validações abrangentes para garantir que os dados sejam adequados para a resolução numérica da EDO.

Retorna:

Dicionário contendo todos os dados validados com as seguintes chaves: - ‘func_input’: str, expressão da função f(x,y) - ‘a’: float, limite inferior do intervalo - ‘b’: float, limite superior do intervalo - ‘x0’: float, ponto inicial das condições iniciais - ‘y0’: float, valor inicial y(x0) - ‘h’: float, tamanho do passo de integração - ‘m’: int or None, número de subintervalos (se especificado) - ‘xn’: float, ponto final (sempre igual a b) - ‘solucao_exata’: callable or None, função da solução exata - ‘sol_exata_expr’: str, expressão da solução exata

Tipo de retorno:

dict

Levanta:

• ValueError – Se os dados inseridos forem inválidos ou inconsistentes.

• KeyboardInterrupt – Se o usuário interromper a entrada (Ctrl+C).

codigos.edos.passos_edo(a, b, x0, h=None, m=None)

Normaliza e retorna (h, xn) dado h ou m. xn é sempre b.

codigos.edos.plotar_grafico_edo(x_vals, y_vals, solucao_exata=None, titulo='Solução da EDO')

codigos.edos.mostrar_tabela_e_grafico_edo(x_vals, y_vals, solucao_exata=None, titulo='Solução da EDO', plotar=True)

Mostra a tabela de pontos (x, y) e chama o plot se plotar for True.

codigos.edos.resolver_edo_2ordem()

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.executar_runge_kutta(ordem)

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.

codigos.edos.menu_principal()

codigos.edos.dados()

Menu interativo para métodos de resolução de EDOs.

Módulo para conversões entre sistemas de numeração.

Este módulo implementa funções para conversão entre diferentes bases numéricas: binário, decimal e hexadecimal.

Author: Pedro Henrique Rocha de Andrade Date: Dezembro 2025

codigos.bases.dados()

Menu interativo para operações de conversão de bases.

codigos.bases.binario_para_decimal(string_binaria)

Converte uma string binária para inteiro decimal.

Parâmetros:

string_binaria (str) – Representação binária (ex.: '1011').

Retorna:

Valor decimal correspondente.

Tipo de retorno:

int

codigos.bases.decimal_para_binario(numero_decimal)

Converte um inteiro decimal para sua representação binária em string.

Parâmetros:

numero_decimal (int) – Número decimal não-negativo.

Retorna:

• str – Representação binária (ex.: '1011').

• Exemplos

• ——–

• >>> decimal_para_binario(11)

• ’1011’

codigos.bases.decimal_para_hexadecimal(numero_decimal)

Converte um inteiro decimal para representação hexadecimal (maiúscula).

Parâmetros:

numero_decimal (int) – Número decimal não-negativo.

Retorna:

• str – Representação hexadecimal (ex.: 'FE').

• Exemplos

• ——–

• >>> decimal_para_hexadecimal(254)

• ’FE’

codigos.bases.hexadecimal_para_decimal(string_hexadecimal)

Converte uma string hexadecimal (base 16) para inteiro decimal.

Parâmetros:

string_hexadecimal (str) – Representação hexadecimal (ex.: 'FE').

Retorna:

• int – Valor decimal correspondente.

• Exemplos

• ——–

• >>> hexadecimal_para_decimal(‘FE’)

• 254

codigos.bases.binario_para_hexadecimal(string_binaria)

Converte uma string binária para representação hexadecimal.

Parâmetros:

string_binaria (str) – Representação binária.

Retorna:

• str – Representação hexadecimal em maiúsculas.

• Exemplos

• ——–

• >>> binario_para_hexadecimal(‘1111’)

• ’F’

codigos.bases.hexadecimal_para_binario(string_hexadecimal)

Converte uma string hexadecimal para representação binária.

Parâmetros:

string_hexadecimal (str) – Representação hexadecimal (ex.: 'F').

Retorna:

• str – Representação binária (ex.: '1111').

• Exemplos

• ——–

• >>> hexadecimal_para_binario(‘F’)

• ’1111’

codigos.bases.main()

codigos.ajustecurvas.dados()

Função de entrada de dados interativa.

Solicita ao usuário o número de pontos e os valores de x e y, com validação de entrada e tratamento de erros.

Returns: - Vetor x (np.ndarray) - Vetor y (np.ndarray)

codigos.ajustecurvas.tabela_interpolador(x, y, p1x, verbose=True)

Tabela para exibição dos cálculos pelo método dos mínimos quadrados.

Parameters: - x, y: vetores de pontos - p1x: valores do polinomio interpolador - verbose: se True, imprime a tabela

codigos.ajustecurvas.tabela_minimos_quadrados(x, y, verbose=True)

Tabela para exibição dos cálculos pelo método dos mínimos quadrados:

Entradas/Parâmetros: - x (vetor de pontos em x) - y (vetor de pontos em y) - verbose (bool): se True, imprime a tabela; se False, executa silenciosamente

Fórmulas b1 = (sum_xi * sum_yi - n * sum_xiyi) / (sum_xi ** 2 - n * sum_xi**2) b0 = (sum_yi - b1 * sum_xi) / n

Saídas: - Tabela com i,xi,yi,xi**2,yi**2,xiyi,ui,di,di**2

codigos.ajustecurvas.calcula_chi_e_r2(x, y, b0, b1, n_params=2, verbose=True)

Calcula chi-quadrado (ajustado), soma dos quadrados dos resíduos (desvio) e coeficiente de determinação R^2, recebendo explicitamente os coeficientes da reta (b0, b1) e os pontos (x, y).

Parâmetros: x (np.array): valores de x y (np.array): valores observados b0 (float): coeficiente linear da reta b1 (float): coeficiente angular da reta n_params (int): número de parâmetros do modelo (p), padrão 2 para regressão linear verbose (bool): se True, imprime os resultados; se False, executa silenciosamente

Fórmulas: D(a0,a1) = sum((y_i - b0 - b1*x_i)^2) SQT = sum((y_i - y_media)^2) SQRes = sum((y_i - Ui)^2) onde Ui = b0 + b1 * x_i SQReg = sum((Ui - y_media)^2) R^2 = 1 - (SQRes / SQT) Chi^2 = D(a0,a1) / (n - p) (n = número de pontos, p = número de parâmetros do modelo)

Retorna:

chi2, r2, Desvio, SQT, SQRes, SQReg, Ui

codigos.ajustecurvas.regressaolinear(x, y, verbose=True, tabela=None, grafico=None)

Método 1: Polinômio interpolador de ordem 1 - Escolhendo o primeiro e o último ponto, ou qualquer outro par de pontos inserido previamente pelo usuário.

Entradas/Parâmetros: - x (vetor de pontos em x) - y (vetor de pontos em y) - verbose (bool): se True, imprime resultados; se False, executa silenciosamente - tabela (bool): se True, mostra tabela; se None, usa variável global - grafico (bool): se True, mostra gráfico; se None, usa variável global - x0,y0; x1,y1 (pares de pontos escolhidos por indice)

Fórmulas b1 = (y1 - y0) / (x1 - x0) b0 = y0 - b1 * x0 P_1(x) = y0 - ((y1 - y0)/(x1 - x0))*(x-x0) D(a0,a1) = sum((yi - p1(xi))^2)

Saídas: - Tabela com i,xi,yi,p_1(xi),di - Equação da reta - Desvio D(a0,a1) - Chi2, R2 - Gráfico ilustrativo

codigos.ajustecurvas.regressaolinear_intervalo(x, y, verbose=True, tabela=None, grafico=None)

Método 2: Polinômio interpolador de ordem 1 dentro do intervalo (x.min(x), x.max(x)) - Inserindo pontos manualmente dentro do intervalo previamente definido com os dados da funcao dados()

Entradas/Parâmetros: - x (vetor de pontos em x) - y (vetor de pontos em y) - verbose (bool): se True, imprime resultados; se False, executa silenciosamente

Fórmulas P_1(x) = y0 - ((y1 - y0)/(x1 - x0))*(x-x0) D(a0,a1) = sum((yi - p1(xi))^2)

Saídas: - Tabela com i,xi,yi,p_1(xi),di - Equação da reta - Desvio D(a0,a1) - Chi2, R2 - Gráfico ilustrativo

codigos.ajustecurvas.minquadrados(x, y, verbose=True, tabela=None, grafico=None)

Método 3: Mínimos Quadrados - É a derivada do desvio igualada a 0 com respeito a b0 e b1 (parciais)

Entradas/Parâmetros: - x (vetor de pontos em x) - y (vetor de pontos em y) - verbose (bool): se True, imprime resultados; se False, executa silenciosamente - tabela (bool): se True, mostra tabela; se None, usa variável global - grafico (bool): se True, mostra gráfico; se None, usa variável global

Fórmulas: b0 = (sum(yi) - b1*sum(xi)) / n b1 = (sum(xi)*sum(yi) - n*sum(xiyi))/((sum(xi)**2) - n*sum(xi**2)) D(b0,b1) = sum((yi - (b0 + b1*xi))^2)

Saídas: - Tabela com i,xi,yi,xi**2,yi**2,xiyi,ui,di,di**2 - Equação da reta - Desvio D(b0,b1) - Chi2, R2 - Gráfico ilustrativo

codigos.ajustecurvas.minquadrados_ordem_n(x, y, ordem, verbose=True, tabela=None, grafico=None)

Método 3: Mínimos Quadrados

Entradas/Parâmetros: - x (vetor de pontos em x) - y (vetor de pontos em y) - ordem (inteiro >=0) - verbose (bool): se True, imprime resultados; se False, executa silenciosamente - tabela (bool): se True, mostra tabela; se None, usa variável global - grafico (bool): se True, mostra gráfico; se None, usa variável global

Fórmulas: basicamente montar um sistema e resolver por Gauss (poderia ser por decomposição LU tb)

Saídas: - Equação da reta - Desvio - Chi2, R2 - Gráfico ilustrativo

codigos.ajustecurvas.menu()

Menu interativo de demonstração para Ajustes de Curvas.

Fornece opções para regressão linear, mínimos quadrados (linear) e ajuste polinomial de ordem n. Este docstring foi simplificado para evitar problemas de formatação no Sphinx e melhorar a legibilidade.