Fix torch svd

ivy/functional/backends/jax/linear_algebra.py

@@ -361,7 +361,7 @@ def svd(
     x: JaxArray, /, *, compute_uv: bool = True, full_matrices: bool = True
 ) -> Union[JaxArray, Tuple[JaxArray, ...]]:
     if compute_uv:
-        results = namedtuple("svd", "U S Vh")
+        results = namedtuple("svd", 'U S Vh')
         U, D, VT = jnp.linalg.svd(x, full_matrices=full_matrices, compute_uv=compute_uv)
         return results(U, D, VT)
     else:

ivy/functional/backends/numpy/linear_algebra.py

@@ -291,7 +291,7 @@ def svd(
     x: np.ndarray, /, *, compute_uv: bool = True, full_matrices: bool = True
 ) -> Union[np.ndarray, Tuple[np.ndarray, ...]]:
     if compute_uv:
-        results = namedtuple("svd", "U S Vh")
+        results = namedtuple("svd", 'U S Vh')
         U, D, VT = np.linalg.svd(x, full_matrices=full_matrices, compute_uv=compute_uv)
         return results(U, D, VT)
     else:

ivy/functional/backends/paddle/linear_algebra.py

@@ -521,7 +521,7 @@ def svd(
 ) -> Union[paddle.Tensor, Tuple[paddle.Tensor, ...]]:
     ret = paddle.linalg.svd(x, full_matrices=full_matrices)
     if compute_uv:
-        results = namedtuple("svd", "U S Vh")
+        results = namedtuple("svd", 'U S Vh')
         return results(*ret)
     else:
         results = namedtuple("svd", "S")

ivy/functional/backends/tensorflow/linear_algebra.py

@@ -534,8 +534,7 @@ def svd(
     compute_uv: bool = True,
 ) -> Union[Union[tf.Tensor, tf.Variable], Tuple[Union[tf.Tensor, tf.Variable], ...]]:
     if compute_uv:
-        results = namedtuple("svd", "U S Vh")
-
+        results = namedtuple("svd", 'U S Vh')
         batch_shape = tf.shape(x)[:-2]
         num_batch_dims = len(batch_shape)
         transpose_dims = list(range(num_batch_dims)) + [

ivy/functional/backends/torch/linear_algebra.py

@@ -414,16 +414,13 @@ def svd(
     x: torch.Tensor, /, *, full_matrices: bool = True, compute_uv: bool = True
 ) -> Union[torch.Tensor, Tuple[torch.Tensor, ...]]:
     if compute_uv:
-        results = namedtuple("svd", "U S Vh")
-
+        results = namedtuple("svd", 'U S Vh')
         U, D, VT = torch.linalg.svd(x, full_matrices=full_matrices)
         return results(U, D, VT)
     else:
         results = namedtuple("svd", "S")
-        svd = torch.linalg.svd(x, full_matrices=full_matrices)
-        # torch.linalg.svd returns a tuple with U, S, and Vh
-        D = svd[1]
-        return results(D)
+        s = torch.linalg.svdvals(x)
+        return results(s)
 
 
 @with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, backend_version)

ivy/functional/frontends/jax/lax/linalg.py

@@ -1,6 +1,6 @@
 import ivy
 from ivy.functional.frontends.jax.func_wrapper import to_ivy_arrays_and_back
-from ivy.func_wrapper import with_unsupported_dtypes
+from ivy.func_wrapper import with_unsupported_dtypes, with_supported_dtypes
 
 
 @to_ivy_arrays_and_back
@@ -44,7 +44,29 @@ def qr(x, /, *, full_matrices=False):
 
 
 @to_ivy_arrays_and_back
-def svd(x, /, *, full_matrices=True, compute_uv=True):
-    if not compute_uv:
-        return ivy.svdvals(x)
-    return ivy.svd(x, full_matrices=full_matrices)
+@with_supported_dtypes(
+    {
+        "0.4.14 and below": (
+            "float64",
+            "float32",
+            "half",
+            "complex32",
+            "complex64",
+            "complex128",
+        )
+    },
+    "jax",
+)
+def svd(x, /, *, full_matrices=True, compute_uv=True, subset_by_index=None):
+    # TODO: handle subset_by_index
+    if ivy.is_complex_dtype(x.dtype):
+        d = ivy.complex128
+    else:
+        d = ivy.float64
+    if compute_uv:
+        svd = ivy.svd(x, compute_uv=compute_uv, full_matrices=full_matrices)
+        return tuple(
+            [ivy.astype(svd.U, d), ivy.astype(svd.S, d), ivy.astype(svd.Vh, d)]
+        )
+    else:
+        return ivy.astype(ivy.svdvals(x), ivy.float64)

ivy/functional/frontends/jax/numpy/linalg.py

@@ -120,10 +120,32 @@ def solve(a, b):
 
 
 @to_ivy_arrays_and_back
+@with_supported_dtypes(
+    {
+        "0.4.24 and below": (
+            "float64",
+            "float32",
+            "half",
+            "complex32",
+            "complex64",
+            "complex128",
+        )
+    },
+    "jax",
+)
 def svd(a, /, *, full_matrices=True, compute_uv=True, hermitian=None):
-    if not compute_uv:
-        return ivy.svdvals(a)
-    return ivy.svd(a, full_matrices=full_matrices)
+    # TODO: handle hermitian
+    if ivy.is_complex_dtype(a.dtype):
+        d = ivy.complex128
+    else:
+        d = ivy.float64
+    if compute_uv:
+        svd = ivy.svd(a, compute_uv=compute_uv, full_matrices=full_matrices)
+        return tuple(
+            [ivy.astype(svd.U, d), ivy.astype(svd.S, d), ivy.astype(svd.Vh, d)]
+        )
+    else:
+        return ivy.astype(ivy.svdvals(a), ivy.float64)
 
 
 @to_ivy_arrays_and_back

ivy/functional/frontends/numpy/linalg/decompositions.py

@@ -1,6 +1,7 @@
 # local
 import ivy
 from ivy.functional.frontends.numpy.func_wrapper import to_ivy_arrays_and_back
+from ivy.func_wrapper import with_supported_dtypes
 
 
 @to_ivy_arrays_and_back
@@ -14,6 +15,22 @@ def qr(a, mode="reduced"):
 
 
 @to_ivy_arrays_and_back
+@with_supported_dtypes(
+    {
+        "1.26.3 and below": (
+            "float64",
+            "float32",
+            "half",
+            "complex32",
+            "complex64",
+            "complex128",
+        )
+    },
+    "numpy",
+)
 def svd(a, full_matrices=True, compute_uv=True, hermitian=False):
-    # Todo: conpute_uv and hermitian handling
-    return ivy.svd(a, full_matrices=full_matrices, compute_uv=compute_uv)
+    # Todo: hermitian handling
+    if compute_uv:
+        return ivy.svd(a, full_matrices=full_matrices, compute_uv=compute_uv)
+    else:
+        return ivy.astype(ivy.svdvals(a), a.dtype)

ivy/functional/frontends/tensorflow/linalg.py

@@ -357,8 +357,32 @@ def solve(matrix, rhs, /, *, adjoint=False, name=None):
 
 
 @to_ivy_arrays_and_back
+@with_supported_dtypes(
+    {
+        "2.15.0 and below": (
+            "float32",
+            "float64",
+            "half",
+            "complex32",
+            "complex64",
+            "complex128",
+        )
+    },
+    "tensorflow",
+)
 def svd(a, /, *, full_matrices=False, compute_uv=True, name=None):
-    return ivy.svd(a, compute_uv=compute_uv, full_matrices=full_matrices)
+    if ivy.is_complex_dtype(a.dtype):
+        d = ivy.complex128
+    else:
+        d = ivy.float64
+    if compute_uv:
+        svd = ivy.svd(a, compute_uv=compute_uv, full_matrices=full_matrices)
+        return tuple(
+            [ivy.astype(svd.S, d), ivy.astype(svd.U, d), ivy.astype(svd.Vh.T, d)]
+        )
+    else:
+        svd = ivy.svd(a, compute_uv=compute_uv, full_matrices=full_matrices)
+        return ivy.astype(svd.S, d)
 
 
 @to_ivy_arrays_and_back

ivy/functional/frontends/tensorflow/raw_ops.py

@@ -832,12 +832,24 @@ def Sum(*, input, axis, keep_dims=False, name="Sum"):
 
 
 @with_supported_dtypes(
-    {"2.15.0 and below": ("float64", "float128", "halfcomplex64", "complex128")},
+    {
+        "2.15.0 and below": (
+            "float64",
+            "float32",
+            "half",
+            "complex32",
+            "complex64",
+            "complex128",
+        )
+    },
     "tensorflow",
 )
 @to_ivy_arrays_and_back
-def Svd(*, input, full_matrices=False, compute_uv=True, name=None):
-    return ivy.svd(input, compute_uv=compute_uv, full_matrices=full_matrices)
+def Svd(*, input, full_matrices=False, compute_uv=True, name="Svd"):
+    ret = ivy.svd(input, compute_uv=compute_uv, full_matrices=full_matrices)
+    if not compute_uv:
+        return (ret.S, None, None)
+    return (ret.S, ret.U, ivy.adjoint(ret.Vh))
 
 
 @to_ivy_arrays_and_back

ivy/functional/frontends/torch/blas_and_lapack_ops.py

@@ -1,7 +1,8 @@
 # global
 import ivy
-from ivy.func_wrapper import with_unsupported_dtypes
+from ivy.func_wrapper import with_unsupported_dtypes, with_supported_dtypes
 import ivy.functional.frontends.torch as torch_frontend
+from collections import namedtuple
 from ivy.functional.frontends.torch.func_wrapper import to_ivy_arrays_and_back
 
 
@@ -189,13 +190,36 @@ def slogdet(A, *, out=None):
     return torch_frontend.linalg.slogdet(A, out=out)
 
 
+@with_supported_dtypes(
+    {
+        "2.2 and below": (
+            "float64",
+            "float32",
+            "half",
+            "complex32",
+            "complex64",
+            "complex128",
+        )
+    },
+    "torch",
+)
 @to_ivy_arrays_and_back
 def svd(input, some=True, compute_uv=True, *, out=None):
-    # TODO: add compute_uv
-    if some:
-        ret = ivy.svd(input, full_matrices=False)
+    retu = ivy.svd(input, full_matrices=not some, compute_uv=compute_uv)
+    results = namedtuple("svd", "U S V")
+    if compute_uv:
+        ret = results(retu[0], retu[1], ivy.adjoint(retu[2]))
     else:
-        ret = ivy.svd(input, full_matrices=True)
+        shape = list(input.shape)
+        shape1 = shape
+        shape2 = shape
+        shape1[-2] = shape[-1]
+        shape2[-1] = shape[-2]
+        ret = results(
+            ivy.zeros(shape1, device=input.device, dtype=input.dtype),
+            ivy.astype(retu[0], input.dtype),
+            ivy.zeros(shape2, device=input.device, dtype=input.dtype),
+        )
     if ivy.exists(out):
         return ivy.inplace_update(out, ret)
     return ret

ivy/functional/frontends/torch/linalg.py

@@ -345,11 +345,30 @@ def solve_ex(A, B, *, left=True, check_errors=False, out=None):
 
 @to_ivy_arrays_and_back
 @with_supported_dtypes(
-    {"2.2 and below": ("float32", "float64", "complex32", "complex64")}, "torch"
+    {
+        "2.2 and below": (
+            "float64",
+            "float32",
+            "half",
+            "complex32",
+            "complex64",
+            "complex128",
+        )
+    },
+    "torch",
 )
 def svd(A, /, *, full_matrices=True, driver=None, out=None):
-    # TODO: add handling for driver and out
-    return ivy.svd(A, compute_uv=True, full_matrices=full_matrices)
+    # TODO: add handling for driver
+    USVh = ivy.svd(A, compute_uv=True, full_matrices=full_matrices)
+    if ivy.is_complex_dtype(A.dtype):
+        d = ivy.complex64
+    else:
+        d = ivy.float32
+    nt = namedtuple("svd", "U S Vh")
+    ret = nt(ivy.astype(USVh.U, d), ivy.astype(USVh.S, d), ivy.astype(USVh.Vh, d))
+    if ivy.exists(out):
+        return ivy.inplace_update(out, ret)
+    return ret
 
 
 @to_ivy_arrays_and_back

ivy/functional/frontends/torch/tensor.py

@@ -2090,7 +2090,19 @@ def adjoint(self):
     def conj(self):
         return torch_frontend.conj(self)
 
-    @with_unsupported_dtypes({"2.2 and below": ("float16", "bfloat16")}, "torch")
+    @with_supported_dtypes(
+        {
+            "2.2 and below": (
+                "float64",
+                "float32",
+                "half",
+                "complex32",
+                "complex64",
+                "complex128",
+            )
+        },
+        "torch",
+    )
     def svd(self, some=True, compute_uv=True, *, out=None):
         return torch_frontend.svd(self, some=some, compute_uv=compute_uv, out=out)
 

ivy/functional/ivy/linear_algebra.py

@@ -2130,15 +2130,12 @@ def svd(
         If ``True`` then left and right singular vectors will be computed and returned
         in ``U`` and ``Vh``, respectively. Otherwise, only the singular values will be
         computed, which can be significantly faster.
-    .. note::
-        with backend set as torch, svd with still compute left and right singular
-        vectors irrespective of the value of compute_uv, however Ivy will still
-        only return the singular values.
 
     Returns
     -------
     .. note::
         once complex numbers are supported, each square matrix must be Hermitian.
+        In addition, the return will be a namedtuple ``(S)`` when compute_uv is ``False``
 
     ret
         a namedtuple ``(U, S, Vh)`` whose