Merge f73bcf3 into 6cc2348

Author: antonwolfy

dpnp/dpnp_array.py

@@ -185,7 +185,12 @@ def __and__(self, other):
         """Return ``self&value``."""
         return dpnp.bitwise_and(self, other)
 
-    # '__array__',
+    def __array__(self, dtype=None, /, *, copy=None):
+        raise TypeError(
+            "Implicit conversion to a NumPy array is not allowed. "
+            "Please use `.asnumpy()` to construct a NumPy array explicitly."
+        )
+
     # '__array_finalize__',
     # '__array_function__',
     # '__array_interface__',

dpnp/dpnp_utils/dpnp_utils_pad.py

@@ -74,7 +74,12 @@ def _as_pairs(x, ndim, as_index=False):
             x = round(x)
         return ((x, x),) * ndim
 
-    x = numpy.array(x)
+    # explicitly cast input "x" to NumPy array
+    if dpnp.is_supported_array_type(x):
+        x = dpnp.asnumpy(x)
+    else:
+        x = numpy.array(x)
+
     if as_index:
         x = numpy.asarray(numpy.round(x), dtype=numpy.intp)
 

dpnp/tests/__init__.py

@@ -3,5 +3,6 @@
 from . import testing
 
 numpy.testing.assert_allclose = testing.assert_allclose
+numpy.testing.assert_almost_equal = testing.assert_almost_equal
 numpy.testing.assert_array_equal = testing.assert_array_equal
 numpy.testing.assert_equal = testing.assert_equal

dpnp/tests/helper.py

@@ -161,6 +161,20 @@ def get_all_dtypes(
     return dtypes
 
 
+def get_array(xp, a):
+    """
+    Cast input array `a` to a type supported by `xp` initerface.
+
+    Implicit conversion of either DPNP or DPCTL array to a NumPy array is not
+    allowed. Input array has to be explicitly casted with `asnumpy` function.
+
+    """
+
+    if xp is numpy and dpnp.is_supported_array_type(a):
+        return dpnp.asnumpy(a)
+    return a
+
+
 def generate_random_numpy_array(
     shape,
     dtype=None,

dpnp/tests/test_arraycreation.py

@@ -17,6 +17,7 @@
 from .helper import (
     assert_dtype_allclose,
     get_all_dtypes,
+    get_array,
 )
 from .third_party.cupy import testing
 
@@ -768,7 +769,7 @@ def test_space_numpy_dtype(func, start_dtype, stop_dtype):
     ],
 )
 def test_linspace_arrays(start, stop):
-    func = lambda xp: xp.linspace(start, stop, 10)
+    func = lambda xp: xp.linspace(get_array(xp, start), get_array(xp, stop), 10)
     assert func(numpy).shape == func(dpnp).shape
 
 

dpnp/tests/test_indexing.py

@@ -17,7 +17,12 @@
 import dpnp
 from dpnp.dpnp_array import dpnp_array
 
-from .helper import get_all_dtypes, get_integer_dtypes, has_support_aspect64
+from .helper import (
+    get_all_dtypes,
+    get_array,
+    get_integer_dtypes,
+    has_support_aspect64,
+)
 from .third_party.cupy import testing
 
 
@@ -441,16 +446,15 @@ class TestPut:
     )
     @pytest.mark.parametrize("ind_dt", get_all_dtypes(no_none=True))
     @pytest.mark.parametrize(
-        "vals",
+        "ivals",
         [0, [1, 2], (2, 2), dpnp.array([1, 2])],
         ids=["0", "[1, 2]", "(2, 2)", "dpnp.array([1,2])"],
     )
     @pytest.mark.parametrize("mode", ["clip", "wrap"])
-    def test_input_1d(self, a_dt, indices, ind_dt, vals, mode):
+    def test_input_1d(self, a_dt, indices, ind_dt, ivals, mode):
         a = numpy.array([-2, -1, 0, 1, 2], dtype=a_dt)
-        b = numpy.copy(a)
-        ia = dpnp.array(a)
-        ib = dpnp.array(b)
+        b, vals = numpy.copy(a), get_array(numpy, ivals)
+        ia, ib = dpnp.array(a), dpnp.array(b)
 
         ind = numpy.array(indices, dtype=ind_dt)
         if ind_dt == dpnp.bool and ind.all():
@@ -459,18 +463,18 @@ def test_input_1d(self, a_dt, indices, ind_dt, vals, mode):
 
         if numpy.can_cast(ind_dt, numpy.intp, casting="safe"):
             numpy.put(a, ind, vals, mode=mode)
-            dpnp.put(ia, iind, vals, mode=mode)
+            dpnp.put(ia, iind, ivals, mode=mode)
             assert_array_equal(ia, a)
 
             b.put(ind, vals, mode=mode)
-            ib.put(iind, vals, mode=mode)
+            ib.put(iind, ivals, mode=mode)
             assert_array_equal(ib, b)
         else:
             assert_raises(TypeError, numpy.put, a, ind, vals, mode=mode)
-            assert_raises(TypeError, dpnp.put, ia, iind, vals, mode=mode)
+            assert_raises(TypeError, dpnp.put, ia, iind, ivals, mode=mode)
 
             assert_raises(TypeError, b.put, ind, vals, mode=mode)
-            assert_raises(TypeError, ib.put, iind, vals, mode=mode)
+            assert_raises(TypeError, ib.put, iind, ivals, mode=mode)
 
     @pytest.mark.parametrize("a_dt", get_all_dtypes(no_none=True))
     @pytest.mark.parametrize(
@@ -637,7 +641,7 @@ def test_values(self, arr_dt, idx_dt, ndim, values):
         ia, iind = dpnp.array(a), dpnp.array(ind)
 
         for axis in range(ndim):
-            numpy.put_along_axis(a, ind, values, axis)
+            numpy.put_along_axis(a, ind, get_array(numpy, values), axis)
             dpnp.put_along_axis(ia, iind, values, axis)
             assert_array_equal(ia, a)
 

dpnp/tests/test_linalg.py

@@ -1935,7 +1935,7 @@ def test_matrix_rank(self, data, dtype):
 
         np_rank = numpy.linalg.matrix_rank(a)
         dp_rank = dpnp.linalg.matrix_rank(a_dp)
-        assert np_rank == dp_rank
+        assert dp_rank.asnumpy() == np_rank
 
     @pytest.mark.parametrize("dtype", get_all_dtypes())
     @pytest.mark.parametrize(
@@ -1953,7 +1953,7 @@ def test_matrix_rank_hermitian(self, data, dtype):
 
         np_rank = numpy.linalg.matrix_rank(a, hermitian=True)
         dp_rank = dpnp.linalg.matrix_rank(a_dp, hermitian=True)
-        assert np_rank == dp_rank
+        assert dp_rank.asnumpy() == np_rank
 
     @pytest.mark.parametrize(
         "high_tol, low_tol",
@@ -1986,15 +1986,15 @@ def test_matrix_rank_tolerance(self, high_tol, low_tol):
         dp_rank_high_tol = dpnp.linalg.matrix_rank(
             a_dp, hermitian=True, tol=dp_high_tol
         )
-        assert np_rank_high_tol == dp_rank_high_tol
+        assert dp_rank_high_tol.asnumpy() == np_rank_high_tol
 
         np_rank_low_tol = numpy.linalg.matrix_rank(
             a, hermitian=True, tol=low_tol
         )
         dp_rank_low_tol = dpnp.linalg.matrix_rank(
             a_dp, hermitian=True, tol=dp_low_tol
         )
-        assert np_rank_low_tol == dp_rank_low_tol
+        assert dp_rank_low_tol.asnumpy() == np_rank_low_tol
 
     # rtol kwarg was added in numpy 2.0
     @testing.with_requires("numpy>=2.0")
@@ -2789,15 +2789,14 @@ def check_decomposition(
             for i in range(min(dp_a.shape[-2], dp_a.shape[-1])):
                 dpnp_diag_s[..., i, i] = dp_s[..., i]
                 reconstructed = dpnp.dot(dp_u, dpnp.dot(dpnp_diag_s, dp_vt))
-            # TODO: use assert dpnp.allclose() inside check_decomposition()
-            # when it will support complex dtypes
-            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)
 
         if compute_vt:
             for i in range(min(dp_a.shape[-2], dp_a.shape[-1])):
-                if np_u[..., 0, i] * dp_u[..., 0, i] < 0:
+                if np_u[..., 0, i] * dpnp.asnumpy(dp_u[..., 0, i]) < 0:
                     np_u[..., :, i] = -np_u[..., :, i]
                     np_vt[..., i, :] = -np_vt[..., i, :]
             for i in range(numpy.count_nonzero(np_s > tol)):

dpnp/tests/testing/__init__.py

@@ -1,5 +1,6 @@
 from .array import (
     assert_allclose,
+    assert_almost_equal,
     assert_array_equal,
     assert_equal,
 )

dpnp/tests/testing/array.py

@@ -29,6 +29,7 @@
 from dpnp.dpnp_utils import convert_item
 
 assert_allclose_orig = numpy.testing.assert_allclose
+assert_almost_equal_orig = numpy.testing.assert_almost_equal
 assert_array_equal_orig = numpy.testing.assert_array_equal
 assert_equal_orig = numpy.testing.assert_equal
 
@@ -44,6 +45,10 @@ def assert_allclose(result, expected, *args, **kwargs):
     _assert(assert_allclose_orig, result, expected, *args, **kwargs)
 
 
+def assert_almost_equal(result, expected, *args, **kwargs):
+    _assert(assert_almost_equal_orig, result, expected, *args, **kwargs)
+
+
 def assert_array_equal(result, expected, *args, **kwargs):
     _assert(assert_array_equal_orig, result, expected, *args, **kwargs)
 

dpnp/tests/third_party/cupy/core_tests/test_ndarray.py

@@ -691,7 +691,6 @@ def test_format(self, xp):
         return format(x, ".2f")
 
 
-@pytest.mark.skip("implicit conversation to numpy does not raise an exception")
 class TestNdarrayImplicitConversion(unittest.TestCase):
 
     def test_array(self):

dpnp/tests/third_party/cupy/random_tests/test_permutations.py

@@ -129,7 +129,7 @@ class TestPermutationSoundness(unittest.TestCase):
 
     def setUp(self):
         a = cupy.random.permutation(self.num)
-        self.a = a
+        self.a = a.asnumpy()
 
     # Test soundness
 

dpnp/tests/third_party/cupy/random_tests/test_sample.py

@@ -89,15 +89,15 @@ def test_bound_float2(self):
     def test_goodness_of_fit(self):
         mx = 5
         trial = 100
-        vals = [random.randint(mx) for _ in range(trial)]
+        vals = [random.randint(mx).asnumpy() for _ in range(trial)]
         counts = numpy.histogram(vals, bins=numpy.arange(mx + 1))[0]
         expected = numpy.array([float(trial) / mx] * mx)
         assert _hypothesis.chi_square_test(counts, expected)
 
     @_condition.repeat(3, 10)
     def test_goodness_of_fit_2(self):
         mx = 5
-        vals = random.randint(mx, size=(5, 20))
+        vals = random.randint(mx, size=(5, 20)).asnumpy()
         counts = numpy.histogram(vals, bins=numpy.arange(mx + 1))[0]
         expected = numpy.array([float(vals.size) / mx] * mx)
         assert _hypothesis.chi_square_test(counts, expected)
@@ -191,15 +191,15 @@ def test_bound_2(self):
     def test_goodness_of_fit(self):
         mx = 5
         trial = 100
-        vals = [random.randint(0, mx) for _ in range(trial)]
+        vals = [random.randint(0, mx).asnumpy() for _ in range(trial)]
         counts = numpy.histogram(vals, bins=numpy.arange(mx + 1))[0]
         expected = numpy.array([float(trial) / mx] * mx)
         assert _hypothesis.chi_square_test(counts, expected)
 
     @_condition.repeat(3, 10)
     def test_goodness_of_fit_2(self):
         mx = 5
-        vals = random.randint(0, mx, (5, 20))
+        vals = random.randint(0, mx, (5, 20)).asnumpy()
         counts = numpy.histogram(vals, bins=numpy.arange(mx + 1))[0]
         expected = numpy.array([float(vals.size) / mx] * mx)
         assert _hypothesis.chi_square_test(counts, expected)