From 6ddbf0a03467defff740b89bf8a2f945e7484d8c Mon Sep 17 00:00:00 2001 From: Denis Date: Tue, 15 Oct 2019 09:04:02 +0300 Subject: [PATCH] Combine 3 tests to check unsupported params --- .../datatypes/hpat_pandas_series_functions.py | 24 +++--- hpat/tests/test_series.py | 80 +++++++++++-------- 2 files changed, 60 insertions(+), 44 deletions(-) diff --git a/hpat/datatypes/hpat_pandas_series_functions.py b/hpat/datatypes/hpat_pandas_series_functions.py index 594410a30..4e605233a 100644 --- a/hpat/datatypes/hpat_pandas_series_functions.py +++ b/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 diff --git a/hpat/tests/test_series.py b/hpat/tests/test_series.py index bad283708..4d7abe3dc 100644 --- a/hpat/tests/test_series.py +++ b/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):