Implement idxmin

hpat/datatypes/hpat_pandas_series_functions.py

@@ -1096,6 +1096,66 @@ def hpat_pandas_series_ge_impl(self, other):
     raise TypingError('{} The object must be a pandas.series and argument must be a number. Given: {} and other: {}'.format(_func_name, self, other))
 
 
+@overload_method(SeriesType, 'idxmin')
+def hpat_pandas_series_idxmin(self, axis=None, skipna=True, *args):
+    """
+    Pandas Series method :meth:`pandas.Series.idxmin` implementation.
+
+    .. only:: developer
+
+        Test: python -m hpat.runtests hpat.tests.test_series.TestSeries.test_series_idxmin1
+        Test: python -m hpat.runtests hpat.tests.test_series.TestSeries.test_series_idxmin_str
+        Test: python -m hpat.runtests hpat.tests.test_series.TestSeries.test_series_idxmin_int
+        Test: python -m hpat.runtests hpat.tests.test_series.TestSeries.test_series_idxmin_no
+
+    Parameters
+    -----------
+    axis :  :obj:`int`, :obj:`str`, default: None
+            Axis along which the operation acts
+            0/None - row-wise operation
+            1      - column-wise operation
+            *unsupported*
+    skipna:  :obj:`bool`, default: True
+            exclude NA/null values
+            *unsupported*
+
+    Returns
+    -------
+    :obj:`pandas.Series.index` or nan
+            returns: Label of the minimum value.
+    """
+
+    _func_name = 'Method idxmin().'
+
+    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.dtype))
+
+    if not isinstance(skipna, (types.Omitted, types.Boolean, bool)):
+        raise TypingError(
+            '{} The parameter must be a boolean type. Given type skipna: {}'.format(_func_name, type(skipna)))
+
+    if not (isinstance(axis, types.Omitted) or axis is None):
+        raise TypingError('{} Unsupported parameters. Given axis: {}'.format(_func_name, axis))
+
+    if not isinstance(self.index, types.NoneType):
+        def hpat_pandas_series_idxmin_impl(self, axis=None, skipna=True):
+
+            result = numpy.argmin(self._data)
+            return self._index[int(result)]
+
+        return hpat_pandas_series_idxmin_impl
+    else:
+        def hpat_pandas_series_idxmin_impl(self, axis=None, skipna=True):
+
+            return numpy.argmin(self._data)
+
+        return hpat_pandas_series_idxmin_impl
+
+
 @overload_method(SeriesType, 'lt')
 def hpat_pandas_series_lt(self, other, level=None, fill_value=None, axis=0):
     """

hpat/hiframes/hiframes_typed.py

@@ -866,7 +866,7 @@ def _run_call_series(self, assign, lhs, rhs, series_var, func_name):
             return self._replace_func(func, [data], pre_nodes=nodes)
 
         if func_name in ('std', 'nunique', 'describe', 'isna',
-                         'isnull', 'median', 'idxmin', 'idxmax', 'unique'):
+                         'isnull', 'median', 'idxmax', 'unique'):
             if rhs.args or rhs.kws:
                 raise ValueError("unsupported Series.{}() arguments".format(
                     func_name))

hpat/hiframes/pd_series_ext.py

@@ -690,10 +690,10 @@ def resolve_median(self, ary, args, kws):
         dtype = types.float64 if isinstance(dtype, types.Integer) else dtype
         return signature(dtype, *args)
 
-    @bound_function("series.idxmin")
-    def resolve_idxmin(self, ary, args, kws):
-        assert not kws
-        return signature(types.intp, *args)
+    # @bound_function("series.idxmin")
+    # def resolve_idxmin(self, ary, args, kws):
+    #     assert not kws
+    #     return signature(types.intp, *args)
 
     @bound_function("series.idxmax")
     def resolve_idxmax(self, ary, args, kws):
@@ -1280,3 +1280,4 @@ def hpat_pandas_series_ctor_impl(data=None, index=None, dtype=None, name=None, c
     return hpat_pandas_series_ctor_impl
 
 from hpat.datatypes.hpat_pandas_series_functions import *
+

hpat/tests/test_series.py

@@ -1556,6 +1556,96 @@ def test_impl(A):
         S = pd.Series(np.random.ranf(n))
         np.testing.assert_array_equal(hpat_func(S), test_impl(S))
 
+    def test_series_idxmin_str(self):
+        def test_impl(S):
+            return S.idxmin()
+        hpat_func = hpat.jit(test_impl)
+
+        S = pd.Series([8, 6, 34, np.nan], ['a', 'ab', 'abc', 'c'])
+        print(hpat_func(S))
+        print(test_impl(S))
+        self.assertEqual(hpat_func(S), test_impl(S))
+
+    @unittest.skip("Cant return 2 types: string or nan in one case")
+    def test_series_idxmin_str_idx(self):
+        def test_impl(S):
+            return S.idxmin(skipna=False)
+
+        hpat_func = hpat.jit(test_impl)
+
+        S = pd.Series([8, 6, 34, np.nan], ['a', 'ab', 'abc', 'c'])
+        print(hpat_func(S))
+        print(test_impl(S))
+        self.assertEqual(hpat_func(S), test_impl(S))
+
+    def test_series_idxmin_no(self):
+        def test_impl(S):
+            return S.idxmin()
+        hpat_func = hpat.jit(test_impl)
+
+        S = pd.Series([8, 6, 34, np.nan])
+        self.assertEqual(hpat_func(S), test_impl(S))
+
+    @unittest.skip("Enable after fixing index")
+    def test_series_idxmin_int(self):
+        def test_impl(S):
+            return S.idxmin()
+        hpat_func = hpat.jit(test_impl)
+
+        S = pd.Series([1, 2, 3], [4, 45, 14])
+        print(hpat_func(S))
+        print(test_impl(S))
+        self.assertEqual(hpat_func(S), test_impl(S))
+
+    @unittest.skip("Need index fix")
+    def test_series_idxmin(self):
+        def test_series_idxmin_impl(S):
+            return S.idxmin()
+
+        hpat_func = hpat.jit(test_series_idxmin_impl)
+
+        test_input_data = []
+        data_simple = [[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],
+                       ]
+
+        data_extra = [[np.nan, np.nan, np.nan, np.nan],
+                      [np.nan, np.nan, np.inf, np.inf],
+                      ]
+
+        test_input_data = data_simple + data_extra
+
+        for input_data in data_simple:
+            S = pd.Series(input_data)
+
+            result_ref = test_series_idxmin_impl(S)
+            result = hpat_func(S)
+            self.assertEqual(result, result_ref)
+
+        for input_data in test_input_data:
+            S = pd.Series(input_data)
+
+            result_ref = test_series_idxmin_impl(S)
+            result = hpat_func(S)
+            self.assertEqual(result, result_ref)
+
+        for input_data in data_simple:
+            for index_data in data_simple:
+                S = pd.Series(input_data, index_data)
+
+                result_ref = test_series_idxmin_impl(S)
+                result = hpat_func(S)
+                self.assertEqual(result, result_ref)
+
+        for input_data in test_input_data:
+            for index_data in test_input_data:
+                S = pd.Series(input_data, index_data)
+
+                result_ref = test_series_idxmin_impl(S)
+                result = hpat_func(S)
+                self.assertEqual(result, result_ref)
+
     def test_series_idxmax1(self):
         def test_impl(A):
             return A.idxmax()