denseLU-class {Matrix} | R Documentation |

`denseLU`

is the class of dense, row-pivoted LU factorizations
of `m \times n`

real matrices `A`

,
having the general form

`P_{1} A = L U`

or (equivalently)

`A = P_{1}' L U`

where
`P_{1}`

is an `m \times m`

permutation matrix,
`L`

is an `m \times \min(m,n)`

unit lower trapezoidal matrix, and
`U`

is a `\min(m,n) \times n`

upper trapezoidal matrix. If `m = n`

, then the factors
`L`

and `U`

are triangular.

`Dim`

,`Dimnames`

inherited from virtual class

`MatrixFactorization`

.`x`

a numeric vector of length

`prod(Dim)`

storing the triangular`L`

and`U`

factors together in a packed format. The details of the representation are specified by the manual for LAPACK routine`dgetrf`

.`perm`

an integer vector of length

`min(Dim)`

specifying the permutation`P_{1}`

as a product of transpositions. The corresponding permutation vector can be obtained as`asPerm(perm)`

.

Class `LU`

, directly.
Class `MatrixFactorization`

, by class
`LU`

, distance 2.

Objects can be generated directly by calls of the form
`new("denseLU", ...)`

, but they are more typically obtained
as the value of `lu(x)`

for `x`

inheriting from
`denseMatrix`

(often `dgeMatrix`

).

`coerce`

`signature(from = "denseLU", to = "dgeMatrix")`

: returns a`dgeMatrix`

with the dimensions of the factorized matrix`A`

, equal to`L`

below the diagonal and equal to`U`

on and above the diagonal.`determinant`

`signature(from = "denseLU", logarithm = "logical")`

: computes the determinant of the factorized matrix`A`

or its logarithm.`expand`

`signature(x = "denseLU")`

: see`expand-methods`

.`expand1`

`signature(x = "denseLU")`

: see`expand1-methods`

.`expand2`

`signature(x = "denseLU")`

: see`expand2-methods`

.`solve`

`signature(a = "denseLU", b = "missing")`

: see`solve-methods`

.

The LAPACK source code, including documentation; see https://netlib.org/lapack/double/dgetrf.f.

Golub, G. H., & Van Loan, C. F. (2013).
*Matrix computations* (4th ed.).
Johns Hopkins University Press.
doi:10.56021/9781421407944

Class `sparseLU`

for sparse LU factorizations.

Class `dgeMatrix`

.

Generic functions `lu`

,
`expand1`

and `expand2`

.

```
showClass("denseLU")
set.seed(1)
n <- 3L
(A <- Matrix(round(rnorm(n * n), 2L), n, n))
## With dimnames, to see that they are propagated :
dimnames(A) <- dn <- list(paste0("r", seq_len(n)),
paste0("c", seq_len(n)))
(lu.A <- lu(A))
str(e.lu.A <- expand2(lu.A), max.level = 2L)
## Underlying LAPACK representation
(m.lu.A <- as(lu.A, "dgeMatrix")) # which is L and U interlaced
stopifnot(identical(as(m.lu.A, "matrix"), `dim<-`(lu.A@x, lu.A@Dim)))
ae1 <- function(a, b, ...) all.equal(as(a, "matrix"), as(b, "matrix"), ...)
ae2 <- function(a, b, ...) ae1(unname(a), unname(b), ...)
## A ~ P1' L U in floating point
stopifnot(exprs = {
identical(names(e.lu.A), c("P1.", "L", "U"))
identical(e.lu.A[["P1."]],
new( "pMatrix", Dim = c(n, n), Dimnames = c(dn[1L], list(NULL)),
margin = 1L, perm = invertPerm(asPerm(lu.A@perm))))
identical(e.lu.A[["L"]],
new("dtrMatrix", Dim = c(n, n), Dimnames = list(NULL, NULL),
uplo = "L", diag = "U", x = lu.A@x))
identical(e.lu.A[["U"]],
new("dtrMatrix", Dim = c(n, n), Dimnames = c(list(NULL), dn[2L]),
uplo = "U", diag = "N", x = lu.A@x))
ae1(A, with(e.lu.A, P1. %*% L %*% U))
ae2(A[asPerm(lu.A@perm), ], with(e.lu.A, L %*% U))
})
## Factorization handled as factorized matrix
b <- rnorm(n)
stopifnot(identical(det(A), det(lu.A)),
identical(solve(A, b), solve(lu.A, b)))
```

[Package *Matrix* version 1.6-5 Index]