Struct rin::math::Cholesky[][src]

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>, 
[src]

pub fn new_unchecked(
    matrix: Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>
) -> Cholesky<N, D>
[src]

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>
[src]

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>
[src]

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>
[src]

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>
[src]

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>, 
[src]

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>, 
[src]

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>
[src]

Computes the inverse of the decomposed matrix.

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

pub fn new(
    matrix: Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>
) -> Option<Cholesky<N, D>>
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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

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>, 
[src]

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
[src]

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
[src]

Auto Trait Implementations

impl<N, D> !RefUnwindSafe for Cholesky<N, D>

impl<N, D> !Send for Cholesky<N, D>

impl<N, D> !Sync for Cholesky<N, D>

impl<N, D> !Unpin for Cholesky<N, D>

impl<N, D> !UnwindSafe for Cholesky<N, D>

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Any for T where
    T: Any
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Downcast for T where
    T: Any
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<V> IntoPnt<V> for V[src]

impl<V> IntoVec<V> for V[src]

impl<T> Pointable for T[src]

type Init = T

The type for initializers.

impl<T> Same<T> for T[src]

type Output = T

Should always be Self

impl<SS, SP> SupersetOf<SS> for SP where
    SS: SubsetOf<SP>, 
[src]

impl<SS, SP> SupersetOf<SS> for SP where
    SS: SubsetOf<SP>, 
[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<V, T> VZip<V> for T where
    V: MultiLane<T>, 
[src]