Struct nalgebra::linalg::Cholesky

pub struct Cholesky<T: SimdComplexField, D: Dim> where
    DefaultAllocator: Allocator<T, D, D>,  { /* fields omitted */ }

The Cholesky decomposition of a symmetric-definite-positive matrix.

Implementations

impl<T: SimdComplexField, D: Dim> Cholesky<T, D> where
    DefaultAllocator: Allocator<T, D, D>, 

pub fn new_unchecked(matrix: OMatrix<T, D, D>) -> Self

Computes the Cholesky decomposition of matrix without checking that the matrix is definite-positive.

If the input matrix is not definite-positive, the decomposition may contain trash values (Inf, NaN, etc.)

pub fn pack_dirty(matrix: OMatrix<T, D, D>) -> Self

Uses the given matrix as-is without any checks or modifications as the Cholesky decomposition.

It is up to the user to ensure all invariants hold.

pub fn unpack(self) -> OMatrix<T, D, D>

Retrieves the lower-triangular factor of the Cholesky decomposition with its strictly upper-triangular part filled with zeros.

pub fn unpack_dirty(self) -> OMatrix<T, D, D>

Retrieves the lower-triangular factor of the Cholesky decomposition, without zeroing-out its strict upper-triangular part.

The values of the strict upper-triangular part are garbage and should be ignored by further computations.

pub fn l(&self) -> OMatrix<T, D, D>

Retrieves the lower-triangular factor of the Cholesky decomposition with its strictly uppen-triangular part filled with zeros.

pub fn l_dirty(&self) -> &OMatrix<T, D, D>

Retrieves the lower-triangular factor of the Cholesky decomposition, without zeroing-out its strict upper-triangular part.

This is an allocation-less version of self.l(). The values of the strict upper-triangular part are garbage and should be ignored by further computations.

pub fn solve_mut<R2: Dim, C2: Dim, S2>(&self, b: &mut Matrix<T, R2, C2, S2>) where
    S2: StorageMut<T, R2, C2>,
    ShapeConstraint: SameNumberOfRows<R2, D>, 

Solves the system self * x = b where self is the decomposed matrix and x the unknown.

The result is stored on b.

pub fn solve<R2: Dim, C2: Dim, S2>(
    &self,
    b: &Matrix<T, R2, C2, S2>
) -> OMatrix<T, R2, C2> where
    S2: Storage<T, R2, C2>,
    DefaultAllocator: Allocator<T, R2, C2>,
    ShapeConstraint: SameNumberOfRows<R2, D>, 

Returns the solution of the system self * x = b where self is the decomposed matrix and x the unknown.

pub fn inverse(&self) -> OMatrix<T, D, D>

Computes the inverse of the decomposed matrix.

pub fn determinant(&self) -> T::SimdRealField

Computes the determinant of the decomposed matrix.

impl<T: ComplexField, D: Dim> Cholesky<T, D> where
    DefaultAllocator: Allocator<T, D, D>, 

pub fn new(matrix: OMatrix<T, D, D>) -> Option<Self>

Attempts to compute the Cholesky decomposition of matrix.

Returns None if the input matrix is not definite-positive. The input matrix is assumed to be symmetric and only the lower-triangular part is read.

pub fn new_with_substitute(
    matrix: OMatrix<T, D, D>,
    substitute: T
) -> Option<Self>

Attempts to approximate the Cholesky decomposition of matrix by replacing non-positive values on the diagonals during the decomposition with the given substitute.

try_sqrt will be applied to the substitute when it has to be used.

If your input matrix results only in positive values on the diagonals during the decomposition, substitute is unused and the result is just the same as if you used new.

This method allows to compensate for matrices with very small or even negative values due to numerical errors but necessarily results in only an approximation: it is basically a hack. If you don’t specifically need Cholesky, it may be better to consider alternatives like the LU decomposition/factorization.

pub fn rank_one_update<R2: Dim, S2>(
    &mut self,
    x: &Vector<T, R2, S2>,
    sigma: T::RealField
) where
    S2: Storage<T, R2, U1>,
    DefaultAllocator: Allocator<T, R2, U1>,
    ShapeConstraint: SameNumberOfRows<R2, D>, 

Given the Cholesky decomposition of a matrix M, a scalar sigma and a vector v, performs a rank one update such that we end up with the decomposition of M + sigma * (v * v.adjoint()).

pub fn insert_column<R2, S2>(
    &self,
    j: usize,
    col: Vector<T, R2, S2>
) -> Cholesky<T, DimSum<D, U1>> where
    D: DimAdd<U1>,
    R2: Dim,
    S2: Storage<T, R2, U1>,
    DefaultAllocator: Allocator<T, DimSum<D, U1>, DimSum<D, U1>> + Allocator<T, R2>,
    ShapeConstraint: SameNumberOfRows<R2, DimSum<D, U1>>, 

Updates the decomposition such that we get the decomposition of a matrix with the given column col in the jth position. Since the matrix is square, an identical row will be added in the jth row.

pub fn remove_column(&self, j: usize) -> Cholesky<T, DimDiff<D, U1>> where
    D: DimSub<U1>,
    DefaultAllocator: Allocator<T, DimDiff<D, U1>, DimDiff<D, U1>> + Allocator<T, D>, 

Updates the decomposition such that we get the decomposition of the factored matrix with its jth column removed. Since the matrix is square, the jth row will also be removed.

Trait Implementations

impl<T: Clone + SimdComplexField, D: Clone + Dim> Clone for Cholesky<T, D> where
    DefaultAllocator: Allocator<T, D, D>, 

fn clone(&self) -> Cholesky<T, D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + SimdComplexField, D: Debug + Dim> Debug for Cholesky<T, D> where
    DefaultAllocator: Allocator<T, D, D>, 

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

Formats the value using the given formatter.

impl<T: SimdComplexField, D: Dim> Copy for Cholesky<T, D> where
    DefaultAllocator: Allocator<T, D, D>,
    OMatrix<T, D, D>: Copy,