Overload series.rolling.skew() (#444)

* Overload series.rolling.skew()

* Remove excess code for series.rolling.skew()

* Minor fix in test for series.rolling.skew()

* Move method std back

Co-authored-by: Alexander Kalistratov <alexander.kalistratov@intel.com>

Author: densmirn

examples/series/rolling/series_rolling_skew.py

@@ -0,0 +1,39 @@
+# *****************************************************************************
+# Copyright (c) 2019, Intel Corporation All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     Redistributions of source code must retain the above copyright notice,
+#     this list of conditions and the following disclaimer.
+#
+#     Redistributions in binary form must reproduce the above copyright notice,
+#     this list of conditions and the following disclaimer in the documentation
+#     and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+# *****************************************************************************
+
+import pandas as pd
+from numba import njit
+
+
+@njit
+def series_rolling_skew():
+    series = pd.Series([4, 3, 5, 2, 6])  # Series of 4, 3, 5, 2, 6
+    out_series = series.rolling(3).skew()
+
+    return out_series  # Expect series of NaN, NaN, 0.000000, 0.935220, -1.293343
+
+
+print(series_rolling_skew())

sdc/datatypes/hpat_pandas_series_rolling_functions.py

@@ -153,6 +153,31 @@ def arr_quantile(arr, q):
     return numpy.quantile(arr, q)
 
 
+@register_jitable
+def _moment(arr, moment):
+    mn = numpy.mean(arr)
+    s = numpy.power((arr - mn), moment)
+
+    return numpy.mean(s)
+
+
+@register_jitable
+def arr_skew(arr):
+    """Calculate unbiased skewness of values"""
+    n = len(arr)
+    if n < 3:
+        return numpy.nan
+
+    m2 = _moment(arr, 2)
+    m3 = _moment(arr, 3)
+    val = 0 if m2 == 0 else m3 / m2 ** 1.5
+
+    if (n > 2) & (m2 > 0):
+        val = numpy.sqrt((n - 1.0) * n) / (n - 2.0) * m3 / m2 ** 1.5
+
+    return val
+
+
 @register_jitable
 def arr_std(arr, ddof):
     """Calculate standard deviation of values"""
@@ -247,6 +272,8 @@ def impl(self):
     gen_hpat_pandas_series_rolling_impl(arr_median, float64))
 hpat_pandas_rolling_series_min_impl = register_jitable(
     gen_hpat_pandas_series_rolling_impl(arr_min, float64))
+hpat_pandas_rolling_series_skew_impl = register_jitable(
+    gen_hpat_pandas_series_rolling_impl(arr_skew, float64))
 hpat_pandas_rolling_series_sum_impl = register_jitable(
     gen_hpat_pandas_series_rolling_impl(arr_sum, float64))
 
@@ -268,7 +295,7 @@ def hpat_pandas_series_rolling_corr(self, other=None, pairwise=None):
 
     nan_other = isinstance(other, (Omitted, NoneType)) or other is None
 
-    def hpat_pandas_rolling_series_std_impl(self, other=None, pairwise=None):
+    def hpat_pandas_rolling_series_corr_impl(self, other=None, pairwise=None):
         win = self._window
         minp = self._min_periods
 
@@ -309,7 +336,7 @@ def calc_corr(main, other, minp):
 
         return pandas.Series(output_arr)
 
-    return hpat_pandas_rolling_series_std_impl
+    return hpat_pandas_rolling_series_corr_impl
 
 
 @sdc_overload_method(SeriesRollingType, 'count')
@@ -386,7 +413,7 @@ def hpat_pandas_series_rolling_cov(self, other=None, pairwise=None, ddof=1):
 
     nan_other = isinstance(other, (Omitted, NoneType)) or other is None
 
-    def hpat_pandas_rolling_series_std_impl(self, other=None, pairwise=None, ddof=1):
+    def hpat_pandas_rolling_series_cov_impl(self, other=None, pairwise=None, ddof=1):
         win = self._window
         minp = self._min_periods
 
@@ -427,7 +454,7 @@ def calc_cov(main, other, ddof, minp):
 
         return pandas.Series(output_arr)
 
-    return hpat_pandas_rolling_series_std_impl
+    return hpat_pandas_rolling_series_cov_impl
 
 
 @sdc_overload_method(SeriesRollingType, 'max')
@@ -604,6 +631,15 @@ def calc_quantile(arr, quantile, minp):
     return hpat_pandas_rolling_series_quantile_impl
 
 
+@sdc_overload_method(SeriesRollingType, 'skew')
+def hpat_pandas_series_rolling_skew(self):
+
+    ty_checker = TypeChecker('Method rolling.skew().')
+    ty_checker.check(self, SeriesRollingType)
+
+    return hpat_pandas_rolling_series_skew_impl
+
+
 @sdc_overload_method(SeriesRollingType, 'sum')
 def hpat_pandas_series_rolling_sum(self):
     """
@@ -692,7 +728,7 @@ def culc_std(arr, ddof, minp):
             arr_range = input_arr[:i + 1]
             output_arr[i] = culc_std(arr_range, ddof, minp)
 
-        for i in prange(min(win, length), length):
+        for i in prange(boundary, length):
             arr_range = input_arr[i + 1 - win:i + 1]
             output_arr[i] = culc_std(arr_range, ddof, minp)
 
@@ -818,6 +854,13 @@ def culc_var(arr, ddof, minp):
     """
 })
 
+hpat_pandas_series_rolling_skew.__doc__ = hpat_pandas_series_rolling_docstring_tmpl.format(**{
+    'method_name': 'skew',
+    'example_caption': 'Unbiased rolling skewness.',
+    'limitations_block': '',
+    'extra_params': ''
+})
+
 hpat_pandas_series_rolling_std.__doc__ = hpat_pandas_series_rolling_docstring_tmpl.format(**{
     'method_name': 'std',
     'example_caption': 'Calculate rolling standard deviation.',

sdc/tests/test_rolling.py

@@ -800,6 +800,25 @@ def test_impl(quantile, interpolation):
             hpat_func(0.5, 'lower')
         self.assertIn('interpolation value not "linear"', str(raises.exception))
 
+    @skip_sdc_jit('Series.rolling.skew() unsupported Series index')
+    def test_series_rolling_skew(self):
+        def test_impl(series, window, min_periods):
+            return series.rolling(window, min_periods).skew()
+
+        hpat_func = self.jit(test_impl)
+
+        all_data = test_global_input_data_float64
+        indices = [list(range(len(data)))[::-1] for data in all_data]
+        for data, index in zip(all_data, indices):
+            series = pd.Series(data, index, name='A')
+            for window in range(3, len(series) + 1):
+                for min_periods in range(window + 1):
+                    with self.subTest(series=series, window=window,
+                                      min_periods=min_periods):
+                        ref_result = test_impl(series, window, min_periods)
+                        jit_result = hpat_func(series, window, min_periods)
+                        pd.testing.assert_series_equal(jit_result, ref_result)
+
     @skip_sdc_jit('Series.rolling.std() unsupported Series index')
     def test_series_rolling_std(self):
         test_impl = series_rolling_std_usecase