Struct Lu 

pub struct Lu<T, F = Vec<T>, P = Vec<usize>> {
    pub n: usize,
    pub factors: F,
    pub perm: P,
    /* private fields */
}

An LU factorization with partial pivoting of an n×n matrix. factors packs L below the diagonal and U on and above it. L’s diagonal is 1 and isn’t stored. Unlike the crate’s other matrices, factors is column-major: item (i, j) is factors[j * n + i]. Row i of L U is row perm[i] of the factored matrix. lu returns one that owns its factors. LuRef borrows them.

Fields

n: usize

factors: F

perm: P

Implementations

impl<T, F: AsRef<[T]>, P: AsRef<[usize]>> Lu<T, F, P>

pub fn new(n: usize, factors: F, perm: P) -> Self

The factorization of an n×n matrix with these packed factors and row permutation.

pub fn as_ref(&self) -> LuRef<'_, T>

A view of the factors, with no copies.

impl<T: Factor, F: AsRef<[T]>, P: AsRef<[usize]>> Lu<T, F, P>

pub fn solve(&self, b: &[T], k: usize) -> Vec<T>

The solution x of a x = b, for the factored a and the n×k matrix b, as an n×k matrix.

pub fn inverse(&self) -> Vec<T>

The inverse of the factored matrix.

pub fn diagonal(&self) -> impl Iterator<Item = T> + '_

U’s diagonal.

pub fn lower(&self) -> Vec<T>

L as an n×n matrix, with ones on its diagonal and zeros above it.

pub fn upper(&self) -> Vec<T>

U as an n×n matrix, with zeros below its diagonal.

pub fn determinant(&self) -> T

The factored matrix’s determinant: the product of U’s diagonal, negated where perm is odd.

pub fn log_determinant(&self) -> (T, T::Real)

The factored matrix’s determinant as a sign and the natural logarithm of its magnitude, which can’t overflow. The sign has magnitude 1, or is 0 with a logarithm of -∞ for a singular matrix.

Trait Implementations

impl<T: Clone, F: Clone, P: Clone> Clone for Lu<T, F, P>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy, F: Copy, P: Copy> Copy for Lu<T, F, P>

impl<T: Debug, F: Debug, P: Debug> Debug for Lu<T, F, P>

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

Formats the value using the given formatter.

impl<T: PartialEq, F: PartialEq, P: PartialEq> PartialEq for Lu<T, F, P>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<T: PartialEq, F: PartialEq, P: PartialEq> StructuralPartialEq for Lu<T, F, P>