Struct extendr_api::prelude::sparse::linalg::cholesky::LdltRef

pub struct LdltRef<'a, I, E>
where
    I: Index,
    E: Entity,
{
    symbolic: &'a SymbolicCholesky<I>,
    values: SliceGroup<'a, E>,
}

Sparse LDLT factorization wrapper.

Fields

symbolic: &'a SymbolicCholesky<I>

values: SliceGroup<'a, E>

Implementations

impl<'a, I, E> LdltRef<'a, I, E>

where I: Index, E: Entity,

pub fn new( symbolic: &'a SymbolicCholesky<I>, values: <<E as Entity>::Group as ForType>::FaerOf<&'a [<E as Entity>::Unit]>, ) -> LdltRef<'a, I, E>

Creates new Cholesky LDLT factors from the symbolic part and numerical values.

Panics

• Panics if values.len() != symbolic.len_values().

pub fn symbolic(self) -> &'a SymbolicCholesky<I>

Returns the symbolic part of the Cholesky factor.

pub fn solve_in_place_with_conj( &self, conj: Conj, rhs: MatMut<'_, E>, parallelism: Parallelism<'_>, stack: PodStack<'_>, )

where E: ComplexField,

Solves the equation $\text{Op}(A) x = \text{rhs}$ and stores the result in rhs, where $\text{Op}$ is either the identity or the conjugate, depending on the value of conj.

Panics

Panics if rhs.nrows() != self.symbolic().nrows().

Methods from Deref<Target = SymbolicCholesky<I>>

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<'a, I, E> Clone for LdltRef<'a, I, E>

where I: Index, E: Entity,

fn clone(&self) -> LdltRef<'a, I, E>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, I, E> Debug for LdltRef<'a, I, E>

where I: Debug + Index, E: Debug + Entity,

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

Formats the value using the given formatter.

impl<'a, I, E> Deref for LdltRef<'a, I, E>

where I: Index, E: Entity,

type Target = SymbolicCholesky<I>

The resulting type after dereferencing.

fn deref(&self) -> &<LdltRef<'a, I, E> as Deref>::Target

Dereferences the value.

impl<'a, I, E> Copy for LdltRef<'a, I, E>

where I: Index, E: Entity,