Interpolações

Funções do módulo codigos.interpolacoes para interpolação (Newton, Lagrange, Gregory-Newton).

Documentação da API

codigos.interpolacoes.dados_interpolacao()[código-fonte]

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)[código-fonte]

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)[código-fonte]

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)[código-fonte]

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.tabela_diferencas_finitas(y)[código-fonte]

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.calcular_erro(func_str, x_vals, x_interp, grau, valor_interpolado)[código-fonte]

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)[código-fonte]

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)[código-fonte]

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)[código-fonte]

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

Exemplo de Uso

"""Exemplo: uso de interpolação (Newton e Lagrange)"""
from codigos import interpolacoes

if __name__ == '__main__':
    x = [0.0, 1.0, 2.0]
    y = [0.0, 1.0, 4.0]
    tabela = interpolacoes.tabela_diferencas_divididas(x, y)
    print('Newton @1.5 ->', interpolacoes.newton_dif_divididas(x, tabela, 1.5))
    print('Lagrange @1.5 ->', interpolacoes.lagrange_interpol(x, y, 1.5))

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_interpolacoes.py -v (testes específicos do módulo)

Teste correspondente: tests/inputs/inputInterpolacoes.txt

Testes Unitários (visíveis)

Testes: test_interpolacoes

Links rápidos

Teste de integração relacionado: tests/test_inputs_calcnum.py::test_calcnum_inputs_basic
Testes unitários (arquivo): tests/test_interpolacoes.py
Página de testes (docs): Testes: test_interpolacoes