Combine 3 tests to check unsupported params

hpat/datatypes/hpat_pandas_series_functions.py

@@ -30,7 +30,7 @@
 | Also, it contains Numba internal operators which are required for Series type handling
 
 """
-import math
+
 import numpy
 import operator
 import pandas
@@ -174,24 +174,24 @@ def hpat_pandas_series_shape_impl(self):
 
 
 @overload_method(SeriesType, 'std')
-def hapt_pandas_series_std(self, axis=None, skipna=None, level=None, ddof=1, numeric_only=None):
+def hpat_pandas_series_std(self, axis=None, skipna=None, level=None, ddof=1, numeric_only=None):
     """
     Pandas Series method :meth:`pandas.Series.std` implementation.
+
     .. only:: developer
        Test: python -m hpat.runtests hpat.tests.test_series.TestSeries.test_series_std
        Test: python -m hpat.runtests hpat.tests.test_series.TestSeries.test_series_std_unboxing
        Test: python -m hpat.runtests hpat.tests.test_series.TestSeries.test_series_std_str
-       Test: python -m hpat.runtests hpat.tests.test_series.TestSeries.test_series_std_unsupported_axis
-       Test: python -m hpat.runtests hpat.tests.test_series.TestSeries.test_series_std_unsupported_level
-       Test: python -m hpat.runtests hpat.tests.test_series.TestSeries.test_series_std_unsupported_numeric_only
+       Test: python -m hpat.runtests hpat.tests.test_series.TestSeries.test_series_std_unsupported_params
+
     Parameters
     ----------
     self: :obj:`pandas.Series`
         input series
     axis: :obj:`int`, :obj:`str`
         Axis along which the operation acts
-        0/None - row-wise operation
-        1      - column-wise operation
+        0/None/'index' - row-wise operation
+        1/'columns'    - column-wise operation
         *unsupported*
     skipna: :obj:`bool`
         exclude NA/null values
@@ -208,18 +208,21 @@ def hapt_pandas_series_std(self, axis=None, skipna=None, level=None, ddof=1, num
         If None, will attempt to use everything, then use only numeric data.
         Not implemented for Series.
         *unsupported*
+
     Returns
     -------
     :obj:`scalar`
          returns :obj:`scalar`
     """
+
     _func_name = 'Method std().'
 
     if not isinstance(self, SeriesType):
         raise TypingError('{} The object must be a pandas.series. Given: {}'.format(_func_name, self))
 
-    if not isinstance(self.dtype, types.Number):
-        raise TypingError('{} The object must be a number. Given self.dtype: {}'.format(_func_name, self.dtype))
+    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(skipna, (types.Omitted, types.Boolean, types.NoneType)) and skipna is not None:
         raise TypingError('{} The object must be a boolean. Given skipna: {}'.format(_func_name, skipna))
@@ -232,7 +235,8 @@ def hapt_pandas_series_std(self, axis=None, skipna=None, level=None, ddof=1, num
             raise TypingError('{} Unsupported parameters. Given {}: {}'.format(_func_name, name, arg))
 
     def hpat_pandas_series_std_impl(self, axis=None, skipna=None, level=None, ddof=1, numeric_only=None):
-        return math.sqrt(self.var(axis=axis, skipna=skipna, level=level, ddof=ddof, numeric_only=numeric_only))
+        var = self.var(axis=axis, skipna=skipna, level=level, ddof=ddof, numeric_only=numeric_only)
+        return var ** 0.5
 
     return hpat_pandas_series_std_impl
 

hpat/tests/test_series.py

@@ -36,6 +36,31 @@
     ),
 ]]
 
+test_global_input_data_float64 = [
+    [1.0, np.nan, -1.0, 0.0, 5e-324],
+    [np.nan, np.inf, np.NINF, np.NZERO]
+]
+
+min_int64 = -9223372036854775808
+max_int64 = 9223372036854775807
+max_uint64 = 18446744073709551615
+
+test_global_input_data_integer64 = [
+    [1, -1, 0, max_uint64],
+    [-0, min_int64, max_int64]
+]
+
+test_global_input_data_numeric = test_global_input_data_integer64 + test_global_input_data_float64
+
+test_global_input_data_unicode_kind4 = [
+    'ascii',
+    '12345',
+    '1234567890',
+    '¡Y tú quién te crees?',
+    '🐍⚡',
+    '大处着眼，小处着手。',
+]
+
 
 def _make_func_from_text(func_text, func_name='test_impl'):
     loc_vars = {}
@@ -2047,7 +2072,7 @@ def test_impl():
 
     def test_series_std(self):
         def pyfunc():
-            series = pd.Series([1.3, -2.7, np.nan, 0.1, 10.9])
+            series = pd.Series([1.0, np.nan, -1.0, 0.0, 5e-324])
             return series.std()
 
         cfunc = hpat.jit(pyfunc)
@@ -2060,56 +2085,43 @@ def pyfunc(series, skipna, ddof):
             return series.std(skipna=skipna, ddof=ddof)
 
         cfunc = hpat.jit(pyfunc)
-        series = pd.Series([1.3, -2.7, np.nan, 0.1, 10.9])
-        for ddof in [0, 1]:
-            for skipna in [True, False]:
-                ref_result = pyfunc(series, skipna=skipna, ddof=ddof)
-                result = cfunc(series, skipna=skipna, ddof=ddof)
-                np.testing.assert_equal(ref_result, result)
+        for data in test_global_input_data_float64:
+            series = pd.Series(data)
+            for ddof in [0, 1]:
+                for skipna in [True, False]:
+                    ref_result = pyfunc(series, skipna=skipna, ddof=ddof)
+                    result = cfunc(series, skipna=skipna, ddof=ddof)
+                    np.testing.assert_equal(ref_result, result)
 
     def test_series_std_str(self):
         def pyfunc(series):
             return series.std()
 
         cfunc = hpat.jit(pyfunc)
-        series = pd.Series(['test', 'series', 'std', 'str'])
+        series = pd.Series(test_global_input_data_unicode_kind4)
         with self.assertRaises(TypingError) as raises:
             cfunc(series)
-        msg = 'Method std(). The object must be a number. Given self.dtype: {}'
+        msg = 'Method std(). The object must be a number. Given self.data.dtype: {}'
         self.assertIn(msg.format(types.unicode_type), str(raises.exception))
 
-    def test_series_std_unsupported_axis(self):
-        def pyfunc(series, axis):
-            return series.std(axis=axis)
+    def test_series_std_unsupported_params(self):
+        def pyfunc(series, axis, level, numeric_only):
+            return series.std(axis=axis, level=level, numeric_only=numeric_only)
 
         cfunc = hpat.jit(pyfunc)
-        series = pd.Series([1.3, -2.7, np.nan, 0.1, 10.9])
+        series = pd.Series(test_global_input_data_float64[0])
+        msg = 'Method std(). Unsupported parameters. Given {}: {}'
         with self.assertRaises(TypingError) as raises:
-            cfunc(series, axis=1)
-        msg = 'Method std(). Unsupported parameters. Given axis: int'
-        self.assertIn(msg, str(raises.exception))
+            cfunc(series, axis=1, level=None, numeric_only=None)
+        self.assertIn(msg.format('axis', 'int'), str(raises.exception))
 
-    def test_series_std_unsupported_level(self):
-        def pyfunc(series, level):
-            return series.std(level=level)
-
-        cfunc = hpat.jit(pyfunc)
-        series = pd.Series([1.3, -2.7, np.nan, 0.1, 10.9])
         with self.assertRaises(TypingError) as raises:
-            cfunc(series, level=1)
-        msg = 'Method std(). Unsupported parameters. Given level: int'
-        self.assertIn(msg, str(raises.exception))
+            cfunc(series, axis=None, level=1, numeric_only=None)
+        self.assertIn(msg.format('level', 'int'), str(raises.exception))
 
-    def test_series_std_unsupported_numeric_only(self):
-        def pyfunc(series, numeric_only):
-            return series.std(numeric_only=numeric_only)
-
-        cfunc = hpat.jit(pyfunc)
-        series = pd.Series([1.3, -2.7, np.nan, 0.1, 10.9])
         with self.assertRaises(TypingError) as raises:
-            cfunc(series, numeric_only=True)
-        msg = 'Method std(). Unsupported parameters. Given numeric_only: bool'
-        self.assertIn(msg, str(raises.exception))
+            cfunc(series, axis=None, level=None, numeric_only=True)
+        self.assertIn(msg.format('numeric_only', 'bool'), str(raises.exception))
 
     def test_series_nunique(self):
         def test_series_nunique_impl(S):