CHMfactor-class {Matrix} | R Documentation |

The virtual class `"CHMfactor"`

is a class of
CHOLMOD-based Cholesky factorizations of symmetric, sparse,
compressed, column-oriented matrices. Such a factorization is
simplicial (virtual class `"CHMsimpl"`

) or supernodal (virtual
class `"CHMsuper"`

). Objects that inherit from these classes are
either numeric factorizations (classes `"dCHMsimpl"`

and
`"dCHMsuper"`

) or symbolic factorizations (classes
`"nCHMsimpl"`

and `"nCHMsuper"`

).

isLDL(x) ## S4 method for signature 'CHMfactor' update(object, parent, mult = 0, ...) .updateCHMfactor(object, parent, mult) ## and many more methods, notably, ## solve(a, b, system = c("A","LDLt","LD","DLt","L","Lt","D","P","Pt"), ...) ## ----- see below

`x,object,a` |
a |

`parent` |
a Since Matrix version 1.0-8, other |

`mult` |
a numeric scalar (default 0). |

`...` |
potentially further arguments to the methods. |

Objects can be created by calls of the form `new("dCHMsuper", ...)`

but are more commonly created via `Cholesky()`

,
applied to `dsCMatrix`

or
`lsCMatrix`

objects.

For an introduction, it may be helpful to look at the `expand()`

method and examples below.

of `"CHMfactor"`

and all classes inheriting from it:

`perm`

:An integer vector giving the 0-based permutation of the rows and columns chosen to reduce fill-in and for post-ordering.

`colcount`

:Object of class

`"integer"`

....

`type`

:Object of class

`"integer"`

....

Slots of the non virtual classes “[dl]CHM(super|simpl)”:

`p`

:Object of class

`"integer"`

of pointers, one for each column, to the initial (zero-based) index of elements in the column. Only present in classes that contain`"CHMsimpl"`

.`i`

:Object of class

`"integer"`

of length nnzero (number of non-zero elements). These are the row numbers for each non-zero element in the matrix. Only present in classes that contain`"CHMsimpl"`

.`x`

:For the

`"d*"`

classes:`"numeric"`

- the non-zero elements of the matrix.

- isLDL
`(x)`

returns a`logical`

indicating if`x`

is an*LDL'*decomposition or (when`FALSE`

) an*LL'*one.- coerce
`signature(from = "CHMfactor", to = "sparseMatrix")`

(or equivalently,`to = "Matrix"`

or`to = "triangularMatrix"`

)`as(*, "sparseMatrix")`

returns the lower triangular factor*L*from the*LL'*form of the Cholesky factorization. Note that (currently) the factor from the*LL'*form is always returned, even if the`"CHMfactor"`

object represents an*LDL'*decomposition. Furthermore, this is the factor after any fill-reducing permutation has been applied. See the`expand`

method for obtaining both the permutation matrix,*P*, and the lower Cholesky factor,*L*.- coerce
`signature(from = "CHMfactor", to = "pMatrix")`

returns the permutation matrix*P*, representing the fill-reducing permutation used in the decomposition.- expand
`signature(x = "CHMfactor")`

returns a list with components`P`

, the matrix representing the fill-reducing permutation, and`L`

, the lower triangular Cholesky factor. The original positive-definite matrix*A*corresponds to the product*A = P'LL'P*. Because of fill-in during the decomposition the product may apparently have more non-zeros than the original matrix, even after applying`drop0`

to it. However, the extra "non-zeros" should be very small in magnitude.- image
`signature(x = "CHMfactor"):`

Plot the image of the lower triangular factor,*L*, from the decomposition. This method is equivalent to`image(as(x, "sparseMatrix"))`

so the comments in the above description of the`coerce`

method apply here too.- solve
`signature(a = "CHMfactor", b = "ddenseMatrix"), system= *`

: The`solve`

methods for a`"CHMfactor"`

object take an optional third argument`system`

whose value can be one of the character strings`"A"`

,`"LDLt"`

,`"LD"`

,`"DLt"`

,`"L"`

,`"Lt"`

,`"D"`

,`"P"`

or`"Pt"`

. This argument describes the system to be solved. The default,`"A"`

, is to solve*Ax = b*for*x*where`A`

is the sparse, positive-definite matrix that was factored to produce`a`

. Analogously,`system = "L"`

returns the solution*x*, of*Lx = b*. Similarly, for all system codes**but**`"P"`

and`"Pt"`

where, e.g.,`x <- solve(a, b, system="P")`

is equivalent to`x <- P %*% b`

.See also

`solve-methods`

.- determinant
`signature(x = "CHMfactor", logarithm = "logical")`

returns the determinant (or the logarithm of the determinant, if`logarithm = TRUE`

, the default) of the factor*L*from the*LL'*decomposition (even if the decomposition represented by`x`

is of the*LDL'*form (!)). This is the square root of the determinant (half the logarithm of the determinant when`logarithm = TRUE`

) of the positive-definite matrix that was decomposed.

- update
`signature(object = "CHMfactor"), parent`

. The`update`

method requires an additional argument`parent`

, which is*either*a`"dsCMatrix"`

object, say*A*, (with the same structure of nonzeros as the matrix that was decomposed to produce`object`

) or a general`"dgCMatrix"`

, say*M*, where*A := M M'*(`== tcrossprod(parent)`

) is used for*A*. Further it provides an optional argument`mult`

, a numeric scalar. This method updates the numeric values in`object`

to the decomposition of*A+mI*where*A*is the matrix above (either the`parent`

or*M M'*) and*m*is the scalar`mult`

. Because only the numeric values are updated this method should be faster than creating and decomposing*A+mI*. It is not uncommon to want, say, the determinant of*A+mI*for many different values of*m*. This method would be the preferred approach in such cases.

`Cholesky`

, also for examples;
class `dgCMatrix`

.

## An example for the expand() method n <- 1000; m <- 200; nnz <- 2000 set.seed(1) M1 <- spMatrix(n, m, i = sample(n, nnz, replace = TRUE), j = sample(m, nnz, replace = TRUE), x = round(rnorm(nnz),1)) XX <- crossprod(M1) ## = M1'M1 = M M' where M <- t(M1) CX <- Cholesky(XX) isLDL(CX) str(CX) ## a "dCHMsimpl" object r <- expand(CX) L.P <- with(r, crossprod(L,P)) ## == L'P PLLP <- crossprod(L.P) ## == (L'P)' L'P == P'LL'P = XX = M M' b <- sample(m) stopifnot(all.equal(PLLP, XX), all(as.vector(solve(CX, b, system="P" )) == r$P %*% b), all(as.vector(solve(CX, b, system="Pt")) == t(r$P) %*% b) ) u1 <- update(CX, XX, mult=pi) u2 <- update(CX, t(M1), mult=pi) # with the original M, where XX = M M' stopifnot(all.equal(u1,u2, tol=1e-14)) ## [ See help(Cholesky) for more examples ] ## -------------

[Package *Matrix* version 1.2-18 Index]