Compute the singular-value decomposition of a rectangular matrix.

`svd(x, nu = min(n, p), nv = min(n, p), LINPACK = FALSE)`La.svd(x, nu = min(n, p), nv = min(n, p))

x

a numeric or complex matrix whose SVD decomposition is to be computed. Logical matrices are coerced to numeric.

nu

the number of left singular vectors to be computed.
This must between `0`

and `n = nrow(x)`

.

nv

the number of right singular vectors to be computed.
This must be between `0`

and `p = ncol(x)`

.

LINPACK

logical. Defunct and ignored.

The SVD decomposition of the matrix as computed by LAPACK, $$
\bold{X = U D V'},$$ where \(\bold{U}\) and \(\bold{V}\) are
orthogonal, \(\bold{V'}\) means *V transposed* (and conjugated
for complex input), and \(\bold{D}\) is a diagonal matrix with the
(non-negative) singular values \(D_{ii}\) in decreasing
order. Equivalently, \(\bold{D = U' X V}\), which is verified in
the examples.

The returned value is a list with components

a vector containing the singular values of `x`

, of
length `min(n, p)`

, sorted decreasingly.

a matrix whose columns contain the left singular vectors of
`x`

, present if `nu > 0`

. Dimension `c(n, nu)`

.

a matrix whose columns contain the right singular vectors of
`x`

, present if `nv > 0`

. Dimension `c(p, nv)`

.

Recall that the singular vectors are only defined up to sign (a constant of modulus one in the complex case). If a left singular vector has its sign changed, changing the sign of the corresponding right vector gives an equivalent decomposition.

For La.svd the return value replaces v by vt, the (conjugated if complex) transpose of v.

The singular value decomposition plays an important role in many
statistical techniques. `svd`

and `La.svd`

provide two
interfaces which differ in their return values.

Computing the singular vectors is the slow part for large matrices.
The computation will be more efficient if both `nu <= min(n, p)`

and `nv <= min(n, p)`

, and even more so if both are zero.

Unsuccessful results from the underlying LAPACK code will result in an
error giving a positive error code (most often `1`

): these can
only be interpreted by detailed study of the FORTRAN code but mean
that the algorithm failed to converge.

Anderson. E. and ten others (1999)
*LAPACK Users' Guide*. Third Edition. SIAM.
Available on-line at
http://www.netlib.org/lapack/lug/lapack_lug.html.

The ‘Singular-value decomposition’ Wikipedia article.

Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988)
*The New S Language*.
Wadsworth & Brooks/Cole.

```
# NOT RUN {
hilbert <- function(n) { i <- 1:n; 1 / outer(i - 1, i, "+") }
X <- hilbert(9)[, 1:6]
(s <- svd(X))
D <- diag(s$d)
s$u %*% D %*% t(s$v) # X = U D V'
t(s$u) %*% X %*% s$v # D = U' X V
# }
```

Run the code above in your browser using DataCamp Workspace