Implement Series.mean() in new style

hpat/datatypes/hpat_pandas_series_functions.py

@@ -1388,6 +1388,67 @@ def hpat_pandas_series_max_impl(self, axis=None, skipna=True, level=None, numeri
     return hpat_pandas_series_max_impl
 
 
+@overload_method(SeriesType, 'mean')
+def hpat_pandas_series_mean(self, axis=None, skipna=None, level=None, numeric_only=None):
+    """
+    Pandas Series method :meth:`pandas.Series.mean` implementation.
+
+    .. only:: developer
+
+       Test: python -m hpat.runtests hpat.tests.test_series.TestSeries.test_series_mean
+
+    Parameters
+    -----------
+    axis: {index (0)}
+        Axis for the function to be applied on.
+        *unsupported*
+    skipna: :obj:`bool`, default True
+        Exclude NA/null values when computing the result.
+    level: :obj:`int` or level name, default None
+        If the axis is a MultiIndex (hierarchical), count along a particular level, collapsing into a scalar.
+        *unsupported*
+    numeric_only: :obj:`bool`, default None
+        Include only float, int, boolean columns.
+        If None, will attempt to use everything, then use only numeric data. Not implemented for Series.
+        *unsupported*
+
+    Returns
+    -------
+    :obj:
+         Return the mean of the values for the requested axis.
+    """
+
+    _func_name = 'Method mean().'
+
+    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):
+        raise TypingError('{} Currently function supports only numeric values. Given data type: {}'.format(_func_name, self.data.dtype))
+
+    if not isinstance(skipna, (types.Omitted, types.Boolean)) and skipna is not None:
+        raise TypingError(
+            '{} The parameter must be a boolean type. Given type skipna: {}'.format(_func_name, skipna))
+
+    if not (isinstance(axis, types.Omitted) or axis is None) \
+            or not (isinstance(level, types.Omitted) or level is None) \
+            or not (isinstance(numeric_only, types.Omitted) or numeric_only is None):
+        raise TypingError(
+            '{} Unsupported parameters. Given axis: {}, level: {}, numeric_only: {}'.format(_func_name, axis, level,
+                                                                                            numeric_only))
+
+    def hpat_pandas_series_mean_impl(self, axis=None, skipna=None, level=None, numeric_only=None):
+        if skipna is None:
+            skipna = True
+
+        if skipna:
+            return numpy.nanmean(self._data)
+
+        return self._data.mean()
+
+    return hpat_pandas_series_mean_impl
+
+
 @overload_method(SeriesType, 'mod')
 def hpat_pandas_series_mod(self, other, level=None, fill_value=None, axis=0):
     """

hpat/hiframes/pd_series_ext.py

@@ -992,7 +992,7 @@ def generic_expand_cumulative_series(self, args, kws):
 
 # TODO: add itemsize, strides, etc. when removed from Pandas
 _not_series_array_attrs = ['flat', 'ctypes', 'itemset', 'reshape', 'sort', 'flatten',
-                           'resolve_shift', 'resolve_sum', 'resolve_copy',
+                           'resolve_shift', 'resolve_sum', 'resolve_copy', 'resolve_mean',
                            'resolve_take', 'resolve_max', 'resolve_min', 'resolve_nunique']
 
 # use ArrayAttribute for attributes not defined in SeriesAttribute

hpat/tests/test_series.py

@@ -1228,13 +1228,59 @@ def test_impl(S):
         S = pd.Series(['aa', 'bb', np.nan])
         self.assertEqual(hpat_func(S), test_impl(S))
 
-    def test_series_mean1(self):
+    def test_series_mean(self):
         def test_impl(S):
             return S.mean()
         hpat_func = hpat.jit(test_impl)
 
-        S = pd.Series([np.nan, 2., 3.])
-        self.assertEqual(hpat_func(S), test_impl(S))
+        data_samples = [
+            [6, 6, 2, 1, 3, 3, 2, 1, 2],
+            [1.1, 0.3, 2.1, 1, 3, 0.3, 2.1, 1.1, 2.2],
+            [6, 6.1, 2.2, 1, 3, 3, 2.2, 1, 2],
+            [6, 6, np.nan, 2, np.nan, 1, 3, 3, np.inf, 2, 1, 2, np.inf],
+            [1.1, 0.3, np.nan, 1.0, np.inf, 0.3, 2.1, np.nan, 2.2, np.inf],
+            [1.1, 0.3, np.nan, 1, np.inf, 0, 1.1, np.nan, 2.2, np.inf, 2, 2],
+            [np.nan, np.nan, np.nan],
+            [np.nan, np.nan, np.inf],
+        ]
+
+        for data in data_samples:
+            with self.subTest(data=data):
+                S = pd.Series(data)
+                actual = hpat_func(S)
+                expected = test_impl(S)
+                if np.isnan(actual) or np.isnan(expected):
+                    self.assertEqual(np.isnan(actual), np.isnan(expected))
+                else:
+                    self.assertEqual(actual, expected)
+
+    @unittest.skipIf(hpat.config.config_pipeline_hpat_default, "Series.mean() any parameters unsupported")
+    def test_series_mean_skipna(self):
+        def test_impl(S, skipna):
+            return S.mean(skipna=skipna)
+        hpat_func = hpat.jit(test_impl)
+
+        data_samples = [
+            [6, 6, 2, 1, 3, 3, 2, 1, 2],
+            [1.1, 0.3, 2.1, 1, 3, 0.3, 2.1, 1.1, 2.2],
+            [6, 6.1, 2.2, 1, 3, 3, 2.2, 1, 2],
+            [6, 6, np.nan, 2, np.nan, 1, 3, 3, np.inf, 2, 1, 2, np.inf],
+            [1.1, 0.3, np.nan, 1.0, np.inf, 0.3, 2.1, np.nan, 2.2, np.inf],
+            [1.1, 0.3, np.nan, 1, np.inf, 0, 1.1, np.nan, 2.2, np.inf, 2, 2],
+            [np.nan, np.nan, np.nan],
+            [np.nan, np.nan, np.inf],
+        ]
+
+        for skipna in [True, False]:
+            for data in data_samples:
+                S = pd.Series(data)
+                actual = hpat_func(S, skipna)
+                expected = test_impl(S, skipna)
+                if np.isnan(actual) or np.isnan(expected):
+                    self.assertEqual(np.isnan(actual), np.isnan(expected))
+                else:
+                    self.assertEqual(actual, expected)
+
 
     def test_series_var1(self):
         def test_impl(S):