fix: use hardcoded values for tests

Author: suzyahyah

pandas/tests/window/test_rolling.py

@@ -4,7 +4,6 @@
 )
 
 import numpy as np
-from numpy.lib.stride_tricks import sliding_window_view
 import pytest
 
 from pandas.compat import (
@@ -1081,132 +1080,91 @@ def test_rolling_sem(frame_or_series):
 
 
 @pytest.mark.parametrize(
-    ("func", "values", "window", "ddof", "exp_value"),
+    ("func", "values", "window", "ddof", "expected_values"),
     [
+        ("var", [99999999999999999, 1, 1, 2, 3, 1, 1], 2, 1, [5e33, 0, 0.5, 0.5, 2, 0]),
         (
-            "var",
-            [
-                2.72993945,
-                1.58444294,
-                4.14371708,
-                4.92961687,
-                2.7138744,
-                3.48168586,
-                0.69505519,
-                1.87511994,
-                4.20167276,
-                0.04797675,
-            ],
-            3,
+            "std",
+            [99999999999999999, 1, 1, 2, 3, 1, 1],
+            2,
             1,
-            "numpy_compute",
+            [7.071068e16, 0, 0.7071068, 0.7071068, 1.414214, 0],
         ),
+        ("var", [99999999999999999, 1, 2, 2, 3, 1, 1], 2, 1, [5e33, 0.5, 0, 0.5, 2, 0]),
         (
             "std",
-            [
-                2.72993945,
-                1.58444294,
-                4.14371708,
-                4.92961687,
-                2.7138744,
-                3.48168586,
-                0.69505519,
-                1.87511994,
-                4.20167276,
-                0.04797675,
-            ],
-            3,
+            [99999999999999999, 1, 2, 2, 3, 1, 1],
+            2,
+            1,
+            [7.071068e16, 0.7071068, 0, 0.7071068, 1.414214, 0],
+        ),
+        (
+            "std",
+            [1.2e03, 1.3e17, 1.5e17, 1.995e03, 1.990e03],
+            2,
             1,
-            "numpy_compute",
+            [9.192388e16, 1.414214e16, 1.060660e17, 3.535534e00],
         ),
         (
             "var",
             [
-                2.72993945,
-                1.58444294,
-                4.14371708,
-                4.92961687,
-                2.7138744,
-                3.48168586,
-                0.69505519,
-                1.87511994,
-                4.20167276,
-                0.04797675,
+                0.00000000e00,
+                0.00000000e00,
+                3.16188252e-18,
+                2.95781651e-16,
+                2.23153542e-51,
+                0.00000000e00,
+                0.00000000e00,
+                5.39943432e-48,
+                1.38206260e-73,
+                0.00000000e00,
             ],
-            2,
+            3,
             1,
-            "numpy_compute",
+            [
+                3.33250036e-036,
+                2.88538519e-032,
+                2.88538519e-032,
+                2.91622617e-032,
+                1.65991678e-102,
+                9.71796366e-096,
+                9.71796366e-096,
+                9.71796366e-096,
+            ],
         ),
         (
             "std",
+            [1, -1, 0, 1, 3, 2, -2, 10000000000, 1, 2, 0, -2, 1, 3, 0, 1],
+            6,
+            1,
             [
-                2.72993945,
-                1.58444294,
-                4.14371708,
-                4.92961687,
-                2.7138744,
-                3.48168586,
-                0.69505519,
-                1.87511994,
-                4.20167276,
-                0.04797675,
+                1.41421356e00,
+                1.87082869e00,
+                4.08248290e09,
+                4.08248290e09,
+                4.08248290e09,
+                4.08248290e09,
+                4.08248290e09,
+                4.08248290e09,
+                1.72240142e00,
+                1.75119007e00,
+                1.64316767e00,
             ],
-            2,
-            1,
-            "numpy_compute",
         ),
-        ("var", [99999999999999999, 1, 1, 2, 3, 1, 1], 2, 1, 0),
-        ("std", [99999999999999999, 1, 1, 2, 3, 1, 1], 2, 1, 0),
-        ("var", [99999999999999999, 1, 2, 2, 3, 1, 1], 2, 1, 0),
-        ("std", [99999999999999999, 1, 2, 2, 3, 1, 1], 2, 1, 0),
-        ("var", [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0], 5, 0, "numpy_compute"),
     ],
 )
-def test_rolling_var_correctness(func, values, window, ddof, exp_value):
-    # This tests subsume the previous tests under test_rolling_var_numerical_issues
-    # GH: 37051, 42064, 54333
+def test_rolling_var_correctness(func, values, window, ddof, expected_values):
+    # GH: 37051, 42064, 54518, 52407, 47721
     ts = Series(values)
     result = getattr(ts.rolling(window=window, center=True), func)(ddof=ddof)
     if result.last_valid_index():
         result = result[
             result.first_valid_index() : result.last_valid_index() + 1
         ].reset_index(drop=True)
-    expected = Series(
-        getattr(sliding_window_view(values, window_shape=window), func)(
-            axis=-1, ddof=ddof
-        )
-    )
+    expected = Series(expected_values)
     tm.assert_series_equal(result, expected, atol=1e-55)
     # GH 42064
-    if exp_value == 0:
-        # new `roll_var` will output 0.0 correctly
-        tm.assert_series_equal(result == 0, expected == 0)
-
-
-def test_rolling_var_numerical_stability():
-    # GH 52407
-    A = [
-        0.00000000e00,
-        0.00000000e00,
-        3.16188252e-18,
-        2.95781651e-16,
-        2.23153542e-51,
-        0.00000000e00,
-        0.00000000e00,
-        5.39943432e-48,
-        1.38206260e-73,
-        0.00000000e00,
-    ]
-    ts = Series(A)
-
-    result = ts.rolling(window=3, center=True).var(ddof=1)
-    result = result[
-        result.first_valid_index() : result.last_valid_index() + 1
-    ].reset_index(drop=True)
-
-    # numpy implementation
-    expected = Series(sliding_window_view(A, window_shape=3).var(axis=-1, ddof=1))
-    tm.assert_series_equal(result, expected, atol=1e-55)
+    tm.assert_series_equal(result == 0, expected == 0)
 
 
 def test_timeoffset_as_window_parameter_for_corr(unit):