R: LU (dense) Matrix Decompositions

LU-class {Matrix} | R Documentation

## LU (dense) Matrix Decompositions

### Description

The `"LU"` class is the virtual class of LU decompositions of real matrices. `"denseLU"` the class of LU decompositions of dense real matrices.

### Details

The decomposition is of the form

A = P L U

where typically all matrices are of size n by n, and the matrix P is a permutation matrix, L is lower triangular and U is upper triangular (both of class `dtrMatrix`).

Note that the dense decomposition is also implemented for a m by n matrix A, when m != n.

If m < n (“wide case”), U is m by n, and hence not triangular.
If m > n (“long case”), L is m by n, and hence not triangular.

### Objects from the Class

Objects can be created by calls of the form `new("denseLU", ...)`. More commonly the objects are created explicitly from calls of the form `lu(mm)` where `mm` is an object that inherits from the `"dgeMatrix"` class or as a side-effect of other functions applied to `"dgeMatrix"` objects.

### Extends

`"LU"` directly extends the virtual class `"MatrixFactorization"`.

`"denseLU"` directly extends `"LU"`.

### Slots

`x`:

  object of class `"numeric"`. The `"L"` (unit lower triangular) and `"U"` (upper triangular) factors of the original matrix. These are stored in a packed format described in the Lapack manual, and can retrieved by the `expand()` method, see below.

`perm`:

  Object of class `"integer"` - a vector of length `min(Dim)` that describes the permutation applied to the rows of the original matrix. The contents of this vector are described in the Lapack manual.

`Dim`:

  the dimension of the original matrix; inherited from class `MatrixFactorization` .

### Methods

expand

  `signature(x = "denseLU")`: Produce the `"L"` and `"U"` (and `"P"`) factors as a named list of matrices, see also the example below.

solve

  `signature(a = "denseLU", b = "missing")`: Compute the inverse of A, A^(-1), `solve(A)` using the LU decomposition, see also `solve-methods`.

### See Also

class `sparseLU` for LU decompositions of sparse matrices; further, class `dgeMatrix` and functions `lu`, `expand`.

### Examples

    set.seed(1)
    mm <- Matrix(round(rnorm(9),2), nrow = 3)
    mm
    str(lum <- lu(mm))
    elu <- expand(lum)
    elu # three components: "L", "U", and "P", the permutation
    elu$L %*% elu$U
    (m2 <- with(elu, P %*% L %*% U)) # the same as 'mm'
    stopifnot(all.equal(as(mm, "matrix"),
                        as(m2, "matrix")))

[Package Matrix version 1.1-4 Index]