[][src]Struct nalgebra::linalg::LU

pub struct LU<N: ComplexField, R: DimMin<C>, C: Dim> where
    DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>, 
{ /* fields omitted */ }

LU decomposition with partial (row) pivoting.

Methods

impl<N: ComplexField, R: DimMin<C>, C: Dim> LU<N, R, C> where
    DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>, 
[src]

pub fn new(matrix: MatrixMN<N, R, C>) -> Self[src]

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

pub fn l(&self) -> MatrixMN<N, R, DimMinimum<R, C>> where
    DefaultAllocator: Allocator<N, R, DimMinimum<R, C>>, 
[src]

The lower triangular matrix of this decomposition.

pub fn l_unpack(self) -> MatrixMN<N, R, DimMinimum<R, C>> where
    DefaultAllocator: Reallocator<N, R, C, R, DimMinimum<R, C>>, 
[src]

The lower triangular matrix of this decomposition.

pub fn u(&self) -> MatrixMN<N, DimMinimum<R, C>, C> where
    DefaultAllocator: Allocator<N, DimMinimum<R, C>, C>, 
[src]

The upper triangular matrix of this decomposition.

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

The row permutations of this decomposition.

pub fn unpack(
    self
) -> (PermutationSequence<DimMinimum<R, C>>, MatrixMN<N, R, DimMinimum<R, C>>, MatrixMN<N, DimMinimum<R, C>, C>) where
    DefaultAllocator: Allocator<N, R, DimMinimum<R, C>> + Allocator<N, DimMinimum<R, C>, C> + Reallocator<N, R, C, R, DimMinimum<R, C>>, 
[src]

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

impl<N: ComplexField, D: DimMin<D, Output = D>> LU<N, D, D> where
    DefaultAllocator: Allocator<N, D, D> + Allocator<(usize, usize), D>, 
[src]

pub fn solve<R2: Dim, C2: Dim, S2>(
    &self,
    b: &Matrix<N, R2, C2, S2>
) -> Option<MatrixMN<N, R2, C2>> where
    S2: Storage<N, R2, C2>,
    ShapeConstraint: SameNumberOfRows<R2, D>,
    DefaultAllocator: Allocator<N, R2, C2>, 
[src]

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<N, R2, C2, S2>
) -> bool where
    S2: StorageMut<N, R2, C2>,
    ShapeConstraint: SameNumberOfRows<R2, D>, 
[src]

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

Computes the inverse of the decomposed matrix.

Returns None if the matrix is not invertible.

pub fn try_inverse_to<S2: StorageMut<N, D, D>>(
    &self,
    out: &mut Matrix<N, D, D, S2>
) -> bool
[src]

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

Computes the determinant of the decomposed matrix.

pub fn is_invertible(&self) -> bool[src]

Indicates if the decomposed matrix is invertible.

Trait Implementations

impl<N: ComplexField, R: DimMin<C>, C: Dim> Copy for LU<N, R, C> where
    DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
    MatrixMN<N, R, C>: Copy,
    PermutationSequence<DimMinimum<R, C>>: Copy
[src]

impl<N: Clone + ComplexField, R: Clone + DimMin<C>, C: Clone + Dim> Clone for LU<N, R, C> where
    DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>, 
[src]

fn clone_from(&mut self, source: &Self)1.0.0[src]

Performs copy-assignment from source. Read more

impl<N: Debug + ComplexField, R: Debug + DimMin<C>, C: Debug + Dim> Debug for LU<N, R, C> where
    DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>, 
[src]

impl<N: ComplexField, R: DimMin<C>, C: Dim> Serialize for LU<N, R, C> where
    DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
    DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
    MatrixMN<N, R, C>: Serialize,
    PermutationSequence<DimMinimum<R, C>>: Serialize
[src]

impl<'de, N: ComplexField, R: DimMin<C>, C: Dim> Deserialize<'de> for LU<N, R, C> where
    DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
    DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
    MatrixMN<N, R, C>: Deserialize<'de>,
    PermutationSequence<DimMinimum<R, C>>: Deserialize<'de>, 
[src]

Auto Trait Implementations

impl<N, R, C> !Unpin for LU<N, R, C>

impl<N, R, C> !Sync for LU<N, R, C>

impl<N, R, C> !Send for LU<N, R, C>

impl<N, R, C> !UnwindSafe for LU<N, R, C>

impl<N, R, C> !RefUnwindSafe for LU<N, R, C>

Blanket Implementations

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

type Owned = T

The resulting type after obtaining ownership.

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

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

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<T> Borrow<T> for T where
    T: ?Sized
[src]

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

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

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]