address comments

Author: vtavana

dpnp/dpnp_array.py

@@ -942,7 +942,11 @@ def max(
         initial=None,
         where=True,
     ):
-        """Return the maximum along an axis."""
+        """
+        Return the maximum along an axis.
+
+        Refer to :obj:`dpnp.max` for full documentation.
+        """
 
         return dpnp.max(self, axis, out, keepdims, initial, where)
 
@@ -959,7 +963,11 @@ def min(
         initial=None,
         where=True,
     ):
-        """Return the minimum along a given axis."""
+        """
+        Return the minimum along a given axis.
+
+        Refer to :obj:`dpnp.min` for full documentation.
+        """
 
         return dpnp.min(self, axis, out, keepdims, initial, where)
 

dpnp/dpnp_iface_statistics.py

@@ -354,6 +354,8 @@ def max(a, axis=None, out=None, keepdims=False, initial=None, where=True):
     """
     Return the maximum of an array or maximum along an axis.
 
+    For full documentation refer to :obj:`numpy.max`.
+
     Returns
     -------
     out : dpnp.ndarray
@@ -396,19 +398,56 @@ def max(a, axis=None, out=None, keepdims=False, initial=None, where=True):
 
     """
 
-    if out is not None:
-        pass
-    elif initial is not None:
-        pass
+    if initial is not None:
+        raise NotImplementedError(
+            "initial keyword arguemnts is only supported by its default value."
+        )
     elif where is not True:
-        pass
+        raise NotImplementedError(
+            "where keyword arguemnts is only supported by its default values."
+        )
     else:
         dpt_array = dpnp.get_usm_ndarray(a)
-        return dpnp_array._create_from_usm_ndarray(
-            dpt.max(dpt_array, axis=axis, keepdims=keepdims)
-        )
-
-    return call_origin(numpy.max, a, axis, out, keepdims, initial, where)
+        if dpt_array.size == 0:
+            # TODO: get rid of this if condition when dpctl supports it
+            for i in range(a.ndim):
+                if a.shape[i] == 0:
+                    if i not in axis:
+                        indices = [i for i in range(a.ndim) if i not in axis]
+                        res_shape = tuple([a.shape[i] for i in indices])
+                        result = dpnp.empty(res_shape, dtype=a.dtype)
+                    else:
+                        raise ValueError(
+                            "reduction does not support zero-size arrays"
+                        )
+        else:
+            result = dpnp_array._create_from_usm_ndarray(
+                dpt.max(dpt_array, axis=axis, keepdims=keepdims)
+            )
+        if out is None:
+            return result
+        else:
+            if out.shape != result.shape:
+                raise ValueError(
+                    f"Output array of shape {result.shape} is needed, got {out.shape}."
+                )
+            elif out.dtype != result.dtype:
+                raise ValueError(
+                    f"Output array of type {result.dtype} is needed, got {out.dtype}."
+                )
+            elif not isinstance(out, dpnp_array):
+                if isinstance(out, dpt.usm_ndarray):
+                    out = dpnp.array(out)
+                else:
+                    raise ValueError(
+                        "An array must be any of supported type, but got {}".format(
+                            type(out)
+                        )
+                    )
+
+            dpnp.copyto(out, result)
+
+            return out
 
 
 def mean(x, /, *, axis=None, dtype=None, keepdims=False, out=None, where=True):
@@ -606,19 +645,56 @@ def min(a, axis=None, out=None, keepdims=False, initial=None, where=True):
 
     """
 
-    if out is not None:
-        pass
-    elif initial is not None:
-        pass
+    if initial is not None:
+        raise NotImplementedError(
+            "initial keyword arguemnts is only supported by its default value."
+        )
     elif where is not True:
-        pass
+        raise NotImplementedError(
+            "where keyword arguemnts is only supported by its default values."
+        )
     else:
         dpt_array = dpnp.get_usm_ndarray(a)
-        return dpnp_array._create_from_usm_ndarray(
-            dpt.min(dpt_array, axis=axis, keepdims=keepdims)
-        )
-
-    return call_origin(numpy.min, a, axis, out, keepdims, initial, where)
+        if dpt_array.size == 0:
+            # TODO: get rid of this if condition when dpctl supports it
+            for i in range(a.ndim):
+                if a.shape[i] == 0:
+                    if i not in axis:
+                        indices = [i for i in range(a.ndim) if i not in axis]
+                        res_shape = tuple([a.shape[i] for i in indices])
+                        result = dpnp.empty(res_shape, dtype=a.dtype)
+                    else:
+                        raise ValueError(
+                            "reduction does not support zero-size arrays"
+                        )
+        else:
+            result = dpnp_array._create_from_usm_ndarray(
+                dpt.min(dpt_array, axis=axis, keepdims=keepdims)
+            )
+        if out is None:
+            return result
+        else:
+            if out.shape != result.shape:
+                raise ValueError(
+                    f"Output array of shape {result.shape} is needed, got {out.shape}."
+                )
+            elif out.dtype != result.dtype:
+                raise ValueError(
+                    f"Output array of type {result.dtype} is needed, got {out.dtype}."
+                )
+            elif not isinstance(out, dpnp_array):
+                if isinstance(out, dpt.usm_ndarray):
+                    out = dpnp.array(out)
+                else:
+                    raise ValueError(
+                        "An array must be any of supported type, but got {}".format(
+                            type(out)
+                        )
+                    )
+
+            dpnp.copyto(out, result)
+
+            return out
 
 
 def nanvar(x1, axis=None, dtype=None, out=None, ddof=0, keepdims=False):

tests/test_amin_amax.py

@@ -7,7 +7,7 @@
 from .helper import get_all_dtypes
 
 
-@pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True, no_complex=True))
+@pytest.mark.parametrize("dtype", get_all_dtypes())
 def test_amax(dtype):
     a = numpy.array(
         [
@@ -25,7 +25,7 @@ def test_amax(dtype):
         assert_allclose(expected, result)
 
 
-@pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True, no_complex=True))
+@pytest.mark.parametrize("dtype", get_all_dtypes())
 def test_amin(dtype):
     a = numpy.array(
         [
@@ -55,8 +55,7 @@ def _get_min_max_input(type, shape):
     return a.reshape(shape)
 
 
-@pytest.mark.usefixtures("allow_fall_back_on_numpy")
-@pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True, no_complex=True))
+@pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True))
 @pytest.mark.parametrize(
     "shape", [(4,), (2, 3), (4, 5, 6)], ids=["(4,)", "(2,3)", "(4,5,6)"]
 )
@@ -74,8 +73,7 @@ def test_amax_diff_shape(dtype, shape):
     numpy.testing.assert_array_equal(dpnp_res, np_res)
 
 
-@pytest.mark.usefixtures("allow_fall_back_on_numpy")
-@pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True, no_complex=True))
+@pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True))
 @pytest.mark.parametrize(
     "shape", [(4,), (2, 3), (4, 5, 6)], ids=["(4,)", "(2,3)", "(4,5,6)"]
 )

tests/test_statistics.py

@@ -23,7 +23,7 @@ def test_median(dtype, size):
 
 @pytest.mark.parametrize("axis", [None, 0, 1, -1, 2, -2, (1, 2), (0, -2)])
 @pytest.mark.parametrize("keepdims", [False, True])
-@pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True, no_bool=True))
+@pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True))
 def test_max_min(axis, keepdims, dtype):
     a = numpy.arange(768, dtype=dtype).reshape((4, 4, 6, 8))
     ia = dpnp.array(a)
@@ -41,6 +41,62 @@ def test_max_min(axis, keepdims, dtype):
     assert_allclose(dpnp_res, np_res)
 
 
+@pytest.mark.parametrize("axis", [None, 0, 1, -1])
+@pytest.mark.parametrize("keepdims", [False, True])
+def test_max_min_bool(axis, keepdims):
+    a = numpy.arange(2, dtype=dpnp.bool)
+    a = numpy.tile(a, (2, 2))
+    ia = dpnp.array(a)
+
+    np_res = numpy.max(a, axis=axis, keepdims=keepdims)
+    dpnp_res = dpnp.max(ia, axis=axis, keepdims=keepdims)
+
+    assert dpnp_res.shape == np_res.shape
+    assert_allclose(dpnp_res, np_res)
+
+    np_res = numpy.min(a, axis=axis, keepdims=keepdims)
+    dpnp_res = dpnp.min(ia, axis=axis, keepdims=keepdims)
+
+    assert dpnp_res.shape == np_res.shape
+    assert_allclose(dpnp_res, np_res)
+
+
+@pytest.mark.parametrize("axis", [None, 0, 1, -1, 2, -2, (1, 2), (0, -2)])
+@pytest.mark.parametrize("keepdims", [False, True])
+@pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True))
+def test_max_min_out(axis, keepdims, dtype):
+    a = numpy.arange(768, dtype=dtype).reshape((4, 4, 6, 8))
+    ia = dpnp.array(a)
+
+    np_res = numpy.max(a, axis=axis, keepdims=keepdims)
+    dpnp_res = dpnp.array(numpy.empty_like(np_res))
+    dpnp.max(ia, axis=axis, keepdims=keepdims, out=dpnp_res)
+
+    assert dpnp_res.shape == np_res.shape
+    assert_allclose(dpnp_res, np_res)
+
+    np_res = numpy.min(a, axis=axis, keepdims=keepdims)
+    dpnp_res = dpnp.array(numpy.empty_like(np_res))
+    dpnp.min(ia, axis=axis, keepdims=keepdims, out=dpnp_res)
+
+    assert dpnp_res.shape == np_res.shape
+    assert_allclose(dpnp_res, np_res)
+
+
+def test_max_min_NotImplemented():
+    ia = dpnp.arange(5)
+
+    with pytest.raises(NotImplementedError):
+        dpnp.max(ia, where=False)
+    with pytest.raises(NotImplementedError):
+        dpnp.max(ia, initial=6)
+
+    with pytest.raises(NotImplementedError):
+        dpnp.min(ia, where=False)
+    with pytest.raises(NotImplementedError):
+        dpnp.max(ia, initial=6)
+
+
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 @pytest.mark.parametrize(
     "array",

tests/third_party/cupy/core_tests/test_ndarray_reduction.py

@@ -215,6 +215,65 @@ def test_ptp_nan_imag(self, xp, dtype):
         return a.ptp()
 
 
+@testing.parameterize(
+    *testing.product(
+        {
+            # TODO(leofang): make a @testing.for_all_axes decorator
+            "shape_and_axis": [
+                ((), None),
+                ((0,), (0,)),
+                ((0, 2), (0,)),
+                ((0, 2), (1,)),
+                ((0, 2), (0, 1)),
+                ((2, 0), (0,)),
+                ((2, 0), (1,)),
+                ((2, 0), (0, 1)),
+                ((0, 2, 3), (0,)),
+                ((0, 2, 3), (1,)),
+                ((0, 2, 3), (2,)),
+                ((0, 2, 3), (0, 1)),
+                ((0, 2, 3), (1, 2)),
+                ((0, 2, 3), (0, 2)),
+                ((0, 2, 3), (0, 1, 2)),
+                ((2, 0, 3), (0,)),
+                ((2, 0, 3), (1,)),
+                ((2, 0, 3), (2,)),
+                ((2, 0, 3), (0, 1)),
+                ((2, 0, 3), (1, 2)),
+                ((2, 0, 3), (0, 2)),
+                ((2, 0, 3), (0, 1, 2)),
+                ((2, 3, 0), (0,)),
+                ((2, 3, 0), (1,)),
+                ((2, 3, 0), (2,)),
+                ((2, 3, 0), (0, 1)),
+                ((2, 3, 0), (1, 2)),
+                ((2, 3, 0), (0, 2)),
+                ((2, 3, 0), (0, 1, 2)),
+            ],
+            "order": ("C", "F"),
+            "func": ("min", "max"),
+        }
+    )
+)
+class TestArrayReductionZeroSize:
+    @testing.numpy_cupy_allclose(
+        contiguous_check=False, accept_error=ValueError
+    )
+    def test_zero_size(self, xp):
+        shape, axis = self.shape_and_axis
+        # NumPy only supports axis being an int
+        if self.func in ("argmax", "argmin"):
+            if axis is not None and len(axis) == 1:
+                axis = axis[0]
+            else:
+                pytest.skip(
+                    f"NumPy does not support axis={axis} for {self.func}"
+                )
+        # dtype is irrelevant here, just pick one
+        a = testing.shaped_random(shape, xp, xp.float32, order=self.order)
+        return getattr(a, self.func)(axis=axis)
+
+
 # This class compares CUB results against NumPy's
 @testing.parameterize(
     *testing.product(