Struct nalgebra::linalg::LU

pub struct LU<T: ComplexField, R: DimMin<C>, C: Dim>where
    DefaultAllocator: Allocator<T, R, C> + Allocator<(usize, usize), 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<T, R, C> + Allocator<(usize, usize), 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<T, 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<T, 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<T, R, DimMinimum<R, C>> + Allocator<T, 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<T, D, D> + Allocator<(usize, usize), 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<T, 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>
) -> boolwhere
    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<T, R, C> + Allocator<(usize, usize), 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<T, R, C> + Allocator<(usize, usize), 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<T, R, C> + Allocator<(usize, usize), 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<T, R, C> + Allocator<(usize, usize), 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<T, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
    OMatrix<T, R, C>: Copy,
    PermutationSequence<DimMinimum<R, C>>: Copy,