Struct LU

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

LU decomposition with partial (row) pivoting.

Implementations

impl<T: ComplexField, R: DimMin<C>, C: Dim> LU<T, R, C>

where DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>>,

pub fn new(matrix: OMatrix<T, R, C>) -> Self

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

pub fn l(&self) -> OMatrix<T, R, DimMinimum<R, C>>

where DefaultAllocator: Allocator<R, DimMinimum<R, C>>,

The lower triangular matrix of this decomposition.

pub fn l_unpack(self) -> OMatrix<T, R, DimMinimum<R, C>>

where DefaultAllocator: Reallocator<T, R, C, R, DimMinimum<R, C>>,

The lower triangular matrix of this decomposition.

pub fn u(&self) -> OMatrix<T, DimMinimum<R, C>, C>

where DefaultAllocator: Allocator<DimMinimum<R, C>, C>,

The upper triangular matrix of this decomposition.

pub fn p(&self) -> &PermutationSequence<DimMinimum<R, C>>

The row permutations of this decomposition.

pub fn unpack( self, ) -> (PermutationSequence<DimMinimum<R, C>>, OMatrix<T, R, DimMinimum<R, C>>, OMatrix<T, DimMinimum<R, C>, C>)

where DefaultAllocator: Allocator<R, DimMinimum<R, C>> + Allocator<DimMinimum<R, C>, C> + Reallocator<T, R, C, R, DimMinimum<R, C>>,

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

impl<T: ComplexField, D: DimMin<D, Output = D>> LU<T, D, D>

where DefaultAllocator: Allocator<D, D> + Allocator<D>,

pub fn solve<R2: Dim, C2: Dim, S2>( &self, b: &Matrix<T, R2, C2, S2>, ) -> Option<OMatrix<T, R2, C2>>

where 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: Dim, C2: Dim, S2>( &self, b: &mut Matrix<T, R2, C2, S2>, ) -> bool

where 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<OMatrix<T, D, D>>

Computes the inverse of the decomposed matrix.

Returns None if the matrix is not invertible.

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

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: Clone + ComplexField, R: Clone + DimMin<C>, C: Clone + Dim> Clone for LU<T, R, C>

where DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>>,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + ComplexField, R: Debug + DimMin<C>, C: Debug + Dim> Debug for LU<T, R, C>

where DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>>,

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

Formats the value using the given formatter.

impl<'de, T: ComplexField, R: DimMin<C>, C: Dim> Deserialize<'de> for LU<T, R, C>

where DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>>, OMatrix<T, R, C>: Deserialize<'de>, PermutationSequence<DimMinimum<R, C>>: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: ComplexField, R: DimMin<C>, C: Dim> Serialize for LU<T, R, C>

where DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>>, OMatrix<T, R, C>: Serialize, PermutationSequence<DimMinimum<R, C>>: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: ComplexField, R: DimMin<C>, C: Dim> Copy for LU<T, R, C>

where DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>>, OMatrix<T, R, C>: Copy, PermutationSequence<DimMinimum<R, C>>: Copy,