Struct Lu 

pub struct Lu<const D: usize> { /* private fields */ }

LU decomposition (PA = LU) with partial pivoting.

Implementations

impl<const D: usize> Lu<D>

pub const fn solve_vec(&self, b: Vector<D>) -> Result<Vector<D>, LaError>

Solve A x = b using this LU factorization.

solve_vec performs floating-point forward/back substitution and does not provide a certified absolute rounding-error bound for the returned solution. Callers should not expect an absolute error bound like Matrix::det_errbound or the ERR_COEFF_* determinant constants provide.

Examples

use la_stack::prelude::*;

let a = Matrix::<2>::try_from_rows([[1.0, 2.0], [3.0, 4.0]])?;
let lu = a.lu(DEFAULT_PIVOT_TOL)?;

let b = Vector::<2>::try_new([5.0, 11.0])?;
let x = lu.solve_vec(b)?.into_array();

assert!((x[0] - 1.0).abs() <= 1e-12);
assert!((x[1] - 2.0).abs() <= 1e-12);

Errors

Returns LaError::NonFinite if the right-hand side contains NaN/infinity or a computed substitution intermediate overflows to NaN or infinity. The right-hand side is revalidated at this boundary before entering substitution; public callers normally encounter the same rejection earlier through Vector::try_new.

pub const fn det(&self) -> Result<f64, LaError>

Determinant of the original matrix.

Examples

use la_stack::prelude::*;

let a = Matrix::<2>::try_from_rows([[1.0, 2.0], [3.0, 4.0]])?;
let lu = a.lu(DEFAULT_PIVOT_TOL)?;

let det = lu.det()?;
assert!((det - (-2.0)).abs() <= 1e-12);

Errors

Returns LaError::NonFinite if the determinant product overflows to NaN or infinity.

Trait Implementations

impl<const D: usize> Clone for Lu<D>

fn clone(&self) -> Lu<D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const D: usize> Copy for Lu<D>

impl<const D: usize> Debug for Lu<D>

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

Formats the value using the given formatter.

impl<const D: usize> PartialEq for Lu<D>

fn eq(&self, other: &Lu<D>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const D: usize> StructuralPartialEq for Lu<D>