# svd

Singular value decomposition

## Syntax

``S = svd(A)``
``````[U,S,V] = svd(A)``````
``````[___] = svd(A,"econ")``````
``[___] = svd(A,0)``
``[___] = svd(___,outputForm)``

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

````[___] = 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)`.The use of this syntax is not recommended. Use the `"econ"` option instead.```
````[___] = 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 decomposition `svd(A,"econ")` computes 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 complete 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 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`.

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.

Depending on whether you specify one output or multiple outputs, `svd` can return different singular values that are still numerically accurate.

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 complete 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'`.

## Version History

Introduced before R2006a

expand all