Struct LuSolver 

pub struct LuSolver { /* private fields */ }

Available on crate feature backend-faer only.

LU solver using full pivoting from Faer.

Stores the LU factorization for reuse (if desired).

Implementations

impl LuSolver

pub fn new() -> Self

Create a new LU solver (no factorization yet).

pub fn solve_cached(&self, b: &[f64], x: &mut [f64])

Solve using the cached LU factorization.

Panics

Panics if called before any factorization has been performed.

Arguments

• b - Right-hand side vector
• x - Output vector (solution)

Trait Implementations

impl Default for LuSolver

fn default() -> Self

Returns the “default value” for a type.

impl LinearSolver<Mat<Own<f64>>, Vec<f64>> for LuSolver

fn solve( &mut self, a: &Mat<f64>, pc: Option<&(dyn Preconditioner<Mat<f64>, Vec<f64>> + '_)>, b: &Vec<f64>, x: &mut Vec<f64>, _pc_side: PcSide, _comm: &UniverseComm, monitors: Option<&[Box<MonitorCallback<Self::Scalar>>]>, _work: Option<&mut Workspace>, ) -> Result<SolveStats<f64>, KError>

Solve Ax = b using LU factorization (full pivoting).

Arguments

• a - Matrix (Faer Mat)
• pc - (Unused) Preconditioner (not supported for direct solvers)
• b - Right-hand side vector
• x - On input: ignored; on output: solution vector
• comm - Communicator for parallel operations (unused for direct solvers)
• monitors - Optional callbacks to invoke at each iteration
• work - Optional workspace (unused for direct solvers)

Returns

• Ok(SolveStats) (always converged in 1 iteration)

type Error = KError

type Scalar = f64

fn setup_workspace(&mut self, _work: &mut Workspace)

fn solve_simple( &mut self, a: &M, pc: Option<&(dyn Preconditioner<M, V> + '_)>, b: &V, x: &mut V, pc_side: PcSide, comm: &UniverseComm, ) -> Result<SolveStats<Self::Scalar>, Self::Error>

where Self: Sized,

fn solve_with_monitors( &mut self, a: &M, pc: Option<&(dyn Preconditioner<M, V> + '_)>, b: &V, x: &mut V, pc_side: PcSide, comm: &UniverseComm, monitors: &[Box<MonitorCallback<Self::Scalar>>], ) -> Result<SolveStats<Self::Scalar>, Self::Error>

where Self: Sized,

fn solve_with_workspace( &mut self, a: &M, pc: Option<&(dyn Preconditioner<M, V> + '_)>, b: &V, x: &mut V, pc_side: PcSide, comm: &UniverseComm, work: &mut Workspace, ) -> Result<SolveStats<Self::Scalar>, Self::Error>

where Self: Sized,