address comments

Author: Vahid Tavanashad

dpnp/tests/helper.py

@@ -147,7 +147,9 @@ def get_float_complex_dtypes(no_float16=True, device=None):
 def get_abs_array(data, dtype=None):
     if numpy.issubdtype(dtype, numpy.unsignedinteger):
         data = numpy.abs(data)
-    return numpy.array(data, dtype=dtype)
+    # it is better to use astype with the default casting=unsafe
+    # otherwise, we need to skip test for cases where overflow occurs
+    return numpy.array(data).astype(dtype)
 
 
 def get_all_dtypes(

dpnp/tests/test_linalg.py

@@ -151,7 +151,7 @@ class TestCholesky:
                 [[[7, 2], [2, 7]], [[8, 3], [3, 8]]],
             ],
         ],
-        ids=["2D_array", "3D_array", "4D_array"],
+        ids=["2D", "3D", "4D"],
     )
     @pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True))
     def test_cholesky(self, array, dtype):
@@ -171,7 +171,7 @@ def test_cholesky(self, array, dtype):
                 [[[7, 2], [2, 7]], [[8, 3], [3, 8]]],
             ],
         ],
-        ids=["2D_array", "3D_array", "4D_array"],
+        ids=["2D", "3D", "4D"],
     )
     @pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True))
     def test_cholesky_upper(self, array, dtype):
@@ -191,16 +191,14 @@ def test_cholesky_upper(self, array, dtype):
                     )
                 else:
                     reconstructed = res_reshaped[idx].T @ res_reshaped[idx]
-                assert_dtype_allclose(
-                    reconstructed, ia_reshaped[idx], check_type=False
-                )
+                assert dpnp.allclose(reconstructed, ia_reshaped[idx])
         else:
             # Reconstruct the matrix using the Cholesky decomposition result
             if dpnp.issubdtype(dtype, dpnp.complexfloating):
                 reconstructed = result.T.conj() @ result
             else:
                 reconstructed = result.T @ result
-            assert_dtype_allclose(reconstructed, ia, check_type=False)
+            assert dpnp.allclose(reconstructed, ia)
 
     # upper parameter support will be added in numpy 2.0 version
     @testing.with_requires("numpy>=2.0")
@@ -214,7 +212,7 @@ def test_cholesky_upper(self, array, dtype):
                 [[[7, 2], [2, 7]], [[8, 3], [3, 8]]],
             ],
         ],
-        ids=["2D_array", "3D_array", "4D_array"],
+        ids=["2D", "3D", "4D"],
     )
     @pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True))
     def test_cholesky_upper_numpy(self, array, dtype):
@@ -382,7 +380,7 @@ class TestDet:
                 [[[1, 3], [3, 1]], [[0, 1], [1, 3]]],
             ],
         ],
-        ids=["2D_array", "3D_array", "4D_array"],
+        ids=["2D", "3D", "4D"],
     )
     @pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True))
     def test_det(self, array, dtype):
@@ -1683,7 +1681,7 @@ class TestInv:
                 [[[1, 3], [3, 1]], [[0, 1], [1, 3]]],
             ],
         ],
-        ids=["2D_array", "3D_array", "4D_array"],
+        ids=["2D", "3D", "4D"],
     )
     @pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True))
     def test_inv(self, array, dtype):
@@ -2851,7 +2849,7 @@ def check_decomposition(
                 dpnp_diag_s[..., i, i] = dp_s[..., i]
                 reconstructed = dpnp.dot(dp_u, dpnp.dot(dpnp_diag_s, dp_vt))
 
-            assert_allclose(dp_a, reconstructed, rtol=tol, atol=1e-4)
+            assert dpnp.allclose(dp_a, reconstructed, rtol=tol, atol=1e-4)
 
         assert_allclose(dp_s, np_s, rtol=tol, atol=1e-03)
 
@@ -3034,7 +3032,7 @@ def test_pinv(self, dtype, shape):
         else:  # a.ndim > 2
             reconstructed = dpnp.matmul(a_dp, dpnp.matmul(B_dp, a_dp))
 
-        assert_allclose(reconstructed, a_dp, rtol=tol, atol=tol)
+        assert dpnp.allclose(reconstructed, a_dp, rtol=tol, atol=tol)
 
     @pytest.mark.parametrize("dtype", get_float_complex_dtypes())
     @pytest.mark.parametrize(
@@ -3054,7 +3052,7 @@ def test_pinv_hermitian(self, dtype, shape):
         tol = self._tol
 
         reconstructed = dpnp.dot(dpnp.dot(a_dp, B_dp), a_dp)
-        assert_allclose(reconstructed, a_dp, rtol=tol, atol=tol)
+        assert dpnp.allclose(reconstructed, a_dp, rtol=tol, atol=tol)
 
     # rtol kwarg was added in numpy 2.0
     @testing.with_requires("numpy>=2.0")

dpnp/tests/test_search.py

@@ -9,75 +9,83 @@
     generate_random_numpy_array,
     get_all_dtypes,
 )
+from .third_party.cupy import testing
 
 
+@testing.parameterize(
+    *testing.product(
+        {
+            "func": ("argmax", "argmin"),
+        }
+    )
+)
 class TestArgmaxArgmin:
-    @pytest.mark.parametrize("func", ["argmax", "argmin"])
     @pytest.mark.parametrize("axis", [None, 0, 1, -1, 2, -2])
     @pytest.mark.parametrize("keepdims", [False, True])
     @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
-    def test_func(self, func, axis, keepdims, dtype):
+    def test_func(self, axis, keepdims, dtype):
         a = generate_random_numpy_array((4, 4, 6, 8), dtype=dtype)
         ia = dpnp.array(a)
 
-        expected = getattr(numpy, func)(a, axis=axis, keepdims=keepdims)
-        result = getattr(dpnp, func)(ia, axis=axis, keepdims=keepdims)
+        expected = getattr(numpy, self.func)(a, axis=axis, keepdims=keepdims)
+        result = getattr(dpnp, self.func)(ia, axis=axis, keepdims=keepdims)
         assert_array_equal(result, expected)
 
-    @pytest.mark.parametrize("func", ["argmax", "argmin"])
-    def test_out(self, func):
+    def test_out(self):
         a = generate_random_numpy_array((2, 2, 3), dtype=numpy.float32)
         ia = dpnp.array(a)
 
         # out is dpnp_array
-        expected = getattr(numpy, func)(a, axis=0)
+        expected = getattr(numpy, self.func)(a, axis=0)
         dpnp_out = dpnp.empty(expected.shape, dtype=expected.dtype)
-        result = getattr(dpnp, func)(ia, axis=0, out=dpnp_out)
+        result = getattr(dpnp, self.func)(ia, axis=0, out=dpnp_out)
         assert dpnp_out is result
         assert_array_equal(result, expected)
 
         # out is usm_ndarray
         dpt_out = dpt.empty(expected.shape, dtype=expected.dtype)
-        result = getattr(dpnp, func)(ia, axis=0, out=dpt_out)
+        result = getattr(dpnp, self.func)(ia, axis=0, out=dpt_out)
         assert dpt_out is result.get_array()
         assert_array_equal(result, expected)
 
         # out is a numpy array -> TypeError
         result = numpy.empty_like(expected)
         with pytest.raises(TypeError):
-            getattr(dpnp, func)(ia, axis=0, out=result)
+            getattr(dpnp, self.func)(ia, axis=0, out=result)
 
         # out shape is incorrect -> ValueError
         result = dpnp.array(numpy.zeros((2, 2)), dtype=dpnp.intp)
         with pytest.raises(ValueError):
-            getattr(dpnp, func)(ia, axis=0, out=result)
+            getattr(dpnp, self.func)(ia, axis=0, out=result)
 
-    @pytest.mark.parametrize("func", ["argmax", "argmin"])
     @pytest.mark.parametrize("arr_dt", get_all_dtypes(no_none=True))
     @pytest.mark.parametrize("out_dt", get_all_dtypes(no_none=True))
-    def test_out_dtype(self, func, arr_dt, out_dt):
+    def test_out_dtype(self, arr_dt, out_dt):
         a = generate_random_numpy_array((2, 2, 3), dtype=arr_dt)
         out = numpy.zeros_like(a, shape=(2, 3), dtype=out_dt)
         ia, iout = dpnp.array(a), dpnp.array(out)
 
         if numpy.can_cast(out.dtype, numpy.intp, casting="safe"):
-            result = getattr(dpnp, func)(ia, out=iout, axis=1)
-            expected = getattr(numpy, func)(a, out=out, axis=1)
+            result = getattr(dpnp, self.func)(ia, out=iout, axis=1)
+            expected = getattr(numpy, self.func)(a, out=out, axis=1)
             assert_array_equal(result, expected)
             assert result is iout
         else:
-            assert_raises(TypeError, getattr(numpy, func), a, out=out, axis=1)
-            assert_raises(TypeError, getattr(dpnp, func), ia, out=iout, axis=1)
+            assert_raises(
+                TypeError, getattr(numpy, self.func), a, out=out, axis=1
+            )
+            assert_raises(
+                TypeError, getattr(dpnp, self.func), ia, out=iout, axis=1
+            )
 
-    @pytest.mark.parametrize("func", ["argmax", "argmin"])
     @pytest.mark.parametrize("axis", [None, 0, 1, -1])
     @pytest.mark.parametrize("keepdims", [False, True])
-    def test_ndarray(self, func, axis, keepdims):
+    def test_ndarray(self, axis, keepdims):
         a = generate_random_numpy_array((4, 6, 8), dtype=numpy.float32)
         ia = dpnp.array(a)
 
-        expected = getattr(a, func)(axis=axis, keepdims=keepdims)
-        result = getattr(ia, func)(axis=axis, keepdims=keepdims)
+        expected = getattr(a, self.func)(axis=axis, keepdims=keepdims)
+        result = getattr(ia, self.func)(axis=axis, keepdims=keepdims)
         assert_array_equal(result, expected)
 
 

dpnp/tests/test_statistics.py

@@ -600,84 +600,87 @@ def test_true_rowvar(self):
         assert_allclose(result, expected)
 
 
+@testing.parameterize(
+    *testing.product(
+        {
+            "func": ("max", "min"),
+        }
+    )
+)
 class TestMaxMin:
-    @pytest.mark.parametrize("func", ["max", "min"])
     @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_func(self, func, axis, keepdims, dtype):
+    def test_func(self, axis, keepdims, dtype):
         a = numpy.arange(768, dtype=dtype).reshape((4, 4, 6, 8))
         ia = dpnp.array(a)
 
-        expected = getattr(numpy, func)(a, axis=axis, keepdims=keepdims)
-        result = getattr(dpnp, func)(ia, axis=axis, keepdims=keepdims)
+        expected = getattr(numpy, self.func)(a, axis=axis, keepdims=keepdims)
+        result = getattr(dpnp, self.func)(ia, axis=axis, keepdims=keepdims)
         assert_dtype_allclose(result, expected)
 
-    @pytest.mark.parametrize("func", ["max", "min"])
     @pytest.mark.parametrize("axis", [None, 0, 1, -1])
     @pytest.mark.parametrize("keepdims", [False, True])
-    def test_bool(self, func, axis, keepdims):
+    def test_bool(self, axis, keepdims):
         a = numpy.arange(2, dtype=numpy.bool_)
         a = numpy.tile(a, (2, 2))
         ia = dpnp.array(a)
 
-        expected = getattr(numpy, func)(a, axis=axis, keepdims=keepdims)
-        result = getattr(dpnp, func)(ia, axis=axis, keepdims=keepdims)
+        expected = getattr(numpy, self.func)(a, axis=axis, keepdims=keepdims)
+        result = getattr(dpnp, self.func)(ia, axis=axis, keepdims=keepdims)
         assert_dtype_allclose(result, expected)
 
-    @pytest.mark.parametrize("func", ["max", "min"])
-    def test_out(self, func):
+    def test_out(self):
         a = numpy.arange(12, dtype=numpy.float32).reshape((2, 2, 3))
         ia = dpnp.array(a)
 
         # out is dpnp_array
-        expected = getattr(numpy, func)(a, axis=0)
+        expected = getattr(numpy, self.func)(a, axis=0)
         dpnp_out = dpnp.empty(expected.shape, dtype=expected.dtype)
-        result = getattr(dpnp, func)(ia, axis=0, out=dpnp_out)
+        result = getattr(dpnp, self.func)(ia, axis=0, out=dpnp_out)
         assert dpnp_out is result
         assert_allclose(result, expected)
 
         # out is usm_ndarray
         dpt_out = dpt.empty(expected.shape, dtype=expected.dtype)
-        result = getattr(dpnp, func)(ia, axis=0, out=dpt_out)
+        result = getattr(dpnp, self.func)(ia, axis=0, out=dpt_out)
         assert dpt_out is result.get_array()
         assert_allclose(result, expected)
 
         # output is numpy array -> Error
         result = numpy.empty_like(expected)
         with pytest.raises(TypeError):
-            getattr(dpnp, func)(ia, axis=0, out=result)
+            getattr(dpnp, self.func)(ia, axis=0, out=result)
 
         # output has incorrect shape -> Error
         result = dpnp.array(numpy.zeros((4, 2)))
         with pytest.raises(ValueError):
-            getattr(dpnp, func)(ia, axis=0, out=result)
+            getattr(dpnp, self.func)(ia, axis=0, out=result)
 
     @pytest.mark.usefixtures("suppress_complex_warning")
-    @pytest.mark.parametrize("func", ["max", "min"])
     @pytest.mark.parametrize("arr_dt", get_all_dtypes(no_none=True))
     @pytest.mark.parametrize("out_dt", get_all_dtypes(no_none=True))
-    def test_out_dtype(self, func, arr_dt, out_dt):
+    def test_out_dtype(self, arr_dt, out_dt):
+        # if out_dt is unsigned, input cannot be signed otherwise overflow occurs
         low = 0 if dpnp.issubdtype(out_dt, dpnp.unsignedinteger) else -10
         a = generate_random_numpy_array((2, 2, 3), dtype=arr_dt, low=low)
         out = numpy.zeros_like(a, shape=(2, 3), dtype=out_dt)
         ia, iout = dpnp.array(a), dpnp.array(out)
 
-        result = getattr(dpnp, func)(ia, out=iout, axis=1)
-        expected = getattr(numpy, func)(a, out=out, axis=1)
+        result = getattr(dpnp, self.func)(ia, out=iout, axis=1)
+        expected = getattr(numpy, self.func)(a, out=out, axis=1)
         assert_dtype_allclose(result, expected)
         assert result is iout
 
-    @pytest.mark.parametrize("func", ["max", "min"])
-    def test_error(self, func):
+    def test_error(self):
         ia = dpnp.arange(5)
         # where is not supported
         with pytest.raises(NotImplementedError):
-            getattr(dpnp, func)(ia, where=False)
+            getattr(dpnp, self.func)(ia, where=False)
 
         # initial is not supported
         with pytest.raises(NotImplementedError):
-            getattr(dpnp, func)(ia, initial=6)
+            getattr(dpnp, self.func)(ia, initial=6)
 
 
 class TestMean:

dpnp/tests/test_sum.py

@@ -51,16 +51,7 @@ def test_sum(shape, dtype_in, dtype_out, transpose, keepdims, order):
     axes.append(tuple(axes_range))
 
     for axis in axes:
-        if (
-            numpy.issubdtype(dtype_out, numpy.bool_)
-            and numpy.issubdtype(dtype_in, numpy.signedinteger)
-            and not a_np.sum(axis=axis).all()
-        ):
-            # TODO: remove workaround when dpctl-issue#1944 is resolved
-            a = a.astype(dpnp.bool)
-            dpnp_res = a.sum(axis=axis, dtype=dtype_out, keepdims=keepdims)
-        else:
-            dpnp_res = a.sum(axis=axis, dtype=dtype_out, keepdims=keepdims)
+        dpnp_res = a.sum(axis=axis, dtype=dtype_out, keepdims=keepdims)
         numpy_res = a_np.sum(axis=axis, dtype=dtype_out, keepdims=keepdims)
         assert_dtype_allclose(dpnp_res, numpy_res, factor=16)
 
@@ -74,7 +65,9 @@ def test_sum_empty_out(dtype):
     assert_array_equal(out, numpy.array(0, dtype=dtype))
 
 
-@pytest.mark.parametrize("dtype", get_all_dtypes(no_complex=True, no_bool=True))
+@pytest.mark.parametrize(
+    "dtype", get_all_dtypes(no_none=True, no_bool=True, no_complex=True)
+)
 @pytest.mark.parametrize("axis", [None, 0, 1, 2, 3])
 def test_sum_empty(dtype, axis):
     a = numpy.empty((1, 2, 0, 4), dtype=dtype)

dpnp/tests/test_umath.py

@@ -468,12 +468,11 @@ def test_values(self, dt):
         assert_dtype_allclose(result, expected)
 
     @pytest.mark.parametrize(
-        "dt",
-        [dpnp.bool, dpnp.int32, dpnp.int64, dpnp.float32, dpnp.float64],
+        "dt", get_all_dtypes(no_none=True, no_complex=True)
     )
     def test_range(self, dt):
-        a = numpy.array([1000000, -1000000, 1000200, -1000200], dtype=dt)
-        b = numpy.array([1000200, -1000200, 1000000, -1000000], dtype=dt)
+        a = get_abs_array([1000000, -1000000, 1000200, -1000200], dtype=dt)
+        b = get_abs_array([1000200, -1000200, 1000000, -1000000], dtype=dt)
         ia, ib = dpnp.array(a), dpnp.array(b)
 
         result = dpnp.logaddexp2(ia, ib)