Refuse class WindowSum

Author: densmirn

sdc/datatypes/hpat_pandas_series_rolling_functions.py

@@ -308,8 +308,28 @@ def apply_minp(arr, ddof, minp):
     gen_hpat_pandas_series_rolling_ddof_impl(arr_var))
 
 
-def gen_sdc_pandas_series_rolling_impl(window_cls):
-    """Generate series rolling methods implementations based on window class"""
+@sdc_register_jitable
+def pop_sum(value, nfinite, result):
+    """Calculate the window sum without old value."""
+    if numpy.isfinite(value):
+        nfinite -= 1
+        result -= value
+
+    return nfinite, result
+
+
+@sdc_register_jitable
+def put_sum(value, nfinite, result):
+    """Calculate the window sum with new value."""
+    if numpy.isfinite(value):
+        nfinite += 1
+        result += value
+
+    return nfinite, result
+
+
+def gen_sdc_pandas_series_rolling_impl(pop, put, init_result=numpy.nan):
+    """Generate series rolling methods implementations based on pop/put funcs"""
     def impl(self):
         win = self._window
         minp = self._min_periods
@@ -322,19 +342,37 @@ def impl(self):
         chunks = parallel_chunks(length)
         for i in prange(len(chunks)):
             chunk = chunks[i]
-            window = window_cls(win, minp)
+            nroll = 0
+            nfinite = 0
+            result = init_result
             for idx in range(chunk.start, chunk.stop):
-                window.roll(input_arr, idx)
-                output_arr[idx] = window.result
-            window.free()
+                if nroll == 0:
+                    start = max(idx + 1 - win, 0)
+                    for j in range(start, idx):
+                        value = input_arr[j]
+                        nfinite, result = put(value, nfinite, result)
+                        nroll += 1
+
+                if nroll >= win:
+                    value = input_arr[idx - win]
+                    nfinite, result = pop(value, nfinite, result)
+
+                value = input_arr[idx]
+                nfinite, result = put(value, nfinite, result)
+                nroll += 1
+
+                if nfinite < minp:
+                    output_arr[idx] = numpy.nan
+                else:
+                    output_arr[idx] = result
 
         return pandas.Series(output_arr, input_series._index,
                              name=input_series._name)
     return impl
 
 
-sdc_pandas_rolling_series_sum_impl = register_jitable(
-    gen_sdc_pandas_series_rolling_impl(WindowSum))
+sdc_pandas_series_rolling_sum_impl = register_jitable(
+    gen_sdc_pandas_series_rolling_impl(pop_sum, put_sum, init_result=0.))
 
 
 @sdc_rolling_overload(SeriesRollingType, 'apply')
@@ -648,7 +686,7 @@ def hpat_pandas_series_rolling_sum(self):
     ty_checker = TypeChecker('Method rolling.sum().')
     ty_checker.check(self, SeriesRollingType)
 
-    return sdc_pandas_rolling_series_sum_impl
+    return sdc_pandas_series_rolling_sum_impl
 
 
 @sdc_rolling_overload(SeriesRollingType, 'var')

sdc/tests/tests_perf/test_perf_series_rolling.py

@@ -85,7 +85,7 @@ class TestSeriesRollingMethods(TestBase):
     def setUpClass(cls):
         super().setUpClass()
         cls.map_ncalls_dlength = {
-            'sum': (100, [2 * 10 ** 5]),
+            'sum': (100, [8 * 10 ** 5]),
         }
 
     def _test_case(self, pyfunc, name, total_data_length, data_num=1,