Struct DenseLuBacksolver 

pub struct DenseLuBacksolver { /* private fields */ }

Synthetic dense-LU backsolver. Used in this crate’s tests to validate the sensitivity math against known-good linear-algebra answers without standing up the full pounce IPM. Phase B.2 ships a real pounce-algorithm-backed implementation; this stays for regression tests and as a reference for the trait contract.

Stores a row-major n × n matrix and reuses an in-place Gaussian-elimination LU factor with partial pivoting. Numerical stability is fine for the small problem sizes the unit tests exercise (n ≤ 16).

Implementations

impl DenseLuBacksolver

pub fn from_dense( n: usize, a_row_major: &[f64], ) -> Result<DenseLuBacksolver, ()>

Build from a row-major n × n matrix. Returns Err(()) if the matrix is exactly singular at LU time (zero pivot after pivoting).

Trait Implementations

impl Clone for DenseLuBacksolver

fn clone(&self) -> DenseLuBacksolver

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DenseLuBacksolver

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

Formats the value using the given formatter.

impl SensBacksolver for DenseLuBacksolver

fn dim(&self) -> usize

Size of the linear system in entries (length of lhs and rhs). The backsolver’s notion of “full state” — pounce’s IPM uses the compound (x, s, λ_c, λ_d, z_l, z_u, v_l, v_u) concatenation here.

fn solve(&self, rhs: &[f64], lhs: &mut [f64]) -> bool

Solve K · lhs = rhs. The implementation may use rhs as scratch; callers should treat it as moved-from on return. lhs must have length self.dim().

fn natural_units_factor(&self) -> Option<&[f64]>

Per-row factor carrying a quantity read off the converged iterate into the units Self::solve answers in, indexed by compound KKT row. None when the solve ran unscaled, which is the identity.

fn bound_rows(&self) -> Option<&[BoundRow]>

The variable behind each bound-multiplier row. None when the backsolver cannot report it, which leaves crate::boundcheck::refine_step_onto_bounds with no way to release and so pinning only.

fn solve_released( &self, _released: &[usize], _rhs: &[f64], _lhs: &mut [f64], ) -> bool

Solve against the system with the bounds named by released – compound multiplier rows – taken out of the active set.

fn solve_released_step( &self, _released: &[usize], _rhs: &[f64], _lhs: &mut [f64], ) -> bool

Self::solve_released against a parametric right-hand side, which additionally needs the released multipliers moved onto their variables’ x rows.

fn solve_released_pinned( &self, _released: &[usize], _pinned: &[usize], _rhs: &[f64], _lhs: &mut [f64], ) -> bool

Self::solve_released with each primal KKT row in pinned carrying an extra diagonal stiff enough to hold that coordinate in place.

fn supports_release(&self) -> bool

Whether Self::solve_released is implemented.