Implement dpnp.linalg.lu_solve() 2D inputs

dpnp/linalg/dpnp_iface_linalg.py

@@ -970,7 +970,7 @@ def lu_factor(a, overwrite_a=False, check_finite=True):
 
 def lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True):
     """
-    Solve an equation system, a x = b, given the LU factorization of `a`.
+    Solve a linear system, :math:`a x = b`, given the LU factorization of `a`.
 
     For full documentation refer to :obj:`scipy.linalg.lu_solve`.
 
@@ -983,13 +983,15 @@ def lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True):
     trans : {0, 1, 2} , optional
         Type of system to solve:
 
-        =====  =========
+        =====  =================
         trans  system
-        =====  =========
-        0      a x   = b
-        1      a^T x = b
-        2      a^H x = b
-        =====  =========
+        =====  =================
+        0      :math:`a x = b`
+        1      :math:`a^T x = b`
+        2      :math:`a^H x = b`
+        =====  =================
+
+        Default: ``0``.
     overwrite_b : {None, bool}, optional
         Whether to overwrite data in `b` (may increase performance).
 
@@ -1011,6 +1013,10 @@ def lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True):
     This function synchronizes in order to validate array elements
     when ``check_finite=True``.
 
+    See Also
+    --------
+    :obj:`dpnp.linalg.lu_factor` : LU factorize a matrix.
+
     Examples
     --------
     >>> import dpnp as np

dpnp/linalg/dpnp_utils_linalg.py

@@ -2508,12 +2508,14 @@ def dpnp_lu_solve(lu, piv, b, trans=0, overwrite_b=False, check_finite=True):
     if check_finite:
         if not dpnp.isfinite(lu).all():
             raise ValueError(
-                "array must not contain infs or NaNs.\n"
+                "LU factorization array must not contain infs or NaNs.\n"
                 "Note that when a singular matrix is given, unlike "
                 "dpnp.linalg.lu_factor returns an array containing NaN."
             )
         if not dpnp.isfinite(b).all():
-            raise ValueError("array must not contain infs or NaNs")
+            raise ValueError(
+                "Right-hand side array must not contain infs or NaNs"
+            )
 
     lu_usm_arr = dpnp.get_usm_ndarray(lu)
     piv_usm_arr = dpnp.get_usm_ndarray(piv)

dpnp/tests/test_linalg.py

@@ -1931,6 +1931,7 @@ def test_overwrite_inplace(self, dtype):
         )
 
         assert lu is a_dp
+        assert lu.data.ptr == a_dp.data.ptr
         assert lu.flags["F_CONTIGUOUS"] is True
 
         L, U = self._split_lu(lu, 2, 2)
@@ -1948,6 +1949,7 @@ def test_overwrite_copy(self, dtype):
         )
 
         assert lu is not a_dp
+        assert lu.data.ptr != a_dp.data.ptr
         assert lu.flags["F_CONTIGUOUS"] is True
 
         L, U = self._split_lu(lu, 2, 2)
@@ -1974,6 +1976,7 @@ def test_overwrite_copy_special(self):
             )
 
             assert lu is not a_dp
+            assert lu.data.ptr != a_dp.data.ptr
             assert lu.flags["F_CONTIGUOUS"] is True
 
             L, U = self._split_lu(lu, 2, 2)
@@ -2217,6 +2220,7 @@ def test_overwrite_inplace(self, dtype):
         )
 
         assert x is b_dp
+        assert x.data.ptr == b_dp.data.ptr
         assert dpnp.allclose(a_dp @ x, b_orig, rtol=1e-6, atol=1e-6)
 
     @pytest.mark.parametrize("dtype", get_float_complex_dtypes())
@@ -2230,6 +2234,7 @@ def test_overwrite_copy_special(self, dtype):
             (lu, piv), b1, overwrite_b=True, check_finite=False
         )
         assert x1 is not b1
+        assert x1.data.ptr != b1.data.ptr
 
         # F-contig, match dtype but read-only input
         b2 = dpnp.array([1, 0], dtype=dtype, order="F")
@@ -2238,6 +2243,7 @@ def test_overwrite_copy_special(self, dtype):
             (lu, piv), b2, overwrite_b=True, check_finite=False
         )
         assert x2 is not b2
+        assert x2.data.ptr != b2.data.ptr
 
         for x in (x1, x2):
             assert dpnp.allclose(

dpnp/tests/test_sycl_queue.py

@@ -1612,13 +1612,13 @@ def test_lu_factor(self, data, device):
             assert_sycl_queue_equal(param_queue, a.sycl_queue)
 
     @pytest.mark.parametrize(
-        "data",
+        "b_data",
         [[1.0, 2.0], numpy.empty((2, 0))],
     )
-    def test_lu_solve(self, data, device):
+    def test_lu_solve(self, b_data, device):
         a = dpnp.array([[1.0, 2.0], [3.0, 5.0]], device=device)
         lu, piv = dpnp.linalg.lu_factor(a)
-        b = dpnp.array(data, device=device)
+        b = dpnp.array(b_data, device=device)
 
         result = dpnp.linalg.lu_solve((lu, piv), b)
 

dpnp/tests/test_usm_type.py

@@ -1489,13 +1489,13 @@ def test_lu_factor(self, data, usm_type):
 
     @pytest.mark.parametrize("usm_type_rhs", list_of_usm_types)
     @pytest.mark.parametrize(
-        "data",
+        "b_data",
         [[1.0, 2.0], numpy.empty((2, 0))],
     )
-    def test_lu_solve(self, data, usm_type, usm_type_rhs):
-        a = dpnp.array(data, usm_type=usm_type)
+    def test_lu_solve(self, b_data, usm_type, usm_type_rhs):
+        a = dpnp.array([[1.0, 2.0], [3.0, 5.0]], usm_type=usm_type)
         lu, piv = dpnp.linalg.lu_factor(a)
-        b = dpnp.array(data, usm_type=usm_type_rhs)
+        b = dpnp.array(b_data, usm_type=usm_type_rhs)
 
         result = dpnp.linalg.lu_solve((lu, piv), b)