# [−][src]Struct na::linalg::FullPivLU

`pub struct FullPivLU<N, R, C> where    C: Dim,    N: ComplexField,    R: DimMin<C>,    DefaultAllocator: Allocator<N, R, C>,    DefaultAllocator: Allocator<(usize, usize), <R as DimMin<C>>::Output, U1>,  { /* fields omitted */ }`

LU decomposition with full row and column pivoting.

## Methods

### `impl<N, R, C> FullPivLU<N, R, C> where    C: Dim,    N: ComplexField,    R: DimMin<C>,    DefaultAllocator: Allocator<N, R, C>,    DefaultAllocator: Allocator<(usize, usize), <R as DimMin<C>>::Output, U1>, `[src]

#### `pub fn new(    matrix: Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>) -> FullPivLU<N, R, C>`[src]

Computes the LU decomposition with full pivoting of `matrix`.

This effectively computes `P, L, U, Q` such that `P * matrix * Q = LU`.

#### `pub fn l(    &self) -> Matrix<N, R, <R as DimMin<C>>::Output, <DefaultAllocator as Allocator<N, R, <R as DimMin<C>>::Output>>::Buffer> where    DefaultAllocator: Allocator<N, R, <R as DimMin<C>>::Output>, `[src]

The lower triangular matrix of this decomposition.

#### `pub fn u(    &self) -> Matrix<N, <R as DimMin<C>>::Output, C, <DefaultAllocator as Allocator<N, <R as DimMin<C>>::Output, C>>::Buffer> where    DefaultAllocator: Allocator<N, <R as DimMin<C>>::Output, C>, `[src]

The upper triangular matrix of this decomposition.

#### `pub fn p(&self) -> &PermutationSequence<<R as DimMin<C>>::Output>`[src]

The row permutations of this decomposition.

#### `pub fn q(&self) -> &PermutationSequence<<R as DimMin<C>>::Output>`[src]

The column permutations of this decomposition.

#### `pub fn unpack(    self) -> (PermutationSequence<<R as DimMin<C>>::Output>, Matrix<N, R, <R as DimMin<C>>::Output, <DefaultAllocator as Allocator<N, R, <R as DimMin<C>>::Output>>::Buffer>, Matrix<N, <R as DimMin<C>>::Output, C, <DefaultAllocator as Allocator<N, <R as DimMin<C>>::Output, C>>::Buffer>, PermutationSequence<<R as DimMin<C>>::Output>) where    DefaultAllocator: Allocator<N, R, <R as DimMin<C>>::Output>,    DefaultAllocator: Allocator<N, <R as DimMin<C>>::Output, C>, `[src]

The two matrices of this decomposition and the row and column permutations: `(P, L, U, Q)`.

### `impl<N, D> FullPivLU<N, D, D> where    D: DimMin<D, Output = D>,    N: ComplexField,    DefaultAllocator: Allocator<N, D, D>,    DefaultAllocator: Allocator<(usize, usize), D, U1>, `[src]

#### `pub fn solve<R2, C2, S2>(    &self,     b: &Matrix<N, R2, C2, S2>) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>> where    C2: Dim,    R2: Dim,    S2: StorageMut<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 the decomposed matrix is not invertible.

#### `pub fn solve_mut<R2, C2, S2>(&self, b: &mut Matrix<N, R2, C2, S2>) -> bool where    C2: Dim,    R2: Dim,    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<Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>>`[src]

Computes the inverse of the decomposed matrix.

Returns `None` if the decomposed matrix is not invertible.

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

Indicates if the decomposed matrix is invertible.

#### `pub fn determinant(&self) -> N`[src]

Computes the determinant of the decomposed matrix.

## Trait Implementations

### `impl<N, R, C> Clone for FullPivLU<N, R, C> where    C: Dim + Clone,    N: Clone + ComplexField,    R: DimMin<C> + Clone,    DefaultAllocator: Allocator<N, R, C>,    DefaultAllocator: Allocator<(usize, usize), <R as DimMin<C>>::Output, U1>, `[src]

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

Performs copy-assignment from `source`. Read more

## Blanket Implementations

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

#### `type Error = Infallible`

The type returned in the event of a conversion error.

### `impl<T, U> TryInto 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> Same for T`

#### `type Output = T`

Should always be `Self`