Struct SparseLu 

pub struct SparseLu { /* private fields */ }

A sparse LU that analyzes a pattern once and refactors it on every solve, with its backend picked by a LuBackend.

Starts empty. analyze builds the symbolic factorization; the solves reuse it until reset. The same precondition as LinearSolver holds: every solve must present the pattern that was analyzed, in the same order.

Implementations

impl SparseLu

pub fn new(backend: LuBackend) -> Self

pub fn backend(&self) -> LuBackend

pub fn is_analyzed(&self) -> bool

Whether a symbolic factorization is cached.

pub fn analyze(&mut self, n: usize, entries: &[(usize, usize, f64)]) -> bool

Analyzes entries’ pattern and factors it, replacing anything cached. false if the pattern is structurally invalid or the matrix singular, in which case nothing is cached.

pub fn adopt_storage_order(&mut self) -> Option<Vec<usize>>

Asks the analyzed backend to take values in its own storage order from now on, so a caller that can write them that way spares it a copy per solve. Returns order, where order[k] is the index, in the entries analyze was given, of the value position k takes; the caller reorders its values to match, once, and every later factor_and_solve_values and factor_and_solve presents them so.

None, changing nothing, for a backend without one fixed layout (faer, PARDISO), for duplicate positions, or before analyze. The two KLUs say yes: copying the values into their column-compressed layout cost a tenth of a warm Newton solve.

pub fn storage_order(&self) -> Option<&[usize]>

The order adopted by adopt_storage_order, if one is in force.

pub fn reset(&mut self)

Discards the cached factorization, so the next solve needs a fresh analyze.

pub fn factor_and_solve( &mut self, entries: &[(usize, usize, f64)], rhs: &[f64], ) -> Option<Vec<f64>>

See LinearSolver::factor_and_solve. None if nothing is analyzed.

pub fn factor_and_solve_values( &mut self, values: &[f64], rhs: &[f64], ) -> Option<Vec<f64>>

See LinearSolver::factor_and_solve_values. None if nothing is analyzed.