Main Content

svd

Singular value decomposition

Description

example

S = svd(A) returns the singular values of matrix A in descending order.

example

[U,S,V] = svd(A) performs a singular value decomposition of matrix A, such that A = U*S*V'.

example

[___] = svd(A,"econ") produces an economy-size decomposition of A using either of the previous output argument combinations. If A is an m-by-n matrix, then:

  • m > n — Only the first n columns of U are computed, and S is n-by-n.

  • m = nsvd(A,"econ") is equivalent to svd(A).

  • m < n — Only the first m columns of V are computed, and S is m-by-m.

The economy-size decomposition removes extra rows or columns of zeros from the diagonal matrix of singular values, S, along with the columns in either U or V that multiply those zeros in the expression A = U*S*V'. Removing these zeros and columns can improve execution time and reduce storage requirements without compromising the accuracy of the decomposition.

example

[___] = svd(A,0) produces a different economy-size decomposition of m-by-n matrix A:

  • m > nsvd(A,0) is equivalent to svd(A,"econ").

  • m <= nsvd(A,0) is equivalent to svd(A).

[___] = svd(___,outputForm) optionally specifies the output format for the singular values. You can use this option with any of the previous input or output argument combinations. Specify "vector" to return the singular values as a column vector, or "matrix" to return the singular values in a diagonal matrix.

Examples

collapse all

Compute the singular values of a full rank matrix.

A = [1 0 1; -1 -2 0; 0 1 -1]
A = 3×3

     1     0     1
    -1    -2     0
     0     1    -1

s = svd(A)
s = 3×1

    2.4605
    1.6996
    0.2391

Find the singular value decomposition of a rectangular matrix A.

A = [1 2; 3 4; 5 6; 7 8]
A = 4×2

     1     2
     3     4
     5     6
     7     8

[U,S,V] = svd(A)
U = 4×4

   -0.1525   -0.8226   -0.3945   -0.3800
   -0.3499   -0.4214    0.2428    0.8007
   -0.5474   -0.0201    0.6979   -0.4614
   -0.7448    0.3812   -0.5462    0.0407

S = 4×2

   14.2691         0
         0    0.6268
         0         0
         0         0

V = 2×2

   -0.6414    0.7672
   -0.7672   -0.6414

Confirm the relation A = U*S*V', within machine precision.

U*S*V'
ans = 4×2

    1.0000    2.0000
    3.0000    4.0000
    5.0000    6.0000
    7.0000    8.0000

Calculate the complete and economy-size decompositions of a rectangular matrix.

A = [1 2; 3 4; 5 6; 7 8]
A = 4×2

     1     2
     3     4
     5     6
     7     8

[U,S,V] = svd(A)
U = 4×4

   -0.1525   -0.8226   -0.3945   -0.3800
   -0.3499   -0.4214    0.2428    0.8007
   -0.5474   -0.0201    0.6979   -0.4614
   -0.7448    0.3812   -0.5462    0.0407

S = 4×2

   14.2691         0
         0    0.6268
         0         0
         0         0

V = 2×2

   -0.6414    0.7672
   -0.7672   -0.6414

[U,S,V] = svd(A,"econ")
U = 4×2

   -0.1525   -0.8226
   -0.3499   -0.4214
   -0.5474   -0.0201
   -0.7448    0.3812

S = 2×2

   14.2691         0
         0    0.6268

V = 2×2

   -0.6414    0.7672
   -0.7672   -0.6414

Since A is 4-by-2, svd(A,"econ") returns fewer columns in U and fewer rows in S compared to a complete decomposition. Extra rows of zeros in S are excluded, along with the corresponding columns in U that would multiply with those zeros in the expression A = U*S*V'.

Create a 6-by-6 magic square matrix and calculate the SVD. By default, svd returns the singular values in a diagonal matrix when you specify multiple outputs.

A = magic(6);
[U,S,V] = svd(A)
U = 6×6

   -0.4082    0.5574    0.0456   -0.4182    0.3092    0.5000
   -0.4082   -0.2312    0.6301   -0.2571   -0.5627   -0.0000
   -0.4082    0.4362    0.2696    0.5391    0.1725   -0.5000
   -0.4082   -0.3954   -0.2422   -0.4590    0.3971   -0.5000
   -0.4082    0.1496   -0.6849    0.0969   -0.5766   -0.0000
   -0.4082   -0.5166   -0.0182    0.4983    0.2604    0.5000

S = 6×6

  111.0000         0         0         0         0         0
         0   50.6802         0         0         0         0
         0         0   34.3839         0         0         0
         0         0         0   10.1449         0         0
         0         0         0         0    5.5985         0
         0         0         0         0         0    0.0000

V = 6×6

   -0.4082    0.6234   -0.3116    0.2495    0.2511   -0.4714
   -0.4082   -0.6282    0.3425    0.1753    0.2617   -0.4714
   -0.4082   -0.4014   -0.7732   -0.0621   -0.1225    0.2357
   -0.4082    0.1498    0.2262   -0.4510    0.5780    0.4714
   -0.4082    0.1163    0.2996    0.6340   -0.3255    0.4714
   -0.4082    0.1401    0.2166   -0.5457   -0.6430   -0.2357

Specify the "vector" option to return the singular values in a column vector.

[U,S,V] = svd(A,"vector")
U = 6×6

   -0.4082    0.5574    0.0456   -0.4182    0.3092    0.5000
   -0.4082   -0.2312    0.6301   -0.2571   -0.5627   -0.0000
   -0.4082    0.4362    0.2696    0.5391    0.1725   -0.5000
   -0.4082   -0.3954   -0.2422   -0.4590    0.3971   -0.5000
   -0.4082    0.1496   -0.6849    0.0969   -0.5766   -0.0000
   -0.4082   -0.5166   -0.0182    0.4983    0.2604    0.5000

S = 6×1

  111.0000
   50.6802
   34.3839
   10.1449
    5.5985
    0.0000

V = 6×6

   -0.4082    0.6234   -0.3116    0.2495    0.2511   -0.4714
   -0.4082   -0.6282    0.3425    0.1753    0.2617   -0.4714
   -0.4082   -0.4014   -0.7732   -0.0621   -0.1225    0.2357
   -0.4082    0.1498    0.2262   -0.4510    0.5780    0.4714
   -0.4082    0.1163    0.2996    0.6340   -0.3255    0.4714
   -0.4082    0.1401    0.2166   -0.5457   -0.6430   -0.2357

If you specify one output argument, such as S = svd(A), then svd switches behavior to return the singular values in a column vector by default. In that case, you can specify the "matrix" option to return the singular values as a diagonal matrix.

Use the results of the singular value decomposition to determine the rank, column space, and null space of a matrix.

A = [2 0 2; 0 1 0; 0 0 0]
A = 3×3

     2     0     2
     0     1     0
     0     0     0

[U,S,V] = svd(A)
U = 3×3

     1     0     0
     0     1     0
     0     0     1

S = 3×3

    2.8284         0         0
         0    1.0000         0
         0         0         0

V = 3×3

    0.7071         0   -0.7071
         0    1.0000         0
    0.7071         0    0.7071

Calculate the rank using the number of nonzero singular values.

s = diag(S);
rank_A = nnz(s)
rank_A = 2

Compute an orthonormal basis for the column space of A using the columns of U that correspond to nonzero singular values.

column_basis = U(:,logical(s))
column_basis = 3×2

     1     0
     0     1
     0     0

Compute an orthonormal basis for the null space of A using the columns of V that correspond to singular values equal to zero.

null_basis = V(:,~s)
null_basis = 3×1

   -0.7071
         0
    0.7071

The functions rank, orth, and null provide convenient ways to calculate these quantities.

Input Arguments

collapse all

Input matrix. A can be either square or rectangular in size.

Data Types: single | double
Complex Number Support: Yes

Output format of singular values, specified as one of these values:

  • "vector"S is a column vector. This is the default behavior when you specify one output, S = svd(X).

  • "matrix"S is a diagonal matrix. This is the default behavior when you specify multiple outputs, [U,S,V] = svd(X).

Example: [U,S,V] = svd(X,"vector") returns S as a column vector instead of a diagonal matrix.

Example: S = svd(X,"matrix") returns S as a diagonal matrix instead of a column vector.

Data Types: char | string

Output Arguments

collapse all

Left singular vectors, returned as the columns of a matrix.

  • For an m-by-n matrix A with m > n, the economy-sized decompositions svd(A,"econ") and svd(A,0) compute only the first n columns of U. In this case, the columns of U are orthogonal and U is an m-by-n matrix that satisfies UHU=In.

  • For complete decompositions, svd(A) returns U as an m-by-m unitary matrix satisfying UUH=UHU=Im. The columns of U that correspond to nonzero singular values form a set of orthonormal basis vectors for the range of A.

Different machines and releases of MATLAB® can produce different singular vectors that are still numerically accurate. Corresponding columns in U and V can flip their signs, since this does not affect the value of the expression A = U*S*V'.

Singular values, returned as a diagonal matrix or column vector. The singular values are nonnegative and returned in decreasing order.

If A is an m-by-n matrix, and S is a diagonal matrix, then the size of S is as follows:

  • The economy-sized decomposition svd(A,"econ") returns S as a square matrix of order min([m,n]).

  • For complete decompositions, svd(A) returns S with the same size as A.

  • For svd(A,0):

    • If m > n, then S is a square matrix of order min([m,n]).

    • If m < n, then S has the same size as A.

Additionally, the singular values in S are returned in a column vector or diagonal matrix depending on how you call svd and whether you specify the outputForm option:

  • If you call svd with one output or specify the "vector" option, then S is a column vector.

  • If you call svd with multiple outputs or specify the "matrix" option, then S is a diagonal matrix.

Right singular vectors, returned as the columns of a matrix.

  • For an m-by-n matrix A with m < n, the economy decomposition svd(A,"econ") computes only the first m columns of V. In this case, the columns of V are orthogonal and V is an n-by-m matrix that satisfies VHV=Im.

  • For complete decompositions, svd(A) returns V as an n-by-n unitary matrix satisfying VVH=VHV=In. The columns of V that do not correspond to nonzero singular values form a set of orthonormal basis vectors for the null space of A.

Different machines and releases of MATLAB can produce different singular vectors that are still numerically accurate. Corresponding columns in U and V can flip their signs, since this does not affect the value of the expression A = U*S*V'.

Compatibility Considerations

expand all

Behavior changed in R2021b

Extended Capabilities

Introduced before R2006a