Struct extendr_api::prelude::sparse::linalg::cholesky::SymbolicCholesky

pub struct SymbolicCholesky<I>
where
    I: Index,
{
    raw: SymbolicCholeskyRaw<I>,
    perm_fwd: Option<Vec<I>>,
    perm_inv: Option<Vec<I>>,
    A_nnz: usize,
}

The symbolic structure of a sparse Cholesky decomposition.

Fields

raw: SymbolicCholeskyRaw<I>

perm_fwd: Option<Vec<I>>

perm_inv: Option<Vec<I>>

A_nnz: usize

Implementations

impl<I> SymbolicCholesky<I>

where I: Index,

pub fn nrows(&self) -> usize

Returns the number of rows of the matrix.

pub fn ncols(&self) -> usize

Returns the number of columns of the matrix.

pub fn raw(&self) -> &SymbolicCholeskyRaw<I>

Returns the inner type of the factorization, either simplicial or symbolic.

pub fn perm(&self) -> Option<PermRef<'_, I>>

Returns the permutation that was computed during symbolic analysis.

pub fn len_values(&self) -> usize

Returns the length of the slice needed to store the numerical values of the Cholesky decomposition.

pub fn factorize_numeric_llt_req<E>( &self, parallelism: Parallelism<'_>, ) -> Result<StackReq, SizeOverflow>

where E: Entity,

Computes the required workspace size and alignment for a numerical LLT factorization.

pub fn factorize_numeric_ldlt_req<E>( &self, with_regularization_signs: bool, parallelism: Parallelism<'_>, ) -> Result<StackReq, SizeOverflow>

where E: Entity,

Computes the required workspace size and alignment for a numerical LDLT factorization.

pub fn factorize_numeric_intranode_bunch_kaufman_req<E>( &self, with_regularization_signs: bool, parallelism: Parallelism<'_>, ) -> Result<StackReq, SizeOverflow>

where E: Entity,

Computes the required workspace size and alignment for a numerical intranodal Bunch-Kaufman factorization.

pub fn factorize_numeric_llt<'out, E>( &'out self, L_values: <<E as Entity>::Group as ForType>::FaerOf<&'out mut [<E as Entity>::Unit]>, A: SparseColMatRef<'_, I, E>, side: Side, regularization: LltRegularization<E>, parallelism: Parallelism<'_>, stack: PodStack<'_>, ) -> Result<LltRef<'out, I, E>, CholeskyError>

where E: ComplexField,

Computes a numerical LLT factorization of A, or returns a CholeskyError if the matrix is not numerically positive definite.

pub fn factorize_numeric_ldlt<'out, E>( &'out self, L_values: <<E as Entity>::Group as ForType>::FaerOf<&'out mut [<E as Entity>::Unit]>, A: SparseColMatRef<'_, I, E>, side: Side, regularization: LdltRegularization<'_, E>, parallelism: Parallelism<'_>, stack: PodStack<'_>, ) -> LdltRef<'out, I, E>

where E: ComplexField,

Computes a numerical LDLT factorization of A.

pub fn factorize_numeric_intranode_bunch_kaufman<'out, E>( &'out self, L_values: <<E as Entity>::Group as ForType>::FaerOf<&'out mut [<E as Entity>::Unit]>, subdiag: <<E as Entity>::Group as ForType>::FaerOf<&'out mut [<E as Entity>::Unit]>, perm_forward: &'out mut [I], perm_inverse: &'out mut [I], A: SparseColMatRef<'_, I, E>, side: Side, regularization: BunchKaufmanRegularization<'_, E>, parallelism: Parallelism<'_>, stack: PodStack<'_>, ) -> IntranodeBunchKaufmanRef<'out, I, E>

where E: ComplexField,

Computes a numerical intranodal Bunch-Kaufman factorization of A.

pub fn solve_in_place_req<E>( &self, rhs_ncols: usize, ) -> Result<StackReq, SizeOverflow>

where E: Entity,

Computes the required workspace size and alignment for a dense solve in place using an LLT, LDLT or intranodal Bunch-Kaufman factorization.

Trait Implementations

impl<I> Debug for SymbolicCholesky<I>

where I: Debug + Index,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.