Testes: test_interpolacoes

Testes para codigos.interpolacoes.

Cobre: - Cálculo de diferenças divididas e avaliação de Newton - Interpolação de Lagrange e dispositivo prático - Método de diferenças finitas de Gregory-Newton - Estimativa de erro e verificação de espaçamento - Comportamentos de verbose/tabela/gráfico e validação de entradas

Conteúdo dos testes:

  1"""Testes para `codigos.interpolacoes`.
  2
  3Cobre:
  4- Cálculo de diferenças divididas e avaliação de Newton
  5- Interpolação de Lagrange e dispositivo prático
  6- Método de diferenças finitas de Gregory-Newton
  7- Estimativa de erro e verificação de espaçamento
  8- Comportamentos de verbose/tabela/gráfico e validação de entradas
  9"""
 10
 11from codigos import interpolacoes
 12import numpy as np
 13
 14def test_tabela_diferencas_divididas_and_newton():
 15    """Verifica a tabela de diferenças divididas e avaliação de Newton.
 16
 17    - Confirma primeira linha da tabela igual a y e que a avaliação em 1.5
 18      produz o valor esperado 2.25.
 19    """
 20    x = [0.0, 1.0, 2.0]
 21    y = [0.0, 1.0, 4.0]
 22    tabela = interpolacoes.tabela_diferencas_divididas(x, y)
 23    assert np.allclose(tabela[0], y)
 24    assert len(tabela) == 3
 25    val = interpolacoes.newton_dif_divididas(x, tabela, 1.5)
 26    assert abs(val - 2.25) < 1e-12
 27
 28
 29def test_lagrange_interpol():
 30    """Verifica a interpolação por Lagrange em um ponto simples.
 31
 32    - Usa pontos [0,1,2] e valida que p(1.5) ≈ 2.25.
 33    """
 34    x = [0.0, 1.0, 2.0]
 35    y = [0.0, 1.0, 4.0]
 36    val = interpolacoes.lagrange_interpol(x, y, 1.5)
 37    assert abs(val - 2.25) < 1e-12
 38
 39
 40def test_tabela_diferencas_finitas_and_gregory():
 41    """Verifica diferenças finitas e interpolação Gregory-Newton progressiva."""
 42    x = [0.0, 1.0, 2.0]
 43    y = [0.0, 1.0, 4.0]
 44    tabela = interpolacoes.tabela_diferencas_finitas(y)
 45    assert np.allclose(tabela[0], y)
 46    assert np.allclose(tabela[1], [1.0, 3.0])
 47    assert np.allclose(tabela[2], [2.0])
 48    val = interpolacoes.gregory_newton_progressivo(x, y, 1.5)
 49    assert abs(val - 2.25) < 1e-12
 50
 51
 52def test_dispositivo_pratico_lagrange():
 53    """Valida o 'dispositivo prático' de Lagrange com dados sintéticos."""
 54    x = [0.0, 1.0, 2.0]
 55    y = [0.0, 1.0, 4.0]
 56    val = interpolacoes.dispositivo_pratico_lagrange(x, y, 1.5)
 57    assert abs(val - 2.25) < 1e-12
 58
 59
 60def test_verifica_espaçamento_uniforme_and_calcular_erro():
 61    """Testa verificação de espaçamento uniforme e estimativa de erro.
 62
 63    - Verifica que h=1.0 e que a estimativa de erro para f(x)=x^2 é nula
 64      no caso exato usado aqui.
 65    """
 66    x = [0.0, 1.0, 2.0]
 67    ok, h = interpolacoes.verifica_espaçamento_uniforme(x)
 68    assert ok and abs(h - 1.0) < 1e-12
 69    erro_trunc, _ = interpolacoes.calcular_erro('x**2', x, 1.5, 2, 2.25)
 70    assert erro_trunc == 0 or abs(erro_trunc) < 1e-14
 71
 72
 73def test_lagrange_real_data_1():
 74    """Testa interpolação de Lagrange com dados reais do exemplo do menu"""
 75    x = [1.0, 1.3, 1.8]
 76    y = [0.0, 0.262, 0.588]
 77    val = interpolacoes.lagrange_interpol(x, y, 1.4)
 78    assert abs(val - 0.3382666666666666) < 1e-10
 79
 80
 81def test_newton_real_data_1():
 82    """Testa interpolação de Newton com dados reais do exemplo do menu"""
 83    x = [1.0, 1.3, 1.8]
 84    y = [0.0, 0.262, 0.588]
 85    tabela = interpolacoes.tabela_diferencas_divididas(x, y)
 86    val = interpolacoes.newton_dif_divididas(x, tabela, 1.4)
 87    assert abs(val - 0.33826666666666655) < 1e-10
 88
 89
 90def test_dispositivo_pratico_lagrange_real_data():
 91    """Testa dispositivo prático de Lagrange com dados de temperatura"""
 92    x = [0.2, 0.3, 0.5]
 93    y = [85.0, 88.0, 92.0]
 94    val = interpolacoes.dispositivo_pratico_lagrange(x, y, 0.4)
 95    assert abs(val - 90.33333333333334) < 1e-10
 96
 97
 98def test_newton_real_data_2():
 99    """Testa Newton com 4 pontos"""
100    x = [0.0, 0.5, 0.75, 1.0]
101    y = [1.0, 4.482, 9.488, 20.086]
102    tabela = interpolacoes.tabela_diferencas_divididas(x, y)
103    val = interpolacoes.newton_dif_divididas(x, tabela, 0.65)
104    assert abs(val - 6.958004) < 1e-6
105
106
107def test_lagrange_real_data_2():
108    """Testa Lagrange com dados de pressão"""
109    x = [55.0, 70.0, 85.0, 100.0]
110    y = [14.08, 13.56, 13.28, 12.27]
111    val = interpolacoes.lagrange_interpol(x, y, 80.0)
112    assert abs(val - 13.40654320987654) < 1e-10
113
114
115def test_lagrange_real_data_3():
116    """Testa Lagrange com outro conjunto de dados de pressão"""
117    x = [85.0, 100.0, 115.0, 130.0]
118    y = [13.28, 12.27, 11.30, 10.40]
119    val = interpolacoes.lagrange_interpol(x, y, 110.0)
120    assert abs(val - 11.617037037037036) < 1e-10
121
122
123def test_newton_real_data_3():
124    """Testa Newton com valores de x decrescentes"""
125    x = [1000.0, 750.0, 500.0]
126    y = [15.0, 10.0, 7.0]
127    tabela = interpolacoes.tabela_diferencas_divididas(x, y)
128    val = interpolacoes.newton_dif_divididas(x, tabela, 850.0)
129    assert abs(val - 11.76) < 1e-10
130
131
132def test_max_grau_limitation():
133    """Garante que o parâmetro max_grau limita o grau do polinômio"""
134    x = [0.0, 1.0, 2.0, 3.0]
135    y = [0.0, 1.0, 4.0, 9.0]
136    val = interpolacoes.lagrange_interpol(x, y, 1.5, max_grau=1)
137    assert isinstance(val, (float, np.floating))
138
139
140def test_gregory_newton_real_data():
141    """Testa Gregory-Newton com dados igualmente espaçados"""
142    x = [0.0, 0.5, 1.0, 1.5]
143    y = [1.0, 1.648721, 2.718282, 4.481689]
144    val = interpolacoes.gregory_newton_progressivo(x, y, 0.75)
145    expected = np.exp(0.75)
146    assert abs(val - expected) < 5e-3  
147
148
149def test_input_validation_errors():
150    """Verifica que validação de entradas levanta erros apropriados"""
151    import pytest
152    
153    with pytest.raises(ValueError, match="x e y devem ter o mesmo comprimento"):
154        interpolacoes._validate_interpolation_inputs([1, 2], [1, 2, 3])
155    
156    with pytest.raises(ValueError, match="Os pontos x devem ser únicos"):
157        interpolacoes._validate_interpolation_inputs([1, 1, 2], [1, 2, 3])
158    
159    with pytest.raises(ValueError, match="São necessários pelo menos 2 pontos para interpolação"):
160        interpolacoes._validate_interpolation_inputs([1], [1])
161
162
163def test_verbose_output(capsys):
164    """Verifica que verbose=False não produz saída e verbose=True produz saída"""
165    x = [0.0, 1.0, 2.0]
166    y = [0.0, 1.0, 4.0]
167    
168    val_silent = interpolacoes.lagrange_interpol(x, y, 1.5, verbose=False)
169    captured = capsys.readouterr()
170    assert captured.out == ""
171    
172    val_verbose = interpolacoes.lagrange_interpol(x, y, 1.5, verbose=True)
173    captured = capsys.readouterr()
174    assert "Lagrange" in captured.out or len(captured.out) > 0
175    
176    assert abs(val_silent - val_verbose) < 1e-12
177
178
179def test_lagrange_verbose_detailed_output(capsys):
180    """Verifica saída detalhada em verbose para interpolação de Lagrange"""
181    x = [1.0, 1.3, 1.8]
182    y = [0.0, 0.262, 0.588]
183    
184    val = interpolacoes.lagrange_interpol(x, y, 1.4, verbose=False)
185    assert abs(val - 0.3382666666666666) < 1e-10
186
187
188def test_newton_verbose_detailed_output(capsys):
189    """Verifica saída detalhada em verbose para interpolação de Newton"""
190    x = [1.0, 1.3, 1.8]
191    y = [0.0, 0.262, 0.588]
192    tabela = interpolacoes.tabela_diferencas_divididas(x, y)
193    
194    val = interpolacoes.newton_dif_divididas(x, tabela, 1.4, verbose=False)
195    assert abs(val - 0.33826666666666655) < 1e-10
196
197def test_numpy_array_inputs():
198    """Verifica que as funções aceitam arrays numpy como entrada"""
199    x = np.array([0.0, 1.0, 2.0])
200    y = np.array([0.0, 1.0, 4.0])
201    
202    val = interpolacoes.lagrange_interpol(x, y, 1.5)
203    assert abs(val - 2.25) < 1e-12
204    
205    tabela = interpolacoes.tabela_diferencas_divididas(x, y)
206    val_newton = interpolacoes.newton_dif_divididas(x, tabela, 1.5)
207    assert abs(val_newton - 2.25) < 1e-12
208
209
210def test_verbose_enables_tables_and_details(capsys):
211    """Quando verbose=True, a função imprime passos e tabelas detalhadas."""
212    x = [0.0, 1.0, 2.0]
213    y = [0.0, 1.0, 4.0]
214    tabela = interpolacoes.tabela_diferencas_divididas(x, y)
215
216    val = interpolacoes.newton_dif_divididas(x, tabela, 1.5, verbose=True)
217    captured = capsys.readouterr()
218    assert "Termo" in captured.out or "Parcial" in captured.out
219    assert abs(val - 2.25) < 1e-12
220
221
222def test_invalid_xp_raises():
223    """xp deve ser um número finito."""
224    x = [0.0, 1.0]
225    y = [0.0, 1.0]
226    tabela = interpolacoes.tabela_diferencas_divididas(x, y)
227    import math
228    import pytest
229    with pytest.raises(TypeError):
230        interpolacoes.newton_dif_divididas(x, tabela, 'not-a-number')
231    with pytest.raises(ValueError):
232        interpolacoes.newton_dif_divididas(x, tabela, math.inf)
233
234
235def test_max_grau_limits_degree():
236    """Garante que max_grau é limitado a [1, n-1]"""
237    x = [0.0, 1.0, 2.0]
238    y = [0.0, 1.0, 4.0]
239    tabela = interpolacoes.tabela_diferencas_divididas(x, y)
240    # request a ridiculously large degree, should be clamped
241    val_high = interpolacoes.newton_dif_divididas(x, tabela, 1.5, max_grau=100)
242    val_full = interpolacoes.newton_dif_divididas(x, tabela, 1.5, max_grau=None)
243    assert abs(val_high - val_full) < 1e-12

Resumo das funções de teste:

  • test_tabela_diferencas_divididas_and_newton: Verifica a tabela de diferenças divididas e avaliação de Newton.

  • test_lagrange_interpol: Verifica a interpolação por Lagrange em um ponto simples.

  • test_tabela_diferencas_finitas_and_gregory: Verifica diferenças finitas e interpolação Gregory-Newton progressiva.

  • test_dispositivo_pratico_lagrange: Valida o ‘dispositivo prático’ de Lagrange com dados sintéticos.

  • test_verifica_espaçamento_uniforme_and_calcular_erro: Testa verificação de espaçamento uniforme e estimativa de erro.

  • test_lagrange_real_data_1: Testa interpolação de Lagrange com dados reais do exemplo do menu

  • test_newton_real_data_1: Testa interpolação de Newton com dados reais do exemplo do menu

  • test_dispositivo_pratico_lagrange_real_data: Testa dispositivo prático de Lagrange com dados de temperatura

  • test_newton_real_data_2: Testa Newton com 4 pontos

  • test_lagrange_real_data_2: Testa Lagrange com dados de pressão

  • test_lagrange_real_data_3: Testa Lagrange com outro conjunto de dados de pressão

  • test_newton_real_data_3: Testa Newton com valores de x decrescentes

  • test_max_grau_limitation: Garante que o parâmetro max_grau limita o grau do polinômio

  • test_gregory_newton_real_data: Testa Gregory-Newton com dados igualmente espaçados

  • test_input_validation_errors: Verifica que validação de entradas levanta erros apropriados

  • test_verbose_output: Verifica que verbose=False não produz saída e verbose=True produz saída

  • test_lagrange_verbose_detailed_output: Verifica saída detalhada em verbose para interpolação de Lagrange

  • test_newton_verbose_detailed_output: Verifica saída detalhada em verbose para interpolação de Newton

  • test_numpy_array_inputs: Verifica que as funções aceitam arrays numpy como entrada

  • test_verbose_enables_tables_and_details: Quando verbose=True, a função imprime passos e tabelas detalhadas.

  • test_invalid_xp_raises: xp deve ser um número finito.

  • test_max_grau_limits_degree: Garante que max_grau é limitado a [1, n-1]