Merge b50b29d into 8e3a220

hpat/datatypes/hpat_pandas_series_functions.py

@@ -2051,6 +2051,62 @@ def hpat_pandas_series_unique_impl(self):
     return hpat_pandas_series_unique_impl
 
 
+@overload_method(SeriesType, 'cumsum')
+def hpat_pandas_series_cumsum(self, axis=None, skipna=True, *args):
+    """
+    Pandas Series method :meth:`pandas.Series.cumsum` implementation.
+
+    .. only:: developer
+       Test: python -m hpat.runtests hpat.tests.test_series.TestSeries.test_series_cumsum
+       Test: python -m hpat.runtests hpat.tests.test_series.TestSeries.test_series_cumsum_unboxing
+       Test: python -m hpat.runtests hpat.tests.test_series.TestSeries.test_series_cumsum_full
+       Test: python -m hpat.runtests hpat.tests.test_series.TestSeries.test_series_cumsum_str
+       Test: python -m hpat.runtests hpat.tests.test_series.TestSeries.test_series_cumsum_unsupported_axis
+
+    Parameters
+    ----------
+    self: :obj:`pandas.Series`
+        input series
+    axis: :obj:`int`, :obj:`str`
+        Axis along which the operation acts
+        0/None/'index' - row-wise operation
+        1/'columns'    - column-wise operation
+        *unsupported*
+    skipna: :obj:`bool`
+        exclude NA/null values
+    *args:
+        *unsupported*
+
+    Returns
+    -------
+    :obj:`scalar`, :obj:`pandas.Series`
+         returns :obj:`scalar` or :obj:`pandas.Series` object
+    """
+
+    _func_name = 'Method cumsum().'
+
+    if not isinstance(self, SeriesType):
+        raise TypingError('{} The object must be a pandas.series. Given: {}'.format(_func_name, self))
+
+    if not isinstance(self.data.dtype, types.Number):
+        msg = '{} The object must be a number. Given self.data.dtype: {}'
+        raise TypingError(msg.format(_func_name, self.data.dtype))
+
+    if not isinstance(axis, (types.Omitted, types.NoneType)) and axis is not None:
+        raise TypingError('{} Unsupported parameters. Given axis: {}'.format(_func_name, axis))
+
+    def hpat_pandas_series_cumsum_impl(self, axis=None, skipna=True):
+        if skipna:
+            # nampy.nancumsum replaces NANs with 0, series.cumsum does not, so replace back 0 with NANs
+            local_data = numpy.nancumsum(self._data)
+            local_data[numpy.isnan(self._data)] = numpy.nan
+            return pandas.Series(local_data)
+
+        return pandas.Series(self._data.cumsum())
+
+    return hpat_pandas_series_cumsum_impl
+
+
 @overload_method(SeriesType, 'nunique')
 def hpat_pandas_series_nunique(self, dropna=True):
     """

hpat/hiframes/pd_series_ext.py

@@ -986,12 +986,12 @@ def generic_expand_cumulative_series(self, args, kws):
     return signature(return_type, recvr=self.this)
 
 
-# replacing cumsum/cumprod since arraydecl.py definition uses types.Array
-for fname in ["cumsum", "cumprod"]:
-    install_array_method(fname, generic_expand_cumulative_series)
+# replacing cumprod since arraydecl.py definition uses types.Array
+install_array_method('cumprod', generic_expand_cumulative_series)
 
 # TODO: add itemsize, strides, etc. when removed from Pandas
 _not_series_array_attrs = ['flat', 'ctypes', 'itemset', 'reshape', 'sort', 'flatten',
+                           'resolve_cumsum',
                            'resolve_shift', 'resolve_sum', 'resolve_copy', 'resolve_mean',
                            'resolve_take', 'resolve_max', 'resolve_min', 'resolve_nunique',
                            'resolve_prod', 'resolve_count']

hpat/tests/test_series.py

@@ -35,18 +35,22 @@
     ),
 ]]
 
+min_float64 = np.finfo('float64').min
+max_float64 = np.finfo('float64').max
+
 test_global_input_data_float64 = [
-    [1.0, np.nan, -1.0, 0.0, 5e-324],
+    [1., np.nan, -1., 0., min_float64, max_float64],
     [np.nan, np.inf, np.NINF, np.NZERO]
 ]
 
-min_int64 = -9223372036854775808
-max_int64 = 9223372036854775807
-max_uint64 = 18446744073709551615
+min_int64 = np.iinfo('int64').min
+max_int64 = np.iinfo('int64').max
+max_uint64 = np.iinfo('uint64').max
 
 test_global_input_data_integer64 = [
-    [1, -1, 0, max_uint64],
-    [-0, min_int64, max_int64]
+    [1, -1, 0],
+    [min_int64, max_int64],
+    [max_uint64]
 ]
 
 test_global_input_data_numeric = test_global_input_data_integer64 + test_global_input_data_float64
@@ -2664,5 +2668,74 @@ def test_series_count_impl(S):
             result = hpat_func(S)
             self.assertEqual(result, result_ref)
 
+    @unittest.skipIf(hpat.config.config_pipeline_hpat_default,
+                     'Series.cumsum() np.nan as input data unsupported')
+    def test_series_cumsum(self):
+        def test_impl():
+            series = pd.Series([1.0, np.nan, -1.0, 0.0, 5e-324])
+            return series.cumsum()
+
+        pyfunc = test_impl
+        cfunc = hpat.jit(pyfunc)
+        pd.testing.assert_series_equal(pyfunc(), cfunc())
+
+    @unittest.skipIf(hpat.config.config_pipeline_hpat_default,
+                     'Series.cumsum() np.nan as input data unsupported')
+    def test_series_cumsum_unboxing(self):
+        def test_impl(s):
+            return s.cumsum()
+
+        pyfunc = test_impl
+        cfunc = hpat.jit(pyfunc)
+
+        for data in test_global_input_data_numeric + [[]]:
+            series = pd.Series(data)
+            pd.testing.assert_series_equal(pyfunc(series), cfunc(series))
+
+    @unittest.skipIf(hpat.config.config_pipeline_hpat_default,
+                     'Series.cumsum() parameters "axis", "skipna" unsupported')
+    def test_series_cumsum_full(self):
+        def test_impl(s, axis, skipna):
+            return s.cumsum(axis=axis, skipna=skipna)
+
+        pyfunc = test_impl
+        cfunc = hpat.jit(pyfunc)
+
+        axis = None
+        for data in test_global_input_data_numeric + [[]]:
+            series = pd.Series(data)
+            for skipna in [True, False]:
+                ref_result = pyfunc(series, axis=axis, skipna=skipna)
+                jit_result = cfunc(series, axis=axis, skipna=skipna)
+                pd.testing.assert_series_equal(ref_result, jit_result)
+
+    @unittest.skipIf(hpat.config.config_pipeline_hpat_default,
+                     'Series.cumsum() strings as input data unsupported')
+    def test_series_cumsum_str(self):
+        def test_impl(s):
+            return s.cumsum()
+
+        cfunc = hpat.jit(test_impl)
+        series = pd.Series(test_global_input_data_unicode_kind4)
+        with self.assertRaises(TypingError) as raises:
+            cfunc(series)
+        msg = 'Method cumsum(). The object must be a number. Given self.data.dtype: {}'
+        self.assertIn(msg.format(types.unicode_type), str(raises.exception))
+
+    @unittest.skipIf(hpat.config.config_pipeline_hpat_default,
+                     'Series.cumsum() parameter "axis" unsupported')
+    def test_series_cumsum_unsupported_axis(self):
+        def test_impl(s, axis):
+            return s.cumsum(axis=axis)
+
+        cfunc = hpat.jit(test_impl)
+        series = pd.Series(test_global_input_data_float64[0])
+        for axis in [0, 1]:
+            with self.assertRaises(TypingError) as raises:
+                cfunc(series, axis=axis)
+            msg = 'Method cumsum(). Unsupported parameters. Given axis: int'
+            self.assertIn(msg, str(raises.exception))
+
+
 if __name__ == "__main__":
     unittest.main()