From 6dcb56a459e4ec9c60fc9504a1e04cab397b012b Mon Sep 17 00:00:00 2001 From: Matt Roeschke Date: Sat, 26 Sep 2020 14:23:25 -0700 Subject: [PATCH 1/5] CLN: test_moments_rolling.py for mean --- .../window/moments/test_moments_rolling.py | 4 - .../moments/test_moments_rolling_mean.py | 131 ++++++++++++++++++ 2 files changed, 131 insertions(+), 4 deletions(-) create mode 100644 pandas/tests/window/moments/test_moments_rolling_mean.py diff --git a/pandas/tests/window/moments/test_moments_rolling.py b/pandas/tests/window/moments/test_moments_rolling.py index da256e80dff7e..48709f4ac8b76 100644 --- a/pandas/tests/window/moments/test_moments_rolling.py +++ b/pandas/tests/window/moments/test_moments_rolling.py @@ -236,10 +236,6 @@ def test_rolling_count(raw, series, frame): ) -def test_rolling_mean(raw, series, frame): - _check_moment_func(np.mean, name="mean", raw=raw, series=series, frame=frame) - - @td.skip_if_no_scipy def test_cmov_mean(): # GH 8238 diff --git a/pandas/tests/window/moments/test_moments_rolling_mean.py b/pandas/tests/window/moments/test_moments_rolling_mean.py new file mode 100644 index 0000000000000..eee8457a773f2 --- /dev/null +++ b/pandas/tests/window/moments/test_moments_rolling_mean.py @@ -0,0 +1,131 @@ +import numpy as np +import pytest + +from pandas import DataFrame, Series, concat, isna, notna +import pandas._testing as tm + +import pandas.tseries.offsets as offsets + + +def test_series(series): + result = series.rolling(50).mean() + assert isinstance(result, Series) + tm.assert_almost_equal(result.iloc[-1], np.mean(series[-50:])) + + +def test_frame(raw, frame): + result = frame.rolling(50).mean() + assert isinstance(result, DataFrame) + tm.assert_series_equal( + result.iloc[-1, :], + frame.iloc[-50:, :].apply(np.mean, axis=0, raw=raw), + check_names=False, + ) + + +def test_time_rule_series(series): + win = 25 + minp = 10 + ser = series[::2].resample("B").mean() + series_result = ser.rolling(window=win, min_periods=minp).mean() + last_date = series_result.index[-1] + prev_date = last_date - 24 * offsets.BDay() + + trunc_series = series[::2].truncate(prev_date, last_date) + tm.assert_almost_equal(series_result[-1], np.mean(trunc_series)) + + +def test_time_rule_frame(raw, frame): + win = 25 + minp = 10 + frm = frame[::2].resample("B").mean() + frame_result = frm.rolling(window=win, min_periods=minp).mean() + last_date = frame_result.index[-1] + prev_date = last_date - 24 * offsets.BDay() + + trunc_frame = frame[::2].truncate(prev_date, last_date) + tm.assert_series_equal( + frame_result.xs(last_date), + trunc_frame.apply(np.mean, raw=raw), + check_names=False, + ) + + +def test_nans(): + obj = Series(np.random.randn(50)) + obj[:10] = np.NaN + obj[-10:] = np.NaN + + result = obj.rolling(50, min_periods=30).mean() + tm.assert_almost_equal(result.iloc[-1], np.mean(obj[10:-10])) + + # min_periods is working correctly + result = obj.rolling(20, min_periods=15).mean() + assert isna(result.iloc[23]) + assert not isna(result.iloc[24]) + + assert not isna(result.iloc[-6]) + assert isna(result.iloc[-5]) + + obj2 = Series(np.random.randn(20)) + result = obj2.rolling(10, min_periods=5).mean() + assert isna(result.iloc[3]) + assert notna(result.iloc[4]) + + +@pytest.mark.parametrize("minp", [0, 99, 100]) +def test_min_periods(series, minp): + result = series.rolling(len(series) + 1, min_periods=minp).mean() + expected = series.rolling(len(series), min_periods=minp).mean() + nan_mask = isna(result) + tm.assert_series_equal(nan_mask, isna(expected)) + + nan_mask = ~nan_mask + tm.assert_almost_equal(result[nan_mask], expected[nan_mask]) + + +def test_center(): + obj = Series(np.random.randn(50)) + obj[:10] = np.NaN + obj[-10:] = np.NaN + + result = obj.rolling(20, min_periods=15, center=True).mean() + expected = ( + concat([obj, Series([np.NaN] * 9)]) + .rolling(20, min_periods=15) + .mean()[9:] + .reset_index(drop=True) + ) + tm.assert_series_equal(result, expected) + + +def test_center_reindex_series(series): + # shifter index + s = [f"x{x:d}" for x in range(12)] + minp = 10 + + series_xp = ( + series.reindex(list(series.index) + s) + .rolling(window=25, min_periods=minp) + .mean() + .shift(-12) + .reindex(series.index) + ) + series_rs = series.rolling(window=25, min_periods=minp, center=True).mean() + tm.assert_series_equal(series_xp, series_rs) + + +def test_center_reindex_frame(frame): + # shifter index + s = [f"x{x:d}" for x in range(12)] + minp = 10 + + frame_xp = ( + frame.reindex(list(frame.index) + s) + .rolling(window=25, min_periods=minp) + .mean() + .shift(-12) + .reindex(frame.index) + ) + frame_rs = frame.rolling(window=25, min_periods=minp, center=True).mean() + tm.assert_frame_equal(frame_xp, frame_rs) From c4a2d37fe13ae85035c3a9bd86f9b70bf4ca9ced Mon Sep 17 00:00:00 2001 From: Matt Roeschke Date: Sat, 26 Sep 2020 14:38:38 -0700 Subject: [PATCH 2/5] Add missing test --- pandas/tests/window/moments/test_moments_rolling_mean.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/pandas/tests/window/moments/test_moments_rolling_mean.py b/pandas/tests/window/moments/test_moments_rolling_mean.py index eee8457a773f2..41089f77d8127 100644 --- a/pandas/tests/window/moments/test_moments_rolling_mean.py +++ b/pandas/tests/window/moments/test_moments_rolling_mean.py @@ -72,6 +72,10 @@ def test_nans(): assert isna(result.iloc[3]) assert notna(result.iloc[4]) + result0 = obj.rolling(20, min_periods=0).mean() + result1 = obj.rolling(20, min_periods=1).mean() + tm.assert_almost_equal(result0, result1) + @pytest.mark.parametrize("minp", [0, 99, 100]) def test_min_periods(series, minp): From c2b7d9a3f447407c948fbc11766720976432bc5c Mon Sep 17 00:00:00 2001 From: Matt Roeschke Date: Sat, 26 Sep 2020 17:52:54 -0700 Subject: [PATCH 3/5] Parameterize over more functions --- .../window/moments/test_moments_rolling.py | 64 +--- .../moments/test_moments_rolling_functions.py | 302 ++++++++++++++++++ .../moments/test_moments_rolling_mean.py | 135 -------- 3 files changed, 304 insertions(+), 197 deletions(-) create mode 100644 pandas/tests/window/moments/test_moments_rolling_functions.py delete mode 100644 pandas/tests/window/moments/test_moments_rolling_mean.py diff --git a/pandas/tests/window/moments/test_moments_rolling.py b/pandas/tests/window/moments/test_moments_rolling.py index 9bb3c16586f80..99c08b5b083e0 100644 --- a/pandas/tests/window/moments/test_moments_rolling.py +++ b/pandas/tests/window/moments/test_moments_rolling.py @@ -211,30 +211,6 @@ def test_centered_axis_validation(): (DataFrame(np.ones((10, 10))).rolling(window=3, center=True, axis=2).mean()) -def test_rolling_sum(raw, series, frame): - _check_moment_func( - np.nansum, - name="sum", - zero_min_periods_equal=False, - raw=raw, - series=series, - frame=frame, - ) - - -def test_rolling_count(raw, series, frame): - counter = lambda x: np.isfinite(x).astype(float).sum() - _check_moment_func( - counter, - name="count", - has_min_periods=False, - fill_value=0, - raw=raw, - series=series, - frame=frame, - ) - - @td.skip_if_no_scipy def test_cmov_mean(): # GH 8238 @@ -729,13 +705,7 @@ def test_cmov_window_special_linear_range(win_types_special): tm.assert_series_equal(xp, rs) -def test_rolling_median(raw, series, frame): - _check_moment_func(np.median, name="median", raw=raw, series=series, frame=frame) - - -def test_rolling_min(raw, series, frame): - _check_moment_func(np.min, name="min", raw=raw, series=series, frame=frame) - +def test_rolling_min_min_periods(): a = pd.Series([1, 2, 3, 4, 5]) result = a.rolling(window=100, min_periods=1).min() expected = pd.Series(np.ones(len(a))) @@ -745,9 +715,7 @@ def test_rolling_min(raw, series, frame): pd.Series([1, 2, 3]).rolling(window=3, min_periods=5).min() -def test_rolling_max(raw, series, frame): - _check_moment_func(np.max, name="max", raw=raw, series=series, frame=frame) - +def test_rolling_max_min_periods(): a = pd.Series([1, 2, 3, 4, 5], dtype=np.float64) b = a.rolling(window=100, min_periods=1).max() tm.assert_almost_equal(a, b) @@ -851,20 +819,6 @@ def test_rolling_quantile_param(): ser.rolling(3).quantile("foo") -def test_rolling_std(raw, series, frame): - _check_moment_func( - lambda x: np.std(x, ddof=1), name="std", raw=raw, series=series, frame=frame - ) - _check_moment_func( - lambda x: np.std(x, ddof=0), - name="std", - ddof=0, - raw=raw, - series=series, - frame=frame, - ) - - def test_rolling_std_1obs(): vals = pd.Series([1.0, 2.0, 3.0, 4.0, 5.0]) @@ -901,20 +855,6 @@ def test_rolling_std_neg_sqrt(): assert np.isfinite(b[2:]).all() -def test_rolling_var(raw, series, frame): - _check_moment_func( - lambda x: np.var(x, ddof=1), name="var", raw=raw, series=series, frame=frame - ) - _check_moment_func( - lambda x: np.var(x, ddof=0), - name="var", - ddof=0, - raw=raw, - series=series, - frame=frame, - ) - - @td.skip_if_no_scipy def test_rolling_skew(raw, series, frame): from scipy.stats import skew diff --git a/pandas/tests/window/moments/test_moments_rolling_functions.py b/pandas/tests/window/moments/test_moments_rolling_functions.py new file mode 100644 index 0000000000000..98c7a0a055bd3 --- /dev/null +++ b/pandas/tests/window/moments/test_moments_rolling_functions.py @@ -0,0 +1,302 @@ +import numpy as np +import pytest + +from pandas import DataFrame, Series, concat, isna, notna +import pandas._testing as tm + +import pandas.tseries.offsets as offsets + + +@pytest.mark.parametrize( + "compare_func, roll_func, kwargs", + [ + [np.mean, "mean", {}], + [np.nansum, "sum", {}], + [lambda x: np.isfinite(x).astype(float).sum(), "count", {}], + [np.median, "median", {}], + [np.min, "min", {}], + [np.max, "max", {}], + [lambda x: np.std(x, ddof=1), "std", {}], + [lambda x: np.std(x, ddof=0), "std", {"ddof": 0}], + [lambda x: np.var(x, ddof=1), "var", {}], + [lambda x: np.var(x, ddof=0), "var", {"ddof": 0}], + ], +) +def test_series(series, compare_func, roll_func, kwargs): + result = getattr(series.rolling(50), roll_func)(**kwargs) + assert isinstance(result, Series) + tm.assert_almost_equal(result.iloc[-1], compare_func(series[-50:])) + + +@pytest.mark.parametrize( + "compare_func, roll_func, kwargs", + [ + [np.mean, "mean", {}], + [np.nansum, "sum", {}], + [lambda x: np.isfinite(x).astype(float).sum(), "count", {}], + [np.median, "median", {}], + [np.min, "min", {}], + [np.max, "max", {}], + [lambda x: np.std(x, ddof=1), "std", {}], + [lambda x: np.std(x, ddof=0), "std", {"ddof": 0}], + [lambda x: np.var(x, ddof=1), "var", {}], + [lambda x: np.var(x, ddof=0), "var", {"ddof": 0}], + ], +) +def test_frame(raw, frame, compare_func, roll_func, kwargs): + result = getattr(frame.rolling(50), roll_func)(**kwargs) + assert isinstance(result, DataFrame) + tm.assert_series_equal( + result.iloc[-1, :], + frame.iloc[-50:, :].apply(compare_func, axis=0, raw=raw), + check_names=False, + ) + + +@pytest.mark.parametrize( + "compare_func, roll_func, kwargs, minp", + [ + [np.mean, "mean", {}, 10], + [np.nansum, "sum", {}, 10], + [lambda x: np.isfinite(x).astype(float).sum(), "count", {}, 0], + [np.median, "median", {}, 10], + [np.min, "min", {}, 10], + [np.max, "max", {}, 10], + [lambda x: np.std(x, ddof=1), "std", {}, 10], + [lambda x: np.std(x, ddof=0), "std", {"ddof": 0}, 10], + [lambda x: np.var(x, ddof=1), "var", {}, 10], + [lambda x: np.var(x, ddof=0), "var", {"ddof": 0}, 10], + ], +) +def test_time_rule_series(series, compare_func, roll_func, kwargs, minp): + win = 25 + ser = series[::2].resample("B").mean() + series_result = getattr(ser.rolling(window=win, min_periods=minp), roll_func)( + **kwargs + ) + last_date = series_result.index[-1] + prev_date = last_date - 24 * offsets.BDay() + + trunc_series = series[::2].truncate(prev_date, last_date) + tm.assert_almost_equal(series_result[-1], compare_func(trunc_series)) + + +@pytest.mark.parametrize( + "compare_func, roll_func, kwargs, minp", + [ + [np.mean, "mean", {}, 10], + [np.nansum, "sum", {}, 10], + [lambda x: np.isfinite(x).astype(float).sum(), "count", {}, 0], + [np.median, "median", {}, 10], + [np.min, "min", {}, 10], + [np.max, "max", {}, 10], + [lambda x: np.std(x, ddof=1), "std", {}, 10], + [lambda x: np.std(x, ddof=0), "std", {"ddof": 0}, 10], + [lambda x: np.var(x, ddof=1), "var", {}, 10], + [lambda x: np.var(x, ddof=0), "var", {"ddof": 0}, 10], + ], +) +def test_time_rule_frame(raw, frame, compare_func, roll_func, kwargs, minp): + win = 25 + frm = frame[::2].resample("B").mean() + frame_result = getattr(frm.rolling(window=win, min_periods=minp), roll_func)( + **kwargs + ) + last_date = frame_result.index[-1] + prev_date = last_date - 24 * offsets.BDay() + + trunc_frame = frame[::2].truncate(prev_date, last_date) + tm.assert_series_equal( + frame_result.xs(last_date), + trunc_frame.apply(compare_func, raw=raw), + check_names=False, + ) + + +@pytest.mark.parametrize( + "compare_func, roll_func, kwargs", + [ + [np.mean, "mean", {}], + [np.nansum, "sum", {}], + [np.median, "median", {}], + [np.min, "min", {}], + [np.max, "max", {}], + [lambda x: np.std(x, ddof=1), "std", {}], + [lambda x: np.std(x, ddof=0), "std", {"ddof": 0}], + [lambda x: np.var(x, ddof=1), "var", {}], + [lambda x: np.var(x, ddof=0), "var", {"ddof": 0}], + ], +) +def test_nans(compare_func, roll_func, kwargs): + obj = Series(np.random.randn(50)) + obj[:10] = np.NaN + obj[-10:] = np.NaN + + result = getattr(obj.rolling(50, min_periods=30), roll_func)(**kwargs) + tm.assert_almost_equal(result.iloc[-1], compare_func(obj[10:-10])) + + # min_periods is working correctly + result = getattr(obj.rolling(20, min_periods=15), roll_func)(**kwargs) + assert isna(result.iloc[23]) + assert not isna(result.iloc[24]) + + assert not isna(result.iloc[-6]) + assert isna(result.iloc[-5]) + + obj2 = Series(np.random.randn(20)) + result = getattr(obj2.rolling(10, min_periods=5), roll_func)(**kwargs) + assert isna(result.iloc[3]) + assert notna(result.iloc[4]) + + if roll_func != "sum": + result0 = getattr(obj.rolling(20, min_periods=0), roll_func)(**kwargs) + result1 = getattr(obj.rolling(20, min_periods=1), roll_func)(**kwargs) + tm.assert_almost_equal(result0, result1) + + +def test_nans_count(): + obj = Series(np.random.randn(50)) + obj[:10] = np.NaN + obj[-10:] = np.NaN + result = obj.rolling(50, min_periods=30).count() + tm.assert_almost_equal( + result.iloc[-1], np.isfinite(obj[10:-10]).astype(float).sum() + ) + + +@pytest.mark.parametrize( + "roll_func, kwargs", + [ + ["mean", {}], + ["sum", {}], + ["median", {}], + ["min", {}], + ["max", {}], + ["std", {}], + ["std", {"ddof": 0}], + ["var", {}], + ["var", {"ddof": 0}], + ], +) +@pytest.mark.parametrize("minp", [0, 99, 100]) +def test_min_periods(series, minp, roll_func, kwargs): + result = getattr(series.rolling(len(series) + 1, min_periods=minp), roll_func)( + **kwargs + ) + expected = getattr(series.rolling(len(series), min_periods=minp), roll_func)( + **kwargs + ) + nan_mask = isna(result) + tm.assert_series_equal(nan_mask, isna(expected)) + + nan_mask = ~nan_mask + tm.assert_almost_equal(result[nan_mask], expected[nan_mask]) + + +def test_min_periods_count(series): + result = series.rolling(len(series) + 1, min_periods=0).count() + expected = series.rolling(len(series), min_periods=0).count() + nan_mask = isna(result) + tm.assert_series_equal(nan_mask, isna(expected)) + + nan_mask = ~nan_mask + tm.assert_almost_equal(result[nan_mask], expected[nan_mask]) + + +@pytest.mark.parametrize( + "roll_func, kwargs, minp", + [ + ["mean", {}, 15], + ["sum", {}, 15], + ["count", {}, 0], + ["median", {}, 15], + ["min", {}, 15], + ["max", {}, 15], + ["std", {}, 15], + ["std", {"ddof": 0}, 15], + ["var", {}, 15], + ["var", {"ddof": 0}, 15], + ], +) +def test_center(roll_func, kwargs, minp): + obj = Series(np.random.randn(50)) + obj[:10] = np.NaN + obj[-10:] = np.NaN + + result = getattr(obj.rolling(20, min_periods=minp, center=True), roll_func)( + **kwargs + ) + expected = getattr( + concat([obj, Series([np.NaN] * 9)]).rolling(20, min_periods=minp), roll_func + )(**kwargs)[9:].reset_index(drop=True) + tm.assert_series_equal(result, expected) + + +@pytest.mark.parametrize( + "roll_func, kwargs, minp, fill_value", + [ + ["mean", {}, 10, None], + ["sum", {}, 10, None], + ["count", {}, 0, 0], + ["median", {}, 10, None], + ["min", {}, 10, None], + ["max", {}, 10, None], + ["std", {}, 10, None], + ["std", {"ddof": 0}, 10, None], + ["var", {}, 10, None], + ["var", {"ddof": 0}, 10, None], + ], +) +def test_center_reindex_series(series, roll_func, kwargs, minp, fill_value): + # shifter index + s = [f"x{x:d}" for x in range(12)] + + series_xp = ( + getattr( + series.reindex(list(series.index) + s).rolling(window=25, min_periods=minp), + roll_func, + )(**kwargs) + .shift(-12) + .reindex(series.index) + ) + series_rs = getattr( + series.rolling(window=25, min_periods=minp, center=True), roll_func + )(**kwargs) + if fill_value is not None: + series_xp = series_xp.fillna(fill_value) + tm.assert_series_equal(series_xp, series_rs) + + +@pytest.mark.parametrize( + "roll_func, kwargs, minp, fill_value", + [ + ["mean", {}, 10, None], + ["sum", {}, 10, None], + ["count", {}, 0, 0], + ["median", {}, 10, None], + ["min", {}, 10, None], + ["max", {}, 10, None], + ["std", {}, 10, None], + ["std", {"ddof": 0}, 10, None], + ["var", {}, 10, None], + ["var", {"ddof": 0}, 10, None], + ], +) +def test_center_reindex_frame(frame, roll_func, kwargs, minp, fill_value): + # shifter index + s = [f"x{x:d}" for x in range(12)] + + frame_xp = ( + getattr( + frame.reindex(list(frame.index) + s).rolling(window=25, min_periods=minp), + roll_func, + )(**kwargs) + .shift(-12) + .reindex(frame.index) + ) + frame_rs = getattr( + frame.rolling(window=25, min_periods=minp, center=True), roll_func + )(**kwargs) + if fill_value is not None: + frame_xp = frame_xp.fillna(fill_value) + tm.assert_frame_equal(frame_xp, frame_rs) diff --git a/pandas/tests/window/moments/test_moments_rolling_mean.py b/pandas/tests/window/moments/test_moments_rolling_mean.py deleted file mode 100644 index 41089f77d8127..0000000000000 --- a/pandas/tests/window/moments/test_moments_rolling_mean.py +++ /dev/null @@ -1,135 +0,0 @@ -import numpy as np -import pytest - -from pandas import DataFrame, Series, concat, isna, notna -import pandas._testing as tm - -import pandas.tseries.offsets as offsets - - -def test_series(series): - result = series.rolling(50).mean() - assert isinstance(result, Series) - tm.assert_almost_equal(result.iloc[-1], np.mean(series[-50:])) - - -def test_frame(raw, frame): - result = frame.rolling(50).mean() - assert isinstance(result, DataFrame) - tm.assert_series_equal( - result.iloc[-1, :], - frame.iloc[-50:, :].apply(np.mean, axis=0, raw=raw), - check_names=False, - ) - - -def test_time_rule_series(series): - win = 25 - minp = 10 - ser = series[::2].resample("B").mean() - series_result = ser.rolling(window=win, min_periods=minp).mean() - last_date = series_result.index[-1] - prev_date = last_date - 24 * offsets.BDay() - - trunc_series = series[::2].truncate(prev_date, last_date) - tm.assert_almost_equal(series_result[-1], np.mean(trunc_series)) - - -def test_time_rule_frame(raw, frame): - win = 25 - minp = 10 - frm = frame[::2].resample("B").mean() - frame_result = frm.rolling(window=win, min_periods=minp).mean() - last_date = frame_result.index[-1] - prev_date = last_date - 24 * offsets.BDay() - - trunc_frame = frame[::2].truncate(prev_date, last_date) - tm.assert_series_equal( - frame_result.xs(last_date), - trunc_frame.apply(np.mean, raw=raw), - check_names=False, - ) - - -def test_nans(): - obj = Series(np.random.randn(50)) - obj[:10] = np.NaN - obj[-10:] = np.NaN - - result = obj.rolling(50, min_periods=30).mean() - tm.assert_almost_equal(result.iloc[-1], np.mean(obj[10:-10])) - - # min_periods is working correctly - result = obj.rolling(20, min_periods=15).mean() - assert isna(result.iloc[23]) - assert not isna(result.iloc[24]) - - assert not isna(result.iloc[-6]) - assert isna(result.iloc[-5]) - - obj2 = Series(np.random.randn(20)) - result = obj2.rolling(10, min_periods=5).mean() - assert isna(result.iloc[3]) - assert notna(result.iloc[4]) - - result0 = obj.rolling(20, min_periods=0).mean() - result1 = obj.rolling(20, min_periods=1).mean() - tm.assert_almost_equal(result0, result1) - - -@pytest.mark.parametrize("minp", [0, 99, 100]) -def test_min_periods(series, minp): - result = series.rolling(len(series) + 1, min_periods=minp).mean() - expected = series.rolling(len(series), min_periods=minp).mean() - nan_mask = isna(result) - tm.assert_series_equal(nan_mask, isna(expected)) - - nan_mask = ~nan_mask - tm.assert_almost_equal(result[nan_mask], expected[nan_mask]) - - -def test_center(): - obj = Series(np.random.randn(50)) - obj[:10] = np.NaN - obj[-10:] = np.NaN - - result = obj.rolling(20, min_periods=15, center=True).mean() - expected = ( - concat([obj, Series([np.NaN] * 9)]) - .rolling(20, min_periods=15) - .mean()[9:] - .reset_index(drop=True) - ) - tm.assert_series_equal(result, expected) - - -def test_center_reindex_series(series): - # shifter index - s = [f"x{x:d}" for x in range(12)] - minp = 10 - - series_xp = ( - series.reindex(list(series.index) + s) - .rolling(window=25, min_periods=minp) - .mean() - .shift(-12) - .reindex(series.index) - ) - series_rs = series.rolling(window=25, min_periods=minp, center=True).mean() - tm.assert_series_equal(series_xp, series_rs) - - -def test_center_reindex_frame(frame): - # shifter index - s = [f"x{x:d}" for x in range(12)] - minp = 10 - - frame_xp = ( - frame.reindex(list(frame.index) + s) - .rolling(window=25, min_periods=minp) - .mean() - .shift(-12) - .reindex(frame.index) - ) - frame_rs = frame.rolling(window=25, min_periods=minp, center=True).mean() - tm.assert_frame_equal(frame_xp, frame_rs) From 2ddf9938addf253f25abb4b9f9eaa5fab44f318b Mon Sep 17 00:00:00 2001 From: Matt Roeschke Date: Sun, 27 Sep 2020 00:48:08 -0700 Subject: [PATCH 4/5] Remove usused param since apply was moved --- pandas/tests/window/moments/test_moments_rolling.py | 6 ------ 1 file changed, 6 deletions(-) diff --git a/pandas/tests/window/moments/test_moments_rolling.py b/pandas/tests/window/moments/test_moments_rolling.py index 99c08b5b083e0..3db863df808e5 100644 --- a/pandas/tests/window/moments/test_moments_rolling.py +++ b/pandas/tests/window/moments/test_moments_rolling.py @@ -26,12 +26,6 @@ def _check_moment_func( frame=None, **kwargs, ): - - # inject raw - if name == "apply": - kwargs = copy.copy(kwargs) - kwargs["raw"] = raw - def get_result(obj, window, min_periods=None, center=False): r = obj.rolling(window=window, min_periods=min_periods, center=center) return getattr(r, name)(**kwargs) From d8c6d52bbbf045bc2c46c1216e588e42faf64235 Mon Sep 17 00:00:00 2001 From: Matt Roeschke Date: Sun, 27 Sep 2020 10:00:41 -0700 Subject: [PATCH 5/5] Remove copy import --- pandas/tests/window/moments/test_moments_rolling.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/pandas/tests/window/moments/test_moments_rolling.py b/pandas/tests/window/moments/test_moments_rolling.py index 3db863df808e5..880316ec6111a 100644 --- a/pandas/tests/window/moments/test_moments_rolling.py +++ b/pandas/tests/window/moments/test_moments_rolling.py @@ -1,5 +1,3 @@ -import copy - import numpy as np from numpy.random import randn import pytest