Update linalg_tests/test_solve.py

Author: antonwolfy

dpnp/tests/third_party/cupy/linalg_tests/test_solve.py

@@ -15,13 +15,14 @@
 @testing.parameterize(
     *testing.product(
         {
+            # "batched_gesv_limit": [None, 0],
             "order": ["C", "F"],
         }
     )
 )
 @testing.fix_random()
 class TestSolve(unittest.TestCase):
-    # TODO: add get_batched_gesv_limit
+
     # def setUp(self):
     #     if self.batched_gesv_limit is not None:
     #         self.old_limit = get_batched_gesv_limit()
@@ -32,6 +33,7 @@ class TestSolve(unittest.TestCase):
     #         set_batched_gesv_limit(self.old_limit)
 
     @testing.for_dtypes("ifdFD")
+    # TODO(kataoka): Fix contiguity
     @testing.numpy_cupy_allclose(
         atol=1e-3, contiguous_check=False, type_check=has_support_aspect64()
     )
@@ -47,6 +49,7 @@ def check_x(self, a_shape, b_shape, xp, dtype):
         testing.assert_array_equal(b_copy, b)
         return result
 
+    @testing.with_requires("numpy>=2.0")
     def test_solve(self):
         self.check_x((4, 4), (4,))
         self.check_x((5, 5), (5, 2))
@@ -55,15 +58,9 @@ def test_solve(self):
         self.check_x((0, 0), (0,))
         self.check_x((0, 0), (0, 2))
         self.check_x((0, 2, 2), (0, 2, 3))
-        # In numpy 2.0 the broadcast ambiguity has been removed and now
-        # b is treaded as a single vector if and only if it is 1-dimensional;
-        # for other cases this signature must be followed
-        # (..., m, m), (..., m, n) -> (..., m, n)
-        # https://github.com/numpy/numpy/pull/25914
-        if numpy.lib.NumpyVersion(numpy.__version__) < "2.0.0":
-            self.check_x((2, 4, 4), (2, 4))
-            self.check_x((2, 3, 2, 2), (2, 3, 2))
-            self.check_x((0, 2, 2), (0, 2))
+        # Allowed since numpy 2
+        self.check_x((2, 3, 3), (3,))
+        self.check_x((2, 5, 3, 3), (3,))
 
     def check_shape(self, a_shape, b_shape, error_types):
         for xp, error_type in error_types.items():
@@ -76,12 +73,14 @@ def check_shape(self, a_shape, b_shape, error_types):
     # NumPy with OpenBLAS returns an empty array
     # while numpy with OneMKL raises LinAlgError
     @pytest.mark.skip("Undefined behavior")
+    @testing.numpy_cupy_allclose()
     def test_solve_singular_empty(self, xp):
         a = xp.zeros((3, 3))  # singular
         b = xp.empty((3, 0))  # nrhs = 0
         # LinAlgError("Singular matrix") is not raised
         return xp.linalg.solve(a, b)
 
+    @testing.with_requires("numpy>=2.0")
     def test_invalid_shape(self):
         linalg_errors = {
             numpy: numpy.linalg.LinAlgError,
@@ -96,11 +95,35 @@ def test_invalid_shape(self):
         self.check_shape((3, 3), (2,), value_errors)
         self.check_shape((3, 3), (2, 2), value_errors)
         self.check_shape((3, 3, 4), (3,), linalg_errors)
-        # Since numpy >= 2.0, this case does not raise an error
-        if numpy.lib.NumpyVersion(numpy.__version__) < "2.0.0":
-            self.check_shape((2, 3, 3), (3,), value_errors)
         self.check_shape((3, 3), (0,), value_errors)
         self.check_shape((0, 3, 4), (3,), linalg_errors)
+        self.check_shape((3, 3), (), value_errors)
+        # Not allowed since numpy 2
+        self.check_shape(
+            (0, 2, 2),
+            (
+                0,
+                2,
+            ),
+            value_errors,
+        )
+        self.check_shape(
+            (2, 4, 4),
+            (
+                2,
+                4,
+            ),
+            value_errors,
+        )
+        self.check_shape(
+            (2, 3, 2, 2),
+            (
+                2,
+                3,
+                2,
+            ),
+            value_errors,
+        )
 
 
 @testing.parameterize(
@@ -113,6 +136,7 @@ def test_invalid_shape(self):
 )
 @testing.fix_random()
 class TestTensorSolve(unittest.TestCase):
+
     @testing.for_dtypes("ifdFD")
     @testing.numpy_cupy_allclose(atol=0.02, type_check=has_support_aspect64())
     def test_tensorsolve(self, xp, dtype):
@@ -131,6 +155,7 @@ def test_tensorsolve(self, xp, dtype):
     )
 )
 class TestInv(unittest.TestCase):
+
     @testing.for_dtypes("ifdFD")
     @_condition.retry(10)
     def check_x(self, a_shape, dtype):
@@ -140,7 +165,6 @@ def check_x(self, a_shape, dtype):
         a_gpu_copy = a_gpu.copy()
         result_cpu = numpy.linalg.inv(a_cpu)
         result_gpu = cupy.linalg.inv(a_gpu)
-
         assert_dtype_allclose(result_gpu, result_cpu)
         testing.assert_array_equal(a_gpu_copy, a_gpu)
 
@@ -170,6 +194,7 @@ def test_invalid_shape(self):
 
 
 class TestInvInvalid(unittest.TestCase):
+
     @testing.for_dtypes("ifdFD")
     def test_inv(self, dtype):
         for xp in (numpy, cupy):
@@ -192,6 +217,7 @@ def test_batched_inv(self, dtype):
 
 
 class TestPinv(unittest.TestCase):
+
     @testing.for_dtypes("ifdFD")
     @_condition.retry(10)
     def check_x(self, a_shape, rcond, dtype):
@@ -234,6 +260,7 @@ def test_pinv_size_0(self):
 
 
 class TestLstsq:
+
     @testing.for_dtypes("ifdFD")
     @testing.numpy_cupy_allclose(atol=1e-3, type_check=has_support_aspect64())
     def check_lstsq_solution(
@@ -312,20 +339,18 @@ def test_invalid_shapes(self):
         self.check_invalid_shapes((3, 3), (2, 2))
         self.check_invalid_shapes((4, 3), (10, 3, 3))
 
-    # dpnp.linalg.lstsq() does not raise a FutureWarning
-    # because dpnp did not have a previous implementation of dpnp.linalg.lstsq()
-    # and there is no need to get rid of old deprecated behavior as numpy did.
-    @pytest.mark.skip("No support of deprecated behavior")
+    @testing.with_requires("numpy>=2.0")
     @testing.for_float_dtypes(no_float16=True)
     @testing.numpy_cupy_allclose(atol=1e-3)
-    def test_warn_rcond(self, xp, dtype):
+    def test_nowarn_rcond(self, xp, dtype):
         a = testing.shaped_random((3, 3), xp, dtype)
         b = testing.shaped_random((3,), xp, dtype)
-        with testing.assert_warns(FutureWarning):
-            return xp.linalg.lstsq(a, b)
+        # FutureWarning is no longer emitted
+        return xp.linalg.lstsq(a, b)
 
 
 class TestTensorInv(unittest.TestCase):
+
     @testing.for_dtypes("ifdFD")
     @_condition.retry(10)
     def check_x(self, a_shape, ind, dtype):