From eafcae4ae78e27c43d223bc158face170b82e274 Mon Sep 17 00:00:00 2001 From: viknesh-ai Date: Mon, 10 Aug 2026 18:26:22 +0530 Subject: [PATCH] Migrate tests/test_aamp.py from npt.assert_almost_equal to npt.assert_allclose npt.assert_almost_equal only checks a fixed absolute tolerance, and NumPy's docs recommend assert_allclose instead. Every comparison in this file is against `ref_mp`/`comp_mp` (or a column slice of it), which combine a float distance column with int index columns and so come back dtype=object - np.isclose can't handle that directly. Cast both sides to float64 before comparing instead of leaving these on the deprecated API; the values are always numeric so the cast is exact. rtol is left at its default rather than pinned to 0. First of a per-file split of #1175, per review feedback. --- tests/test_aamp.py | 118 +++++++++++++++++++++++++++++++++------------ 1 file changed, 86 insertions(+), 32 deletions(-) diff --git a/tests/test_aamp.py b/tests/test_aamp.py index ac83786a9..9a8e4b84a 100644 --- a/tests/test_aamp.py +++ b/tests/test_aamp.py @@ -35,11 +35,15 @@ def test_aamp_self_join(T_A, T_B): comp_mp = aamp(T_B, m, p=p) naive.replace_inf(ref_mp) naive.replace_inf(comp_mp) - npt.assert_almost_equal(ref_mp, comp_mp) + npt.assert_allclose( + ref_mp.astype(np.float64), comp_mp.astype(np.float64), atol=1.5e-07 + ) comp_mp = aamp(pd.Series(T_B), m, p=p) naive.replace_inf(comp_mp) - npt.assert_almost_equal(ref_mp, comp_mp) + npt.assert_allclose( + ref_mp.astype(np.float64), comp_mp.astype(np.float64), atol=1.5e-07 + ) @pytest.mark.parametrize("T_A, T_B", test_data) @@ -50,11 +54,15 @@ def test_aamp_A_B_join(T_A, T_B): comp_mp = aamp(T_A, m, T_B, ignore_trivial=False, p=p) naive.replace_inf(ref_mp) naive.replace_inf(comp_mp) - npt.assert_almost_equal(ref_mp, comp_mp) + npt.assert_allclose( + ref_mp.astype(np.float64), comp_mp.astype(np.float64), atol=1.5e-07 + ) comp_mp = aamp(pd.Series(T_A), m, pd.Series(T_B), ignore_trivial=False, p=p) naive.replace_inf(comp_mp) - npt.assert_almost_equal(ref_mp, comp_mp) + npt.assert_allclose( + ref_mp.astype(np.float64), comp_mp.astype(np.float64), atol=1.5e-07 + ) def test_aamp_constant_subsequence_self_join(): @@ -64,11 +72,15 @@ def test_aamp_constant_subsequence_self_join(): comp_mp = aamp(T_A, m, ignore_trivial=True) naive.replace_inf(ref_mp) naive.replace_inf(comp_mp) - npt.assert_almost_equal(ref_mp[:, 0], comp_mp[:, 0]) # ignore indices + npt.assert_allclose( + ref_mp[:, 0].astype(np.float64), comp_mp[:, 0].astype(np.float64), atol=1.5e-07 + ) # ignore indices comp_mp = aamp(pd.Series(T_A), m, ignore_trivial=True) naive.replace_inf(comp_mp) - npt.assert_almost_equal(ref_mp[:, 0], comp_mp[:, 0]) # ignore indices + npt.assert_allclose( + ref_mp[:, 0].astype(np.float64), comp_mp[:, 0].astype(np.float64), atol=1.5e-07 + ) # ignore indices def test_aamp_one_constant_subsequence_A_B_join(): @@ -79,18 +91,24 @@ def test_aamp_one_constant_subsequence_A_B_join(): comp_mp = aamp(T_A, m, T_B, ignore_trivial=False) naive.replace_inf(ref_mp) naive.replace_inf(comp_mp) - npt.assert_almost_equal(ref_mp[:, 0], comp_mp[:, 0]) # ignore indices + npt.assert_allclose( + ref_mp[:, 0].astype(np.float64), comp_mp[:, 0].astype(np.float64), atol=1.5e-07 + ) # ignore indices comp_mp = aamp(pd.Series(T_A), m, pd.Series(T_B), ignore_trivial=False) naive.replace_inf(comp_mp) - npt.assert_almost_equal(ref_mp[:, 0], comp_mp[:, 0]) # ignore indices + npt.assert_allclose( + ref_mp[:, 0].astype(np.float64), comp_mp[:, 0].astype(np.float64), atol=1.5e-07 + ) # ignore indices # Swap inputs ref_mp = naive.aamp(T_B, m, T_B=T_A) comp_mp = aamp(T_B, m, T_A, ignore_trivial=False) naive.replace_inf(ref_mp) naive.replace_inf(comp_mp) - npt.assert_almost_equal(ref_mp[:, 0], comp_mp[:, 0]) # ignore indices + npt.assert_allclose( + ref_mp[:, 0].astype(np.float64), comp_mp[:, 0].astype(np.float64), atol=1.5e-07 + ) # ignore indices def test_aamp_two_constant_subsequences_A_B_join(): @@ -103,22 +121,30 @@ def test_aamp_two_constant_subsequences_A_B_join(): comp_mp = aamp(T_A, m, T_B, ignore_trivial=False) naive.replace_inf(ref_mp) naive.replace_inf(comp_mp) - npt.assert_almost_equal(ref_mp[:, 0], comp_mp[:, 0]) # ignore indices + npt.assert_allclose( + ref_mp[:, 0].astype(np.float64), comp_mp[:, 0].astype(np.float64), atol=1.5e-07 + ) # ignore indices comp_mp = aamp(pd.Series(T_A), m, pd.Series(T_B), ignore_trivial=False) naive.replace_inf(comp_mp) - npt.assert_almost_equal(ref_mp[:, 0], comp_mp[:, 0]) # ignore indices + npt.assert_allclose( + ref_mp[:, 0].astype(np.float64), comp_mp[:, 0].astype(np.float64), atol=1.5e-07 + ) # ignore indices # Swap inputs ref_mp = naive.aamp(T_B, m, T_B=T_A) comp_mp = aamp(T_B, m, T_A, ignore_trivial=False) naive.replace_inf(ref_mp) naive.replace_inf(comp_mp) - npt.assert_almost_equal(ref_mp[:, 0], comp_mp[:, 0]) # ignore indices + npt.assert_allclose( + ref_mp[:, 0].astype(np.float64), comp_mp[:, 0].astype(np.float64), atol=1.5e-07 + ) # ignore indices comp_mp = aamp(pd.Series(T_B), m, pd.Series(T_A), ignore_trivial=False) naive.replace_inf(comp_mp) - npt.assert_almost_equal(ref_mp[:, 0], comp_mp[:, 0]) # ignore indices + npt.assert_allclose( + ref_mp[:, 0].astype(np.float64), comp_mp[:, 0].astype(np.float64), atol=1.5e-07 + ) # ignore indices def test_aamp_identical_subsequence_self_join(): @@ -131,14 +157,18 @@ def test_aamp_identical_subsequence_self_join(): comp_mp = aamp(T_A, m, ignore_trivial=True) naive.replace_inf(ref_mp) naive.replace_inf(comp_mp) - npt.assert_almost_equal( - ref_mp[:, 0], comp_mp[:, 0], decimal=config.STUMPY_TEST_PRECISION + npt.assert_allclose( + ref_mp[:, 0].astype(np.float64), + comp_mp[:, 0].astype(np.float64), + atol=1.5 * 10**-config.STUMPY_TEST_PRECISION, ) # ignore indices comp_mp = aamp(pd.Series(T_A), m, ignore_trivial=True) naive.replace_inf(comp_mp) - npt.assert_almost_equal( - ref_mp[:, 0], comp_mp[:, 0], decimal=config.STUMPY_TEST_PRECISION + npt.assert_allclose( + ref_mp[:, 0].astype(np.float64), + comp_mp[:, 0].astype(np.float64), + atol=1.5 * 10**-config.STUMPY_TEST_PRECISION, ) # ignore indices @@ -153,14 +183,18 @@ def test_aamp_identical_subsequence_A_B_join(): comp_mp = aamp(T_A, m, T_B, ignore_trivial=False) naive.replace_inf(ref_mp) naive.replace_inf(comp_mp) - npt.assert_almost_equal( - ref_mp[:, 0], comp_mp[:, 0], config.STUMPY_TEST_PRECISION + npt.assert_allclose( + ref_mp[:, 0].astype(np.float64), + comp_mp[:, 0].astype(np.float64), + atol=1.5 * 10**-config.STUMPY_TEST_PRECISION, ) # ignore indices comp_mp = aamp(pd.Series(T_A), m, pd.Series(T_B), ignore_trivial=False) naive.replace_inf(comp_mp) - npt.assert_almost_equal( - ref_mp[:, 0], comp_mp[:, 0], config.STUMPY_TEST_PRECISION + npt.assert_allclose( + ref_mp[:, 0].astype(np.float64), + comp_mp[:, 0].astype(np.float64), + atol=1.5 * 10**-config.STUMPY_TEST_PRECISION, ) # ignore indices # Swap inputs @@ -168,8 +202,10 @@ def test_aamp_identical_subsequence_A_B_join(): comp_mp = aamp(T_B, m, T_A, ignore_trivial=False) naive.replace_inf(ref_mp) naive.replace_inf(comp_mp) - npt.assert_almost_equal( - ref_mp[:, 0], comp_mp[:, 0], config.STUMPY_TEST_PRECISION + npt.assert_allclose( + ref_mp[:, 0].astype(np.float64), + comp_mp[:, 0].astype(np.float64), + atol=1.5 * 10**-config.STUMPY_TEST_PRECISION, ) # ignore indices @@ -189,11 +225,15 @@ def test_aamp_nan_inf_self_join(T_A, T_B, substitute_B, substitution_locations): comp_mp = aamp(T_B_sub, m, ignore_trivial=True) naive.replace_inf(ref_mp) naive.replace_inf(comp_mp) - npt.assert_almost_equal(ref_mp, comp_mp) + npt.assert_allclose( + ref_mp.astype(np.float64), comp_mp.astype(np.float64), atol=1.5e-07 + ) comp_mp = aamp(pd.Series(T_B_sub), m, ignore_trivial=True) naive.replace_inf(comp_mp) - npt.assert_almost_equal(ref_mp, comp_mp) + npt.assert_allclose( + ref_mp.astype(np.float64), comp_mp.astype(np.float64), atol=1.5e-07 + ) @pytest.mark.parametrize("T_A, T_B", test_data) @@ -219,13 +259,17 @@ def test_aamp_nan_inf_A_B_join( comp_mp = aamp(T_A_sub, m, T_B_sub, ignore_trivial=False) naive.replace_inf(ref_mp) naive.replace_inf(comp_mp) - npt.assert_almost_equal(ref_mp, comp_mp) + npt.assert_allclose( + ref_mp.astype(np.float64), comp_mp.astype(np.float64), atol=1.5e-07 + ) comp_mp = aamp( pd.Series(T_A_sub), m, pd.Series(T_B_sub), ignore_trivial=False ) naive.replace_inf(comp_mp) - npt.assert_almost_equal(ref_mp, comp_mp) + npt.assert_allclose( + ref_mp.astype(np.float64), comp_mp.astype(np.float64), atol=1.5e-07 + ) def test_aamp_nan_zero_mean_self_join(): @@ -237,7 +281,9 @@ def test_aamp_nan_zero_mean_self_join(): naive.replace_inf(ref_mp) naive.replace_inf(comp_mp) - npt.assert_almost_equal(ref_mp, comp_mp) + npt.assert_allclose( + ref_mp.astype(np.float64), comp_mp.astype(np.float64), atol=1.5e-07 + ) @pytest.mark.parametrize("T_A, T_B", test_data) @@ -249,11 +295,15 @@ def test_aamp_self_join_KNN(T_A, T_B): comp_mp = aamp(T_B, m, p=p, k=k) naive.replace_inf(ref_mp) naive.replace_inf(comp_mp) - npt.assert_almost_equal(ref_mp, comp_mp) + npt.assert_allclose( + ref_mp.astype(np.float64), comp_mp.astype(np.float64), atol=1.5e-07 + ) comp_mp = aamp(pd.Series(T_B), m, p=p, k=k) naive.replace_inf(comp_mp) - npt.assert_almost_equal(ref_mp, comp_mp) + npt.assert_allclose( + ref_mp.astype(np.float64), comp_mp.astype(np.float64), atol=1.5e-07 + ) @pytest.mark.parametrize("T_A, T_B", test_data) @@ -265,10 +315,14 @@ def test_aamp_A_B_join_KNN(T_A, T_B): comp_mp = aamp(T_A, m, T_B, ignore_trivial=False, p=p, k=k) naive.replace_inf(ref_mp) naive.replace_inf(comp_mp) - npt.assert_almost_equal(ref_mp, comp_mp) + npt.assert_allclose( + ref_mp.astype(np.float64), comp_mp.astype(np.float64), atol=1.5e-07 + ) comp_mp = aamp( pd.Series(T_A), m, pd.Series(T_B), ignore_trivial=False, p=p, k=k ) naive.replace_inf(comp_mp) - npt.assert_almost_equal(ref_mp, comp_mp) + npt.assert_allclose( + ref_mp.astype(np.float64), comp_mp.astype(np.float64), atol=1.5e-07 + )