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
"CHMsuper"). Objects that inherit from these classes are
either numeric factorizations (classes
"dCHMsuper") or symbolic factorizations (classes
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
Since Matrix version 1.0-8, other
a numeric scalar (default 0).
potentially further arguments to the methods.
Objects can be created by calls of the form
but are more commonly created via
For an introduction, it may be helpful to look at the
method and examples below.
"CHMfactor" and all classes inheriting from it:
An integer vector giving the 0-based permutation of the rows and columns chosen to reduce fill-in and for post-ordering.
Object of class
Object of class
Slots of the non virtual classes “[dl]CHM(super|simpl)”:
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
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
"numeric" - the
non-zero elements of the matrix.
(x) returns a
logical indicating if
x is an LDL' decomposition or (when
signature(from = "CHMfactor", to = "sparseMatrix")
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
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.
signature(from = "CHMfactor", to = "pMatrix")
returns the permutation matrix P, representing the
fill-reducing permutation used in the decomposition.
signature(x = "CHMfactor") returns a list with
P, the matrix representing the fill-reducing
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.
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
apply here too.
signature(a = "CHMfactor", b = "ddenseMatrix"), system= *:
solve methods for a
"CHMfactor" object take an
optional third argument
system whose value can be one of the
"Pt". This argument describes the system to be solved. The
"A", is to solve Ax = b for x where
A is the sparse, positive-definite matrix that was factored
system = "L" returns the
solution x, of Lx = b.
Similarly, for all system codes but
x <- solve(a, b, system="P") is equivalent to
x <- P %*% b.
signature(x = "CHMfactor", logarithm =
"logical") returns the determinant (or the logarithm of the
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.
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
object) or a general
say M, where A := M M' (
is used for A.
Further it provides an optional argument
mult, a numeric
scalar. This method updates the numeric values in
to the decomposition of A+mI where A is the matrix
above (either the
parent or M M') and m is
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;
## 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 ] ## -------------
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.