fix: refactored tests in medidas

Author: viniciusdutra314

pyproject.toml

@@ -53,13 +53,12 @@ linter = [
     "ruff>=0.15.21",
 ]
 test = [
-    "labifsc >=0.1.13,<0.2.0",
-    "uncertainties >=3.2.2,<4.0.0",
     "pytest >=9.1.1,<10.0.0",
     "pytest-cov >=7.1.0,<8.0.0",
     "scipy >=1.15.1,<2.0.0",
     "mutmut >=3.6.0,<4.0.0",
     "matplotlib >=3.10.0,<4.0.0",
+    "mcerp>=1.1.0",
 ]
 
 [tool.mypy]

tests/medida/conftest.py

@@ -1,5 +1,6 @@
 from collections.abc import Iterator
 
+import mcerp
 import numpy as np
 import pytest
 from numpy.typing import NDArray
@@ -8,6 +9,19 @@
 from tests.utilities import SEMENTE_MONTE_CARLO
 
 
+@pytest.fixture(autouse=True)
+def configurar_rng_mcerp() -> Iterator[None]:
+    estado = np.random.get_state()
+    quantidade_amostras = mcerp.npts
+    np.random.seed(SEMENTE_MONTE_CARLO % 2**32)
+    mcerp.npts = 100_000
+    try:
+        yield
+    finally:
+        np.random.set_state(estado)
+        mcerp.npts = quantidade_amostras
+
+
 @pytest.fixture
 def rng_testes() -> np.random.Generator:
     return np.random.Generator(np.random.PCG64(SEMENTE_MONTE_CARLO))

tests/medida/test_classe_medida.py

@@ -49,8 +49,8 @@ def test_inicializacao_escalar_e_conversao_si(medida: lab.Medida) -> None:
 def test_inicializacao_por_amostras_usa_media_e_desvio_amostral() -> None:
     medida = lab.Medida([1, 2, 3], "s")
     assert medida.nominal("s") == pytest.approx(2)
-    assert medida.incerteza("s") == pytest.approx(np.std([1,2,3], ddof=1))
-    assert medida.incerteza("s") != pytest.approx(np.std([1,2,3])) #without ddof=1
+    assert medida.incerteza("s") == pytest.approx(np.std([1, 2, 3], ddof=1))
+    assert medida.incerteza("s") != pytest.approx(np.std([1, 2, 3]))  # without ddof=1
 
 
 def test_inicializacao_por_amostras_preserva_maior_incerteza() -> None:

tests/medida/test_classe_medida_operacoes.py

@@ -1,131 +1,114 @@
+from collections.abc import Callable
+
 import numpy as np
 import pytest
+from numpy.typing import NDArray
+from pint import Quantity
 
 import LabIFSC2 as lab
 from tests.utilities import assert_medida_proxima
 
 
-def test_soma():
-
-    x, y = lab.Medida(0, "", 0.1), lab.Medida(5, "", 0.3)
-
-    assert (y + 3).nominal("") == 8
-    assert (y - 3).nominal("") == 2
-    assert (y - 3.13).nominal("") == 5 - 3.13
-
-    incerteza_esperada = np.hypot(0.1, 0.3)
-    assert_medida_proxima(x + y, 5, incerteza_esperada)
-    assert_medida_proxima(y + x, 5, incerteza_esperada)
-    assert_medida_proxima(x - y, -5, incerteza_esperada)
-    assert_medida_proxima(y - x, 5, incerteza_esperada)
-
-    assert_medida_proxima(x - x, 0, 0)
-    assert_medida_proxima(y - y, 0, 0)
-    z = lab.Medida(5, "", 0.01) * lab.Medida(5, "", 0.01)
-    w = lab.Medida(5, "", 0.01)
-    assert np.isclose((z + w).nominal(""), 30, 1e-4)
-    assert np.isclose((z - w).nominal(""), 20, 1e-4)
-
-
-def test_multiplicacao_medidas():
-    x = lab.Medida(0, "", 0.1)
-    y = lab.Medida(0, "", 0.1)
-    correlacionado = x * x
-    nao_correlacionado = lab._medida.montecarlo(lambda a, b: a * b, x, y)
-    assert not (np.any(correlacionado.histograma) < 0)
-    assert np.any(nao_correlacionado.histograma > 0) and np.any(
-        nao_correlacionado.histograma < 0
-    )
-    assert not (
-        correlacionado._histograma is None and nao_correlacionado._histograma is None
+def test_operacoes_com_a_mesma_medida_preservam_correlacao() -> None:
+    medida = lab.Medida(5, "", 0.1)
+    medida_clone = lab.Medida(5, "", 0.1)
+    assert_medida_proxima(medida + medida, 10, 0.2)
+    assert_medida_proxima(medida - medida, 0, 0)
+    assert_medida_proxima(medida / medida, 1, 0)
+    with pytest.raises(AssertionError):
+        assert_medida_proxima(medida + medida_clone, 10, 0.2)
+    with pytest.raises(AssertionError):
+        assert_medida_proxima(medida - medida_clone, 0, 0.0)
+    with pytest.raises(AssertionError):
+        assert_medida_proxima(medida / medida_clone, 1, 0)
+
+
+@pytest.mark.parametrize(
+    ("operacao", "transformacao_no_histograma"),
+    [
+        (lambda medida: medida + 3, lambda amostras: amostras + 3),
+        (lambda medida: 3 + medida, lambda amostras: 3 + amostras),
+        (lambda medida: medida - 3, lambda amostras: amostras - 3),
+        (lambda medida: 3 - medida, lambda amostras: 3 - amostras),
+        (lambda medida: medida * -3, lambda histograma: histograma * -3),
+        (lambda medida: medida / -3, lambda histograma: histograma / -3),
+        (lambda medida: -medida, lambda histograma: -histograma),
+        (lambda medida: abs(medida), lambda histograma: abs(histograma)),
+        (lambda medida: +medida, lambda histograma: histograma),
+    ],
+)
+def test_operacoes_exatas_transformam_cada_amostra_do_histograma(
+    operacao: Callable[[lab.Medida], lab.Medida],
+    transformacao_no_histograma: Callable[[NDArray[np.float64]], NDArray[np.float64]],
+) -> None:
+    medida = lab.Medida(-5, "m", 0.1)
+    histograma_original = medida.histograma
+    assert isinstance(histograma_original, Quantity)
+
+    histograma_resultado = operacao(medida).histograma
+    assert isinstance(histograma_resultado, Quantity)
+    np.testing.assert_allclose(
+        histograma_resultado.magnitude,
+        transformacao_no_histograma(histograma_original.magnitude),
     )
-    w = lab.Medida(0, "", 0.1)
-    assert (
-        lab.comparar_medidas(w * x, nao_correlacionado) == lab.Comparacao.EQUIVALENTES
-    )
-
-
-def test_multiplicacao_cte():
-    x = lab.Medida(5, "", 0.1)
-    y = 3 * x
-    assert_medida_proxima(y, 15, 0.3)
-    y = (-3) * x
-    assert_medida_proxima(y, -15, 0.3)
-
-    y = x * 3
-    assert_medida_proxima(y, 15, 0.3)
-    y = x * (-3)
-    assert_medida_proxima(y, -15, 0.3)
-
-
-def test_mudanca_de_sinal():
-    x = lab.Medida(5, "", 0.1)
-    y = -x
-    assert y.nominal("") == -5 and y.incerteza("") == 0.1
-    assert x.nominal("") == 5 and x.incerteza("") == 0.1  # cria uma cópia
-    y = abs(y)
-    assert y.nominal("") == 5 and y.incerteza("") == 0.1
-    w = abs(x / y)
-    assert np.isclose(w.nominal(""), 1, rtol=1e-3)
-
-    z = +w
-    for i in range(len(z.histograma)):
-        assert z.histograma[i] == w.histograma[i]
-    w._nominal = 3
-    assert not isinstance(z._nominal, int)  # cria uma cópia
-
 
-def test_divisao():
-    x = lab.Medida(-3, "", 0.1)
-    correlacao = x / x
-    assert correlacao.nominal("") == 1 and correlacao.incerteza("") == 0
 
-    x = lab.Medida(5, "", 0.1)
-    assert (x / 5).nominal("") == 1 and (x / 5).incerteza("") == 0.1 / 5
-
-    y = lab.Medida(-3, "", 0.1)
-    assert (x / y).incerteza("") != 0
-
-    assert np.isclose((10 / x).nominal(""), 2, 1e-3)
-
-    divisao = (y / x).nominal("")
-    divisao_inversa = (x / y).nominal("")
-    assert np.isclose(divisao, 1 / divisao_inversa, rtol=1e-2)
-
-    with pytest.raises(TypeError):
-        "3" / lab.Medida(0, "", 0.1)
-
-
-def test_divisoes_especiais_nao_existe():
-    statements = [lambda x, y: x // y, lambda x, y: x % y, lambda x, y: divmod(x, y)]
-    with pytest.raises(TypeError):
-        for statement in statements:
-            statement(lab.Medida(6, "", 0.1), lab.Medida(1, "", 0.1))
-
-
-def test_potencia():
-    x = lab.Medida(2, "", 0.01)
-    y = lab.Medida(6, "", 0.01)
-    assert np.isclose((x**3).nominal(""), 8, 1e-3)
-    assert np.isclose((2**x).nominal(""), 4, 1e-3)
-    assert np.isclose((x**y).nominal(""), 64, 1e-2)
-    assert (x**y).incerteza("") > (x**2).incerteza("")
-    assert np.isclose((x**-20).nominal(""), 1 / (2**20), 1e-3)
+@pytest.mark.parametrize(
+    "operacao",
+    [
+        lambda medida: "3" / medida,
+        lambda medida: medida ** "3",
+        lambda medida: "3" ** medida,
+        lambda medida: medida // 2,
+        lambda medida: medida % 2,
+        lambda medida: divmod(medida, 2),
+    ],
+)
+def test_operacoes_nao_suportadas_levantam_type_error(
+    operacao: Callable[[lab.Medida], object],
+) -> None:
     with pytest.raises(TypeError):
-        lab.Medida(0, "", 0.1) ** "3"
-    with pytest.raises(TypeError):
-        "3" ** lab.Medida(0, "", 0.1)
-
-
-def test_soma_subtracao_constante_histograma():
-    x = lab.Medida(5, "m", 0.1)
-    h_x = x.histograma
-
-    y = x + 3.0
-    h_y = y.histograma
-
-    z = x - 2.0
-    h_z = z.histograma
-
-    assert np.allclose(h_y.magnitude - h_x.magnitude, 3.0)
-    assert np.allclose(h_z.magnitude - h_x.magnitude, -2.0)
+        operacao(lab.Medida(6, "", 0.1))
+
+
+OperacaoVetorizada = Callable[[lab.Medida, NDArray[np.object_]], NDArray[np.object_]]
+OperacaoEscalar = Callable[[lab.Medida, lab.Medida], lab.Medida]
+
+
+@pytest.mark.parametrize(
+    ("operacao_vetorizada", "operacao_elemento"),
+    [
+        (lambda escalar, array: escalar + array, lambda escalar, item: escalar + item),
+        (lambda escalar, array: array + escalar, lambda escalar, item: item + escalar),
+        (lambda escalar, array: escalar - array, lambda escalar, item: escalar - item),
+        (lambda escalar, array: array - escalar, lambda escalar, item: item - escalar),
+        (lambda escalar, array: escalar * array, lambda escalar, item: escalar * item),
+        (lambda escalar, array: array * escalar, lambda escalar, item: item * escalar),
+        (lambda escalar, array: escalar / array, lambda escalar, item: escalar / item),
+        (lambda escalar, array: array / escalar, lambda escalar, item: item / escalar),
+        (lambda escalar, array: escalar**array, lambda escalar, item: escalar**item),
+        (lambda escalar, array: array**escalar, lambda escalar, item: item**escalar),
+    ],
+)
+def test_operacoes_entre_medida_e_array_sao_elemento_a_elemento(
+    operacao_vetorizada: OperacaoVetorizada,
+    operacao_elemento: OperacaoEscalar,
+) -> None:
+    escalar = lab.Medida(2, "", 0.01)
+    medidas = lab.arrayM([1, 2, 4], "", 0.02)
+
+    resultado = operacao_vetorizada(escalar, medidas)
+
+    assert isinstance(resultado, np.ndarray)
+    assert resultado.shape == medidas.shape
+    assert resultado.dtype == object
+    for obtido, item in zip(resultado, medidas, strict=True):
+        assert isinstance(obtido, lab.Medida)
+        esperado = operacao_elemento(escalar, item)
+        assert_medida_proxima(
+            obtido,
+            esperado.nominal(""),
+            esperado.incerteza(""),
+            rtol=1e-3,
+            atol=1e-6,
+        )