Struct LU 

pub struct LU<T, R, C>
where
    T: ComplexField,
    R: DimMin<C>,
    C: Dim,
    DefaultAllocator: Allocator<R, C> + Allocator<<R as DimMin<C>>::Output>,
{ /* private fields */ }

LU decomposition with partial (row) pivoting.

Implementations

impl<T, R, C> LU<T, R, C>

where T: ComplexField, R: DimMin<C>, C: Dim, DefaultAllocator: Allocator<R, C> + Allocator<<R as DimMin<C>>::Output>,

pub fn new( matrix: Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>, ) -> LU<T, R, C>

Computes the LU decomposition with partial (row) pivoting of matrix.

pub fn l( &self, ) -> Matrix<T, R, <R as DimMin<C>>::Output, <DefaultAllocator as Allocator<R, <R as DimMin<C>>::Output>>::Buffer<T>>

where DefaultAllocator: Allocator<R, <R as DimMin<C>>::Output>,

The lower triangular matrix of this decomposition.

pub fn l_unpack( self, ) -> Matrix<T, R, <R as DimMin<C>>::Output, <DefaultAllocator as Allocator<R, <R as DimMin<C>>::Output>>::Buffer<T>>

where DefaultAllocator: Reallocator<T, R, C, R, <R as DimMin<C>>::Output>,

The lower triangular matrix of this decomposition.

pub fn u( &self, ) -> Matrix<T, <R as DimMin<C>>::Output, C, <DefaultAllocator as Allocator<<R as DimMin<C>>::Output, C>>::Buffer<T>>

where DefaultAllocator: Allocator<<R as DimMin<C>>::Output, C>,

The upper triangular matrix of this decomposition.

pub fn p(&self) -> &PermutationSequence<<R as DimMin<C>>::Output>

The row permutations of this decomposition.

pub fn unpack( self, ) -> (PermutationSequence<<R as DimMin<C>>::Output>, Matrix<T, R, <R as DimMin<C>>::Output, <DefaultAllocator as Allocator<R, <R as DimMin<C>>::Output>>::Buffer<T>>, Matrix<T, <R as DimMin<C>>::Output, C, <DefaultAllocator as Allocator<<R as DimMin<C>>::Output, C>>::Buffer<T>>)

where DefaultAllocator: Allocator<R, <R as DimMin<C>>::Output> + Allocator<<R as DimMin<C>>::Output, C> + Reallocator<T, R, C, R, <R as DimMin<C>>::Output>,

The row permutations and two triangular matrices of this decomposition: (P, L, U).

impl<T, D> LU<T, D, D>

where T: ComplexField, D: DimMin<D, Output = D>, DefaultAllocator: Allocator<D, D> + Allocator<D>,

pub fn solve<R2, C2, S2>( &self, b: &Matrix<T, R2, C2, S2>, ) -> Option<Matrix<T, R2, C2, <DefaultAllocator as Allocator<R2, C2>>::Buffer<T>>>

where R2: Dim, C2: Dim, S2: Storage<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>, DefaultAllocator: Allocator<R2, C2>,

Solves the linear system self * x = b, where x is the unknown to be determined.

Returns None if self is not invertible.

pub fn solve_mut<R2, C2, S2>(&self, b: &mut Matrix<T, R2, C2, S2>) -> bool

where R2: Dim, C2: Dim, S2: StorageMut<T, R2, C2>, ShapeConstraint: SameNumberOfRows<R2, D>,

Solves the linear system self * x = b, where x is the unknown to be determined.

If the decomposed matrix is not invertible, this returns false and its input b may be overwritten with garbage.

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

Computes the inverse of the decomposed matrix.

Returns None if the matrix is not invertible.

pub fn try_inverse_to<S2>(&self, out: &mut Matrix<T, D, D, S2>) -> bool

where S2: StorageMut<T, D, D>,

Computes the inverse of the decomposed matrix and outputs the result to out.

If the decomposed matrix is not invertible, this returns false and out may be overwritten with garbage.

pub fn determinant(&self) -> T

Computes the determinant of the decomposed matrix.

pub fn is_invertible(&self) -> bool

Indicates if the decomposed matrix is invertible.

Trait Implementations

impl<T, R, C> Clone for LU<T, R, C>

where T: Clone + ComplexField, R: Clone + DimMin<C>, C: Clone + Dim, DefaultAllocator: Allocator<R, C> + Allocator<<R as DimMin<C>>::Output>,

fn clone(&self) -> LU<T, R, C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, R, C> Debug for LU<T, R, C>

where T: Debug + ComplexField, R: Debug + DimMin<C>, C: Debug + Dim, DefaultAllocator: Allocator<R, C> + Allocator<<R as DimMin<C>>::Output>,

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

Formats the value using the given formatter.

impl<'de, T, R, C> Deserialize<'de> for LU<T, R, C>

where T: ComplexField, R: DimMin<C>, C: Dim, DefaultAllocator: Allocator<R, C> + Allocator<<R as DimMin<C>>::Output>, Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>: Deserialize<'de>, PermutationSequence<<R as DimMin<C>>::Output>: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<LU<T, R, C>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, R, C> Serialize for LU<T, R, C>

where T: ComplexField, R: DimMin<C>, C: Dim, DefaultAllocator: Allocator<R, C> + Allocator<<R as DimMin<C>>::Output>, Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>: Serialize, PermutationSequence<<R as DimMin<C>>::Output>: Serialize,

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<T, R, C> Copy for LU<T, R, C>

where T: ComplexField, R: DimMin<C>, C: Dim, DefaultAllocator: Allocator<R, C> + Allocator<<R as DimMin<C>>::Output>, Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>: Copy, PermutationSequence<<R as DimMin<C>>::Output>: Copy,