Update test_qr in test_sycl_queue

Author: vlad-perevezentsev

dpnp/linalg/dpnp_utils_linalg.py

@@ -806,18 +806,57 @@ def dpnp_qr_batch(a, mode="reduced"):
     if batch_size == 0 or k == 0:
         if mode == "reduced":
             return (
-                dpnp.empty(batch_shape + (m, k), dtype=res_type),
-                dpnp.empty(batch_shape + (k, n), dtype=res_type),
+                dpnp.empty(
+                    batch_shape + (m, k),
+                    dtype=res_type,
+                    sycl_queue=a_sycl_queue,
+                    usm_type=a_usm_type,
+                ),
+                dpnp.empty(
+                    batch_shape + (k, n),
+                    dtype=res_type,
+                    sycl_queue=a_sycl_queue,
+                    usm_type=a_usm_type,
+                ),
             )
         elif mode == "complete":
-            q = _stacked_identity(batch_shape, m, dtype=res_type)
-            return (q, dpnp.empty(batch_shape + (m, n), dtype=res_type))
+            q = _stacked_identity(
+                batch_shape,
+                m,
+                dtype=res_type,
+                usm_type=a_usm_type,
+                sycl_queue=a_sycl_queue,
+            )
+            return (
+                q,
+                dpnp.empty(
+                    batch_shape + (m, n),
+                    dtype=res_type,
+                    sycl_queue=a_sycl_queue,
+                    usm_type=a_usm_type,
+                ),
+            )
         elif mode == "r":
-            return dpnp.empty(batch_shape + (k, n), dtype=res_type)
+            return dpnp.empty(
+                batch_shape + (k, n),
+                dtype=res_type,
+                sycl_queue=a_sycl_queue,
+                usm_type=a_usm_type,
+            )
         elif mode == "raw":
             return (
-                dpnp.empty(batch_shape + (n, m), dtype=res_type),
-                dpnp.empty(batch_shape + (k,), dtype=res_type),
+                dpnp.empty(
+                    batch_shape + (n, m),
+                    dtype=res_type,
+                    sycl_queue=a_sycl_queue,
+                    usm_type=a_usm_type,
+                ),
+                dpnp.empty(
+                    batch_shape + (k,),
+                    dtype=res_type,
+                    sycl_queue=a_sycl_queue,
+                    usm_type=a_usm_type,
+                ),
             )
 
     # get 3d input arrays by reshape
@@ -826,7 +865,7 @@ def dpnp_qr_batch(a, mode="reduced"):
     a = a.swapaxes(-2, -1)
     a_usm_arr = dpnp.get_usm_ndarray(a)
 
-    a_t = dpnp.empty_like(a, order="C", dtype=res_type, usm_type=a_usm_type)
+    a_t = dpnp.empty_like(a, order="C", dtype=res_type)
 
     # use DPCTL tensor function to fill the matrix array
     # with content from the input array `a`
@@ -876,10 +915,20 @@ def dpnp_qr_batch(a, mode="reduced"):
 
     if mode == "complete" and m > n:
         mc = m
-        q = dpnp.empty((batch_size, m, m), dtype=res_type)
+        q = dpnp.empty(
+            (batch_size, m, m),
+            dtype=res_type,
+            sycl_queue=a_sycl_queue,
+            usm_type=a_usm_type,
+        )
     else:
         mc = k
-        q = dpnp.empty((batch_size, n, m), dtype=res_type)
+        q = dpnp.empty(
+            (batch_size, n, m),
+            dtype=res_type,
+            sycl_queue=a_sycl_queue,
+            usm_type=a_usm_type,
+        )
     q[..., :n, :] = a_t
 
     q_stride = q.strides[0]
@@ -977,7 +1026,7 @@ def dpnp_qr(a, mode="reduced"):
 
     a = a.T
     a_usm_arr = dpnp.get_usm_ndarray(a)
-    a_t = dpnp.empty_like(a, order="C", dtype=res_type, usm_type=a_usm_type)
+    a_t = dpnp.empty_like(a, order="C", dtype=res_type)
 
     # use DPCTL tensor function to fill the matrix array
     # with content from the input array `a`

tests/test_sycl_queue.py

@@ -1171,34 +1171,54 @@ def test_matrix_rank(device):
     assert_array_equal(expected, result)
 
 
+@pytest.mark.parametrize(
+    "shape",
+    [
+        (4, 4),
+        (2, 0),
+        (2, 2, 3),
+        (0, 2, 3),
+        (1, 0, 3),
+    ],
+    ids=[
+        "(4, 4)",
+        "(2, 0)",
+        "(2, 2, 3)",
+        "(0, 2, 3)",
+        "(1, 0, 3)",
+    ],
+)
+@pytest.mark.parametrize(
+    "mode",
+    ["r", "raw", "complete", "reduced"],
+    ids=["r", "raw", "complete", "reduced"],
+)
 @pytest.mark.parametrize(
     "device",
     valid_devices,
     ids=[device.filter_string for device in valid_devices],
 )
-def test_qr(device):
-    data = [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0]]
-    dpnp_data = dpnp.array(data, device=device)
-    numpy_data = numpy.array(data, dtype=dpnp_data.dtype)
-
-    np_q, np_r = numpy.linalg.qr(numpy_data, "reduced")
-    dpnp_q, dpnp_r = dpnp.linalg.qr(dpnp_data, "reduced")
+def test_qr(shape, mode, device):
+    dtype = dpnp.default_float_type(device)
+    count_elems = numpy.prod(shape)
+    dpnp_data = dpnp.arange(count_elems, dtype=dtype, device=device).reshape(
+        shape
+    )
 
-    assert dpnp_q.dtype == np_q.dtype
-    assert dpnp_r.dtype == np_r.dtype
-    assert dpnp_q.shape == np_q.shape
-    assert dpnp_r.shape == np_r.shape
+    expected_queue = dpnp_data.get_array().sycl_queue
 
-    assert_dtype_allclose(dpnp_q, np_q)
-    assert_dtype_allclose(dpnp_r, np_r)
+    if mode == "r":
+        dpnp_r = dpnp.linalg.qr(dpnp_data, mode=mode)
+        dpnp_r_queue = dpnp_r.get_array().sycl_queue
+        assert_sycl_queue_equal(dpnp_r_queue, expected_queue)
+    else:
+        dpnp_q, dpnp_r = dpnp.linalg.qr(dpnp_data, mode=mode)
 
-    expected_queue = dpnp_data.get_array().sycl_queue
-    dpnp_q_queue = dpnp_q.get_array().sycl_queue
-    dpnp_r_queue = dpnp_r.get_array().sycl_queue
+        dpnp_q_queue = dpnp_q.get_array().sycl_queue
+        dpnp_r_queue = dpnp_r.get_array().sycl_queue
 
-    # compare queue and device
-    assert_sycl_queue_equal(dpnp_q_queue, expected_queue)
-    assert_sycl_queue_equal(dpnp_r_queue, expected_queue)
+        assert_sycl_queue_equal(dpnp_q_queue, expected_queue)
+        assert_sycl_queue_equal(dpnp_r_queue, expected_queue)
 
 
 @pytest.mark.parametrize(