Skip to main content
`Ctrl`+`K`
scipy.linalg.

# svd

scipy.linalg.svd(a, full_matrices=True, compute_uv=True, overwrite_a=False, check_finite=True, lapack_driver='gesdd')

  Singular Value Decomposition.

  Factorizes the matrix a into two unitary matrices `U` and `Vh`, and a 1-D array `s` of singular values (real, non-negative) such that `a == U @ S @ Vh`, where `S` is a suitably shaped matrix of zeros with main diagonal `s`.

  Parameters:
    a(…, M, N) array_like

      Matrix to decompose.

    full_matrices bool, optional

      If True (default), U and Vh are of shape `(M, M)`, `(N, N)`. If False, the shapes are `(M, K)` and `(K, N)`, where `K = min(M, N)`.

    compute_uv bool, optional

      Whether to compute also `U` and `Vh` in addition to `s`. Default is True.

    overwrite_a bool, optional

      Whether to overwrite data in a (may improve performance). Default is False. See overwrite_* arguments for details.

    check_finite bool, optional

      Whether to check that the input matrix contains only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs.

    lapack_driver{‘gesdd’, ‘gesvd’}, optional

      Whether to use the more efficient divide-and-conquer approach (`'gesdd'`) or general rectangular approach (`'gesvd'`) to compute the SVD. MATLAB and Octave use the `'gesvd'` approach. Default is `'gesdd'`.

  Returns:
    U ndarray

      Unitary matrix having left singular vectors as columns. Of shape `(M, M)` or `(M, K)`, depending on full_matrices. Only present when `compute_uv=True`.

    s ndarray

      The singular values, sorted in non-increasing order. Of shape (K,), with `K = min(M, N)`.

    Vh ndarray

      Unitary matrix having right singular vectors as rows. Of shape `(N, N)` or `(K, N)` depending on full_matrices. Only present when `compute_uv=True`.

  Raises:
    LinAlgError

      If SVD computation does not converge.

  See also

  `svdvals`

    Compute singular values of a matrix.

  `diagsvd`

    Construct the Sigma matrix, given the vector s.

  Notes

  The array argument of this function, a, may have additional “batch” dimensions prepended to the core shape. In this case, the array is treated as a batch of lower-dimensional slices; see Batched Linear Operations for details.

  Examples

      >>> import numpy as np
      >>> from scipy import linalg
      >>> rng = np.random.default_rng()
      >>> m, n = 9, 6
      >>> a = rng.standard_normal((m, n)) + 1.j*rng.standard_normal((m, n))
      >>> U, s, Vh = linalg.svd(a)
      >>> U.shape,  s.shape, Vh.shape
      ((9, 9), (6,), (6, 6))

  Reconstruct the original matrix from the decomposition:

      >>> sigma = np.zeros((m, n))
      >>> for i in range(min(m, n)):
      ...     sigma[i, i] = s[i]
      >>> a1 = U @ sigma @ Vh
      >>> np.allclose(a, a1)
      True

  Alternatively, use `full_matrices=False` (notice that the shape of `U` is then `(m, n)` instead of `(m, m)`):

      >>> U, s, Vh = linalg.svd(a, full_matrices=False)
      >>> U.shape, s.shape, Vh.shape
      ((9, 6), (6,), (6, 6))
      >>> S = np.diag(s)
      >>> np.allclose(a, U @ S @ Vh)
      True

      >>> s2 = linalg.svd(a, compute_uv=False)
      >>> np.allclose(s, s2)
      True

  If the input matrix has more than two dimensions, it is interpreted as a batch of two-dimensional matrices:

      >>> aa = np.stack((a, 2*a))
      >>> linalg.svdvals(aa)[0] == linalg.svdvals(a)
      array([ True,  True,  True,  True,  True,  True])
      >>> linalg.svdvals(aa)[1] == 2 * linalg.svdvals(a)
      array([ True,  True,  True,  True,  True,  True])