# sparseLU-class: Sparse LU decomposition of a square sparse matrix In Matrix: Sparse and Dense Matrix Classes and Methods

## Description

Objects of this class contain the components of the LU decomposition of a sparse square matrix.

## Objects from the Class

Objects can be created by calls of the form ```new("sparseLU", ...)``` but are more commonly created by function `lu()` applied to a sparse matrix, such as a matrix of class `dgCMatrix`.

## Slots

`L`:

Object of class `"dtCMatrix"`, the lower triangular factor from the left.

`U`:

Object of class `"dtCMatrix"`, the upper triangular factor from the right.

`p`:

Object of class `"integer"`, permutation applied from the left.

`q`:

Object of class `"integer"`, permutation applied from the right.

`Dim`:

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

## Extends

Class `"LU"`, directly. Class `"MatrixFactorization"`, by class `"LU"`.

## Methods

expand

`signature(x = "sparseLU")` Returns a list with components `P`, `L`, `U`, and `Q`, where P and Q represent fill-reducing permutations, and L, and U the lower and upper triangular matrices of the decomposition. The original matrix corresponds to the product P'LUQ.

## Note

The decomposition is of the form

A = P'LUQ,

or equivalently PAQ' = LU, where all matrices are sparse and of size n by n. The matrices P and Q, and their transposes P' and Q' are permutation matrices, L is lower triangular and U is upper triangular.

`lu`, `solve`, `dgCMatrix`

## Examples

 ``` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26``` ```## Extending the one in examples(lu), calling the matrix A, ## and confirming the factorization identities : A <- as(readMM(system.file("external/pores_1.mtx", package = "Matrix")), "CsparseMatrix") ## with dimnames(.) - to see that they propagate to L, U : dimnames(A) <- dnA <- list(paste0("r", seq_len(nrow(A))), paste0("C", seq_len(ncol(A)))) str(luA <- lu(A)) # p is a 0-based permutation of the rows # q is a 0-based permutation of the columns xA <- expand(luA) ## which is simply doing stopifnot(identical(xA\$ L, luA@L), identical(xA\$ U, luA@U), identical(xA\$ P, as(luA@p +1L, "pMatrix")), identical(xA\$ Q, as(luA@q +1L, "pMatrix"))) P.LUQ <- with(xA, t(P) %*% L %*% U %*% Q) stopifnot(all.equal(A, P.LUQ, tolerance = 1e-12), identical(dimnames(P.LUQ), dnA)) ## permute rows and columns of original matrix pA <- A[luA@p + 1L, luA@q + 1L] stopifnot(identical(pA, with(xA, P %*% A %*% t(Q)))) pLU <- drop0(luA@L %*% luA@U) # L %*% U -- dropping extra zeros stopifnot(all.equal(pA, pLU, tolerance = 1e-12)) ```

### Example output

```Formal class 'sparseLU' [package "Matrix"] with 5 slots
..@ L  :Formal class 'dtCMatrix' [package "Matrix"] with 7 slots
.. .. ..@ i       : int [1:141] 0 1 18 22 25 26 1 18 22 25 ...
.. .. ..@ p       : int [1:31] 0 6 11 13 16 19 22 26 31 35 ...
.. .. ..@ Dim     : int [1:2] 30 30
.. .. ..@ Dimnames:List of 2
.. .. .. ..\$ : chr [1:30] "r2" "r12" "r30" "r28" ...
.. .. .. ..\$ : NULL
.. .. ..@ x       : num [1:141] 1 -0.993819 -0.004979 -0.000132 0.000132 ...
.. .. ..@ uplo    : chr "L"
.. .. ..@ diag    : chr "N"
..@ U  :Formal class 'dtCMatrix' [package "Matrix"] with 7 slots
.. .. ..@ i       : int [1:206] 0 0 1 2 2 3 2 4 2 3 ...
.. .. ..@ p       : int [1:31] 0 1 3 4 6 8 12 15 20 25 ...
.. .. ..@ Dim     : int [1:2] 30 30
.. .. ..@ Dimnames:List of 2
.. .. .. ..\$ : NULL
.. .. .. ..\$ : chr [1:30] "C1" "C2" "C30" "C28" ...
.. .. ..@ x       : num [1:206] -7178502 -24613411 -18311731 -6399179 715 ...
.. .. ..@ uplo    : chr "U"
.. .. ..@ diag    : chr "N"
..@ p  : int [1:30] 1 11 29 27 19 28 9 18 17 7 ...
..@ q  : int [1:30] 0 1 29 27 19 28 9 18 17 8 ...
..@ Dim: int [1:2] 30 30
```

Matrix documentation built on Aug. 20, 2018, 3:01 p.m.