Input array should be dpnp.ndarray or usm_ndarray

Author: vtavana

dpnp/dpnp_iface_manipulation.py

@@ -1960,8 +1960,9 @@ def require(a, dtype=None, requirements=None, *, like=None):
 
     Parameters
     ----------
-    a : array_like
-       The object to be converted to a type-and-requirement-satisfying array.
+    a : {dpnp.ndarray, usm_ndarray}
+       The input array to be converted to a type-and-requirement-satisfying
+       array.
     dtype : {None, data-type}, optional
        The required data-type. If ``None`` preserve the current dtype.
     requirements : {None, str, sequence of str}, optional
@@ -2015,6 +2016,7 @@ def require(a, dtype=None, requirements=None, *, like=None):
     """
 
     dpnp.check_limitations(like=like)
+    dpnp.check_supported_arrays_type(a)
 
     possible_flags = {
         "C": "C",

tests/test_manipulation.py

@@ -701,24 +701,26 @@ def test_require_each(self):
             a = self.generate_all_false(idtype)
             self.set_and_check_flag(flag, fdtype, a)
 
-    @pytest.mark.parametrize("xp", [numpy, dpnp])
-    def test_unknown_requirement(self, xp):
+    def test_unknown_requirement(self):
         a = self.generate_all_false("f4")
-        assert_raises((KeyError, ValueError), xp.require, a, None, "Q")
+        assert_raises(KeyError, numpy.require, a[0], None, "Q")
+        assert_raises(ValueError, dpnp.require, a[1], None, "Q")
 
     def test_non_array_input(self):
-        expected = numpy.require([1, 2, 3, 4], "i4", ["C", "W"])
-        result = dpnp.require([1, 2, 3, 4], "i4", ["C", "W"])
+        a_np = numpy.array([1, 2, 3, 4])
+        a_dp = dpnp.array(a_np)
+        expected = numpy.require(a_np, "i4", ["C", "W"])
+        result = dpnp.require(a_dp, "i4", ["C", "W"])
         assert expected.flags["C"] == result.flags["C"]
         assert expected.flags["F"] == result.flags["F"]
         assert expected.flags["W"] == result.flags["W"]
         assert expected.dtype == result.dtype
         assert_array_equal(expected, result)
 
-    @pytest.mark.parametrize("xp", [numpy, dpnp])
-    def test_C_and_F_simul(self, xp):
+    def test_C_and_F_simul(self):
         a = self.generate_all_false("f4")
-        assert_raises(ValueError, xp.require, a, None, ["C", "F"])
+        assert_raises(ValueError, numpy.require, a[0], None, ["C", "F"])
+        assert_raises(ValueError, dpnp.require, a[1], None, ["C", "F"])
 
     def test_copy(self):
         a_np = numpy.arange(6).reshape(2, 3)

tests/test_sycl_queue.py

@@ -1285,6 +1285,26 @@ def test_out_multi_dot(device):
         assert_sycl_queue_equal(result.sycl_queue, exec_q)
 
 
+@pytest.mark.parametrize(
+    "device",
+    valid_devices,
+    ids=[device.filter_string for device in valid_devices],
+)
+def test_require(device):
+    dpnp_data = dpnp.arange(10, device=device).reshape(2, 5)
+    result = dpnp.require(dpnp_data, dtype="f4", requirements=["F"])
+
+    expected_queue = dpnp_data.sycl_queue
+    result_queue = result.sycl_queue
+    assert_sycl_queue_equal(result_queue, expected_queue)
+
+    # No requirements
+    result = dpnp.require(dpnp_data, dtype="f4")
+    expected_queue = dpnp_data.sycl_queue
+    result_queue = result.sycl_queue
+    assert_sycl_queue_equal(result_queue, expected_queue)
+
+
 @pytest.mark.parametrize(
     "device",
     valid_devices,

tests/test_usm_type.py

@@ -1013,6 +1013,19 @@ def test_eigenvalue(func, shape, usm_type):
     assert a.usm_type == dp_val.usm_type
 
 
+@pytest.mark.parametrize("usm_type", list_of_usm_types, ids=list_of_usm_types)
+def test_require(usm_type):
+    dpnp_data = dp.arange(10, usm_type=usm_type).reshape(2, 5)
+    result = dp.require(dpnp_data, dtype="f4", requirements=["F"])
+    assert dpnp_data.usm_type == usm_type
+    assert result.usm_type == usm_type
+
+    # No requirements
+    result = dp.require(dpnp_data, dtype="f4")
+    assert dpnp_data.usm_type == usm_type
+    assert result.usm_type == usm_type
+
+
 @pytest.mark.parametrize("usm_type", list_of_usm_types, ids=list_of_usm_types)
 def test_resize(usm_type):
     dpnp_data = dp.arange(10, usm_type=usm_type)