Struct nalgebra::linalg::Cholesky

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

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

Implementations

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

pub fn new_unchecked(matrix: MatrixN<N, 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 unpack(self) -> MatrixN<N, D>

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

pub fn unpack_dirty(self) -> MatrixN<N, 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) -> MatrixN<N, D>

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

pub fn l_dirty(&self) -> &MatrixN<N, 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<N, R2, C2, S2>) where
    S2: StorageMut<N, 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<N, R2, C2, S2>
) -> MatrixMN<N, R2, C2> where
    S2: Storage<N, R2, C2>,
    DefaultAllocator: Allocator<N, 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) -> MatrixN<N, D>

Computes the inverse of the decomposed matrix.

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

pub fn new(matrix: MatrixN<N, 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 rank_one_update<R2: Dim, S2>(
    &mut self,
    x: &Vector<N, R2, S2>,
    sigma: N::RealField
) where
    S2: Storage<N, R2, U1>,
    DefaultAllocator: Allocator<N, 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<N, R2, S2>
) -> Cholesky<N, DimSum<D, U1>> where
    D: DimAdd<U1>,
    R2: Dim,
    S2: Storage<N, R2, U1>,
    DefaultAllocator: Allocator<N, DimSum<D, U1>, DimSum<D, U1>> + Allocator<N, 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<N, DimDiff<D, U1>> where
    D: DimSub<U1>,
    DefaultAllocator: Allocator<N, DimDiff<D, U1>, DimDiff<D, U1>> + Allocator<N, 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<N: Clone + SimdComplexField, D: Clone + Dim> Clone for Cholesky<N, D> where
    DefaultAllocator: Allocator<N, D, D>, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: SimdComplexField, D: Dim> Copy for Cholesky<N, D> where
    DefaultAllocator: Allocator<N, D, D>,
    MatrixN<N, D>: Copy, 

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

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

Formats the value using the given formatter.