Cholesky               package:Matrix               R Documentation

_C_h_o_l_e_s_k_y _D_e_c_o_m_p_o_s_i_t_i_o_n _o_f _a _S_p_a_r_s_e _M_a_t_r_i_x

_D_e_s_c_r_i_p_t_i_o_n:

     Computes the Cholesky decomposition of a sparse, symmetric,
     positive-definite matrix.  However, typically 'chol()' should
     rather be used unless you are interested in the different kinds of
     sparse Cholesky decompositions.

_U_s_a_g_e:

     Cholesky(A, perm = TRUE, LDL = TRUE, super = FALSE, ...)

_A_r_g_u_m_e_n_t_s:

       A: sparse symmetric matrix.  No missing values or IEEE special
          values are allowed.

    perm: logical scalar indicating if a fill-reducing permutation
          should be computed and applied to the rows and columns of
          'A'. Default is 'TRUE'.

     LDL: logical scalar indicating if the decomposition should be
          computed as LDL' where 'L' is a unit lower triangular matrix.
          The alternative is LL' where 'L' is lower triangular with
          arbitrary diagonal elements.  Default is 'TRUE'.

   super: logical scalar indicating is a supernodal decomposition
          should be created.  The alternative is a simplicial
          decomposition. Default is 'FALSE'.

     ...: further arguments passed to or from other methods.

_D_e_t_a_i_l_s:

     This is a generic function with special methods for different
     types of matrices.  Use 'showMethods("Cholesky")' to list all the
     methods for the 'Cholesky' generic.

     The method for class 'dsCMatrix' of sparse matrices - the only one
     available currently - is based on functions from the CHOLMOD
     library.

     Again: If you just want the Cholesky decomposition of a matrix,
     you should probably rather use 'chol(.)'.

_V_a_l_u_e:

     an object inheriting from either '"CHMsuper"', or '"CHMsimpl"',
     depending on the 'super' argument; both classes extend
     '"CHMfactor"' which extends '"MatrixFactorization"'.

     In other words, the result of 'Cholesky()' is _not_ a matrix, and
     if you want one, you should probably rather use 'chol()'.

_R_e_f_e_r_e_n_c_e_s:

     Tim Davis (2005) _{CHOLMOD}: sparse supernodal {Cholesky}
     factorization and update/downdate_ <URL:
     http://www.cise.ufl.edu/research/sparse/cholmod/>

     Timothy A. Davis (2006) _Direct Methods for Sparse Linear
     Systems_, SIAM Series "Fundamentals of Algorithms".

_S_e_e _A_l_s_o:

     Class definitions 'CHMfactor' and 'dsCMatrix' and function
     'expand'.

     Note that 'chol()' returns matrices (inheriting from '"Matrix"')
     whereas 'Cholesky()' returns a '"CHMfactor"' object, and hence a
     typical user will rather use 'chol(A)'.

_E_x_a_m_p_l_e_s:

     data(KNex)
     mtm <- with(KNex, crossprod(mm))
     str(mtm@factors) # empty list()
     Cholesky(mtm)             # uses show(<MatrixFactorization>)
     str(mtm@factors) # 'sPDCholesky' (simpl)
     (Cm <- Cholesky(mtm, super = TRUE))
     str(mtm@factors) # 'sPDCholesky'  *and*  'SPDCholesky'
     str(cmat <- as(Cm, "sparseMatrix"))
     cmat[1:20, 1:20]
     b <- matrix(c(rep(0, 711), 1), nc = 1)
     ## solve(Cm, b) by default solves  Ax = b, where A = Cm'Cm !
     stopifnot(identical(solve(Cm, b), solve(Cm, b, system = "A")),
               all.equal(solve(mtm, b),
                         solve(Cm, b)))

