# LU-class: LU (dense) Matrix Decompositions In Matrix: Sparse and Dense Matrix Classes and Methods

 LU-class 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`.

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")))
```

Matrix documentation built on Nov. 11, 2022, 9:06 a.m.