Struct rin::math::Cholesky

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

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

Implementations

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

pub fn new_unchecked(
    matrix: Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>
) -> Cholesky<N, 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 unpack(
    self
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, 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<N, D, D, <DefaultAllocator as Allocator<N, 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<N, D, D, <DefaultAllocator as Allocator<N, 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<N, D, D, <DefaultAllocator as Allocator<N, 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<N, R2, C2, S2>) where
    C2: Dim,
    R2: Dim,
    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, C2, S2>(
    &self,
    b: &Matrix<N, R2, C2, S2>
) -> Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer> where
    C2: Dim,
    R2: Dim,
    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
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>

Computes the inverse of the decomposed matrix.

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

pub fn new(
    matrix: Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>
) -> Option<Cholesky<N, 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 rank_one_update<R2, S2>(
    &mut self,
    x: &Matrix<N, R2, U1, S2>,
    sigma: <N as ComplexField>::RealField
) where
    R2: Dim,
    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: Matrix<N, R2, U1, S2>
) -> Cholesky<N, <D as DimAdd<U1>>::Output> where
    D: DimAdd<U1>,
    R2: Dim,
    S2: Storage<N, R2, U1>,
    DefaultAllocator: Allocator<N, <D as DimAdd<U1>>::Output, <D as DimAdd<U1>>::Output>,
    DefaultAllocator: Allocator<N, R2, U1>,
    ShapeConstraint: SameNumberOfRows<R2, <D as DimAdd<U1>>::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<N, <D as DimSub<U1>>::Output> where
    D: DimSub<U1>,
    DefaultAllocator: Allocator<N, <D as DimSub<U1>>::Output, <D as DimSub<U1>>::Output>,
    DefaultAllocator: Allocator<N, D, U1>, 

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

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

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

Formats the value using the given formatter.

impl<'de, N, D> Deserialize<'de> for Cholesky<N, D> where
    N: SimdComplexField,
    D: Dim,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<N, D, U1>,
    Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>: Deserialize<'de>, 

pub fn deserialize<__D>(
    __deserializer: __D
) -> Result<Cholesky<N, D>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<N, D> Serialize for Cholesky<N, D> where
    N: SimdComplexField,
    D: Dim,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<N, D, U1>,
    Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>: Serialize, 

pub fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

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