Min max on iterables

numba/targets/builtins.py

@@ -446,22 +446,48 @@ def impl_index_value(context, builder, sig, args):
     index_value.value = value
     return index_value._getvalue()
 
+
 @overload(min)
-def indval_min(indval1, indval2):
+def indval_min(indval1, indval2=None):
+
     if isinstance(indval1, IndexValueType) and \
        isinstance(indval2, IndexValueType):
-        def min_impl(indval1, indval2):
+        def impl(indval1, indval2=None):
             if indval1.value > indval2.value:
                 return indval2
             return indval1
-        return min_impl
+        return impl
+
+    if indval2 is None:
+        if isinstance(indval1, types.IterableType):
+            def impl(indval1, indval2=None):
+                it = iter(indval1)
+                return_val = next(it)
+                for val in it:
+                    if val < return_val:
+                        return_val = val
+                return return_val
+            return impl
+
 
 @overload(max)
-def indval_max(indval1, indval2):
+def indval_max(indval1, indval2=None):
+
     if isinstance(indval1, IndexValueType) and \
        isinstance(indval2, IndexValueType):
-        def max_impl(indval1, indval2):
+        def impl(indval1, indval2=None):
             if indval2.value > indval1.value:
                 return indval2
             return indval1
-        return max_impl
+        return impl
+
+    if indval2 is None:
+        if isinstance(indval1, types.IterableType):
+            def impl(indval1, indval2=None):
+                it = iter(indval1)
+                return_val = next(it)
+                for val in it:
+                    if val > return_val:
+                        return_val = val
+                return return_val
+            return impl

numba/tests/test_builtins.py

@@ -8,7 +8,7 @@
 
 import numba.unittest_support as unittest
 from numba.compiler import compile_isolated, Flags
-from numba import jit, typeof, errors, types, utils, config
+from numba import jit, typeof, errors, types, utils, config, njit
 from .support import TestCase, tag
 
 
@@ -982,6 +982,60 @@ def test_pow_usecase(self):
             r = cres.entry_point(x, y)
             self.assertPreciseEqual(r, pow_usecase(x, y))
 
+    def _check_min_max(self, pyfunc):
+        cfunc = njit()(pyfunc)
+        expected = pyfunc()
+        got = cfunc()
+        self.assertPreciseEqual(expected, got)
+
+    def test_min_max_iterable_input(self):
+
+        @njit
+        def frange(start, stop, step):
+            i = start
+            while i < stop:
+                yield i
+                i += step
+
+        def sample_functions(op):
+            yield lambda: op(range(10))
+            yield lambda: op(range(4, 12))
+            yield lambda: op(range(-4, -15, -1))
+            yield lambda: op([6.6, 5.5, 7.7])
+            yield lambda: op([(3, 4), (1, 2)])
+            yield lambda: op(frange(1.1, 3.3, 0.1))
+            yield lambda: op([np.nan, -np.inf, np.inf, np.nan])
+            yield lambda: op([(1,), (1,), (1,)])
+
+        for fn in sample_functions(op=min):
+            self._check_min_max(fn)
+
+        for fn in sample_functions(op=max):
+            self._check_min_max(fn)
+
+    def test_min_max_supplemental(self):
+        # check the parallel implementations of
+        # argmin and argmax, which depend on
+        # min and max builtins, respectively
+
+        def argmin(arr):
+            return np.argmin(arr)
+
+        def argmax(arr):
+            return np.argmax(arr)
+
+        def arrays():
+            yield np.arange(10, 2, -1)
+            yield np.ones(365)
+            yield self.random.randn(10)
+
+        for pyfunc in argmin, argmax:
+            cfunc = njit(parallel=True)(pyfunc)
+            for arr in arrays():
+                expected = pyfunc(arr)
+                got = cfunc(arr)
+                self.assertPreciseEqual(expected, got)
+
 
 if __name__ == '__main__':
     unittest.main()