Struct heron::rapier_plugin::rapier2d::prelude::nalgebra::Cholesky

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

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

Implementations

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

pub fn new_unchecked(
    matrix: Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer>
) -> Cholesky<T, D>

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: Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer>
) -> Cholesky<T, D>

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
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer>

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

pub fn unpack_dirty(
    self
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer>

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
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer>

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

pub fn l_dirty(
    &self
) -> &Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer>

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, C2, S2>(&self, b: &mut Matrix<T, R2, C2, S2>)where
    R2: Dim,
    C2: Dim,
    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, C2, S2>(
    &self,
    b: &Matrix<T, R2, C2, S2>
) -> Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer>where
    R2: Dim,
    C2: Dim,
    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
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer>

Computes the inverse of the decomposed matrix.

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

Computes the determinant of the decomposed matrix.

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

pub fn new(
    matrix: Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer>
) -> Option<Cholesky<T, D>>

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: Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer>,
    substitute: T
) -> Option<Cholesky<T, D>>

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, S2>(
    &mut self,
    x: &Matrix<T, R2, Const<1>, S2>,
    sigma: <T as ComplexField>::RealField
)where
    R2: Dim,
    S2: Storage<T, R2, Const<1>>,
    DefaultAllocator: Allocator<T, R2, Const<1>>,
    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: Matrix<T, R2, Const<1>, S2>
) -> Cholesky<T, <D as DimAdd<Const<1>>>::Output>where
    D: DimAdd<Const<1>>,
    R2: Dim,
    S2: Storage<T, R2, Const<1>>,
    DefaultAllocator: Allocator<T, <D as DimAdd<Const<1>>>::Output, <D as DimAdd<Const<1>>>::Output> + Allocator<T, R2, Const<1>>,
    ShapeConstraint: SameNumberOfRows<R2, <D as DimAdd<Const<1>>>::Output>,

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, <D as DimSub<Const<1>>>::Output>where
    D: DimSub<Const<1>>,
    DefaultAllocator: Allocator<T, <D as DimSub<Const<1>>>::Output, <D as DimSub<Const<1>>>::Output> + Allocator<T, D, Const<1>>,

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, D> Clone for Cholesky<T, D>where
    T: Clone + SimdComplexField,
    D: Clone + Dim,
    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, D> Debug for Cholesky<T, D>where
    T: Debug + SimdComplexField,
    D: Debug + Dim,
    DefaultAllocator: Allocator<T, D, D>,

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

Formats the value using the given formatter.

impl<T, D> Copy for Cholesky<T, D>where
    T: SimdComplexField,
    D: Dim,
    DefaultAllocator: Allocator<T, D, D>,
    Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer>: Copy,