Use .transpose instead of .T to avoid DeprecationWarning

Author: vlad-perevezentsev

dpnp/linalg/dpnp_utils_linalg.py

@@ -2210,14 +2210,14 @@ def dpnp_lstsq(a, b, rcond=None):
 
     # Solve the least-squares solution
     # x = vh.T.conj() @ diag(s1) @ u.T.conj() @ b
-    z = (dpnp.dot(b.T, u.conj()) * s1).T
-    x = dpnp.dot(vh.T.conj(), z)
+    z = (dpnp.dot(b.transpose(), u.conj()) * s1).transpose()
+    x = dpnp.dot(vh.transpose().conj(), z)
     # Calculate squared Euclidean 2-norm for each column in b - a*x
     if m <= n or rank != n:
         resids = dpnp.empty_like(s, shape=(0,))
     else:
         e = b - a.dot(x)
-        resids = dpnp.atleast_1d(_nrm2_last_axis(e.T))
+        resids = dpnp.atleast_1d(_nrm2_last_axis(e.transpose()))
 
     return x, resids, rank, s
 

dpnp/tests/test_linalg.py

@@ -879,25 +879,33 @@ def check_einsum_sums(self, dtype, do_opt=False):
                 b = numpy.arange(n, dtype=dtype)
                 a_dp = dpnp.array(a)
                 b_dp = dpnp.array(b)
-                expected = numpy.einsum("ji,j", a.T, b.T, optimize=do_opt)
-                result = dpnp.einsum("ji,j", a_dp.T, b_dp.T, optimize=do_opt)
+                expected = numpy.einsum(
+                    "ji,j", a.transpose(), b.transpose(), optimize=do_opt
+                )
+                result = dpnp.einsum(
+                    "ji,j", a_dp.transpose(), b_dp.transpose(), optimize=do_opt
+                )
                 assert_dtype_allclose(result, expected)
 
                 result = dpnp.einsum(
-                    a_dp.T, [1, 0], b_dp.T, [1], optimize=do_opt
+                    a_dp.transpose(),
+                    [1, 0],
+                    b_dp.transpose(),
+                    [1],
+                    optimize=do_opt,
                 )
                 assert_dtype_allclose(result, expected)
 
                 c = dpnp.arange(4, dtype=a_dp.dtype)
-                args = ["ji,j", a_dp.T, b_dp.T]
+                args = ["ji,j", a_dp.transpose(), b_dp.transpose()]
                 result = dpnp.einsum(
                     *args, out=c, dtype="f4", casting="unsafe", optimize=do_opt
                 )
                 assert result is c
                 assert_dtype_allclose(result, expected)
 
                 c[...] = 0
-                args = [a_dp.T, [1, 0], b_dp.T, [1]]
+                args = [a_dp.transpose(), [1, 0], b_dp.transpose(), [1]]
                 result = dpnp.einsum(
                     *args, out=c, dtype="f4", casting="unsafe", optimize=do_opt
                 )

dpnp/tests/test_strides.py

@@ -316,8 +316,8 @@ def test_2args_in_out(func, dtype):
     b = numpy.full(sh, fill_value=0.7, dtype=dtype)
     ia, ib = dpnp.array(a), dpnp.array(b)
 
-    a, b = a[::2], b[::2].T
-    ia, ib = ia[::2], ib[::2].T
+    a, b = a[::2], b[::2].transpose()
+    ia, ib = ia[::2], ib[::2].transpose()
 
     expected = getattr(numpy, func)(a, b, out=out)
     result = getattr(dpnp, func)(ia, ib, out=iout)

dpnp/tests/test_sum.py

@@ -41,8 +41,8 @@ def test_sum(shape, dtype_in, dtype_out, transpose, keepdims, order):
     a = dpnp.asarray(a_np)
 
     if transpose:
-        a_np = a_np.T
-        a = a.T
+        a_np = a_np.transpose()
+        a = a.transpose()
 
     axes_range = list(numpy.arange(len(shape)))
     axes = [None]

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

@@ -66,7 +66,7 @@ def test_view_non_contiguous_raise(self, dtype):
     def test_view_f_contiguous(self, dtype):
         for xp in (numpy, cupy):
             a = testing.shaped_arange((2, 2, 2), xp, dtype=numpy.float32)
-            a = a.T
+            a = a.transpose()
             with pytest.raises(ValueError):
                 a.view(dtype=dtype)
 

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

@@ -252,12 +252,12 @@ def test_setitem_partial_copy(self, xp, dtype):
     @testing.numpy_cupy_array_equal()
     def test_T(self, xp):
         a = testing.shaped_arange((2, 3, 4), xp)
-        return a.T
+        return a.transpose()
 
     @testing.numpy_cupy_array_equal()
     def test_T_vector(self, xp):
         a = testing.shaped_arange((4,), xp)
-        return a.T
+        return a.transpose()
 
 
 class TestSetItemCompatBroadcast:

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

@@ -46,11 +46,11 @@ class TestDot(unittest.TestCase):
     def test_dot(self, xp, dtype_a, dtype_b):
         shape_a, shape_b = self.shape
         if self.trans_a:
-            a = testing.shaped_arange(shape_a[::-1], xp, dtype_a).T
+            a = testing.shaped_arange(shape_a[::-1], xp, dtype_a).transpose()
         else:
             a = testing.shaped_arange(shape_a, xp, dtype_a)
         if self.trans_b:
-            b = testing.shaped_arange(shape_b[::-1], xp, dtype_b).T
+            b = testing.shaped_arange(shape_b[::-1], xp, dtype_b).transpose()
         else:
             b = testing.shaped_arange(shape_b, xp, dtype_b)
         return xp.dot(a, b)
@@ -62,11 +62,11 @@ def test_dot(self, xp, dtype_a, dtype_b):
     def test_dot_with_out(self, xp, dtype_a, dtype_b, dtype_c):
         shape_a, shape_b = self.shape
         if self.trans_a:
-            a = testing.shaped_arange(shape_a[::-1], xp, dtype_a).T
+            a = testing.shaped_arange(shape_a[::-1], xp, dtype_a).transpose()
         else:
             a = testing.shaped_arange(shape_a, xp, dtype_a)
         if self.trans_b:
-            b = testing.shaped_arange(shape_b[::-1], xp, dtype_b).T
+            b = testing.shaped_arange(shape_b[::-1], xp, dtype_b).transpose()
         else:
             b = testing.shaped_arange(shape_b, xp, dtype_b)
         if a.ndim == 0 or b.ndim == 0:
@@ -206,11 +206,11 @@ class TestDotFor0Dim(unittest.TestCase):
     def test_dot(self, xp, dtype_a, dtype_b):
         shape_a, shape_b = self.shape
         if self.trans_a:
-            a = testing.shaped_arange(shape_a[::-1], xp, dtype_a).T
+            a = testing.shaped_arange(shape_a[::-1], xp, dtype_a).transpose()
         else:
             a = testing.shaped_arange(shape_a, xp, dtype_a)
         if self.trans_b:
-            b = testing.shaped_arange(shape_b[::-1], xp, dtype_b).T
+            b = testing.shaped_arange(shape_b[::-1], xp, dtype_b).transpose()
         else:
             b = testing.shaped_arange(shape_b, xp, dtype_b)
         return xp.dot(a, b)

dpnp/tests/third_party/cupy/manipulation_tests/test_basic.py

@@ -26,7 +26,7 @@ def test_copyto(self, xp, dtype):
     @testing.for_all_dtypes()
     @testing.numpy_cupy_array_equal()
     def test_copyto_different_contiguity(self, xp, dtype):
-        a = testing.shaped_arange((2, 3, 2), xp, dtype).T
+        a = testing.shaped_arange((2, 3, 2), xp, dtype).transpose()
         b = xp.empty((2, 3, 2), dtype=dtype)
         xp.copyto(b, a)
         return b

dpnp/tests/third_party/cupy/manipulation_tests/test_join.py

@@ -113,17 +113,17 @@ def test_concatenate_large_different_devices(self):
     @testing.numpy_cupy_array_equal()
     def test_concatenate_f_contiguous(self, xp, dtype):
         a = testing.shaped_arange((2, 3, 4), xp, dtype)
-        b = testing.shaped_arange((2, 3, 2), xp, dtype).T
+        b = testing.shaped_arange((2, 3, 2), xp, dtype).transpose()
         c = testing.shaped_arange((2, 3, 3), xp, dtype)
         return xp.concatenate((a, b, c), axis=-1)
 
     @testing.for_all_dtypes(name="dtype")
     @testing.numpy_cupy_array_equal()
     def test_concatenate_large_f_contiguous(self, xp, dtype):
         a = testing.shaped_arange((2, 3, 4), xp, dtype)
-        b = testing.shaped_arange((2, 3, 2), xp, dtype).T
+        b = testing.shaped_arange((2, 3, 2), xp, dtype).transpose()
         c = testing.shaped_arange((2, 3, 3), xp, dtype)
-        d = testing.shaped_arange((2, 3, 2), xp, dtype).T
+        d = testing.shaped_arange((2, 3, 2), xp, dtype).transpose()
         e = testing.shaped_arange((2, 3, 2), xp, dtype)
         return xp.concatenate((a, b, c, d, e) * 2, axis=-1)