Documentation

### This is machine translation

Mouseover text to see original. Click the button below to return to the English version of the page.

# svd

Singular value decomposition

## Syntax

``s = svd(A)``
``````[U,S,V] = svd(A)``````
``````[U,S,V] = svd(A,'econ')``````
``````[U,S,V] = svd(A,0)``````

## 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

``````[U,S,V] = svd(A,'econ')``` produces an economy-size decomposition of `m`-by-`n` matrix `A`:`m > n` — Only the first `n` columns of `U` are computed, and `S` is `n`-by-`n`.`m = n` — `svd(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

``````[U,S,V] = svd(A,0)``` produces a different economy-size decomposition of `m`-by-`n` matrix `A`:`m > n` — `svd(A,0)` is equivalent to `svd(A,'econ')`.`m <= n` — `svd(A,0)` is equivalent to `svd(A)`.```

## 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 full 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 full 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'`.

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 Arguments

collapse all

Singular values, returned as a column vector. The singular values are nonnegative real numbers listed in decreasing order.

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 ${U}^{H}U={I}_{n}$.

• For full decompositions, `svd(A)` returns `U` as an `m`-by-`m` unitary matrix satisfying $U{U}^{H}={U}^{H}U={I}_{m}$. 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. The diagonal elements of `S` are nonnegative singular values in decreasing order. The size of `S` is as follows:

• For an `m`-by-`n` matrix `A`, the economy-sized decomposition `svd(A,'econ')` returns `S` as a square matrix of order `min([m,n])`.

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

• If `m > n`, then `svd(A,0)` returns `S` as a square matrix of order `min([m,n])`.

• If `m < n`, then `svd(A,0)` returns `S` with the same size as `A`.

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 ${V}^{H}V={I}_{m}$.

• For full decompositions, `svd(A)` returns `V` as an `n`-by-`n` unitary matrix satisfying $V{V}^{H}={V}^{H}V={I}_{n}$. 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'`.