Struct LowRankAugSystemSolver 

pub struct LowRankAugSystemSolver { /* private fields */ }

Implementations

impl LowRankAugSystemSolver

pub fn new(inner: Box<dyn AugSystemSolver>) -> Self

pub fn with_bypass_solver( inner: Box<dyn AugSystemSolver>, bypass: Box<dyn AugSystemSolver>, ) -> Self

Same as Self::new but routes the Hessian-free solves through their own inner solver.

Under limited-memory this solver drives its inner solver with two different (1,1) shapes: an empty W for the least-square multiplier initialization and the equality-multiplier estimates, and an n-diagonal B0 for the main primal-dual solves. StdAugSystemSolver keys its structure signature on W’s nonzero count, so the two alternate and every alternation re-runs the backend’s symbolic factorization — for MA57 with ma57_pivot_order = 5 a full MeTiS nested dissection of the whole KKT system, ~0.4 s per call on a 118 276-row model (gh#730).

Ipopt never pays this because its low-rank layer owns those solves, so its inner solver sees one shape for its whole life — IpTSymLinearSolver.cpp:182 asserts exactly that. Giving the bypass its own solver reproduces that invariant on both sides instead of on neither.

Deliberately not done by making the two shapes agree — e.g. substituting a zeroed n-diagonal for the empty W, which is what the shape proposed in gh#730 does. That is numerically exact, but it changes the pattern the backend orders, and a different ordering rounds differently: swept, it takes pooling_rt2stp under MA57 from obj = -4391.83 to -3273.95 (both “Optimal”, 25% apart) and cresc4 from 110 to 267 iterations. Two solvers hand each path exactly the matrix and the ordering it already had, so the win is free of trajectory movement rather than paid for with it.

The cost is one additional numeric factorization resident at once. That is the deliberate trade: memory is measurable and boundable, and a trajectory regression is what has repeatedly shipped here undetected (dev-notes/trajectory-regressions-and-\ the-fixture-sweep.md).

pub fn augmented_system_requires_change( &self, coeffs: &AugSysCoeffs<'_>, ) -> bool

Pure tag/scalar comparison — port of upstream AugmentedSystemRequiresChange (IpLowRankAugSystemSolver.cpp:531-599).

pub fn first_call(&self) -> bool

pub fn cache(&self) -> &AugSysCache

Trait Implementations

impl AugSystemSolver for LowRankAugSystemSolver

fn resolve( &mut self, coeffs: &AugSysCoeffs<'_>, rhs: &AugSysRhs<'_>, sol: &mut AugSysSol<'_>, ) -> ESymSolverStatus

Back-substitution against the cached factor, plus the same SMW corrections solve applies.

Without this override the trait default falls through to solve, which re-factorizes — and because PdFullSpaceSolver’s iterative refinement and its same-matrix fast path both come in through resolve, that made the majority of the augmented-system solves on the limited-memory path re-factorize a matrix that had not changed. It also left LinearSystemBackSolve reading 0.000 s for a whole run, since the only back-solve timer guard lives on the path nothing reached (gh#698).

Every condition that cannot be served falls back to solve, so this can lose an optimization but cannot change an answer — the same defensive shape as StdAugSystemSolver::resolve’s own have_factor fallback.

fn provides_inertia(&self) -> bool

Whether the underlying linear solver reports inertia.

fn number_of_neg_evals(&self) -> Index

Number of negative eigenvalues observed in the most recent factorization. Caller checks provides_inertia() first.

fn increase_quality(&mut self) -> bool

Ask the underlying solver for higher-quality pivoting.

fn last_solve_status(&self) -> ESymSolverStatus

Status of the most recent solve call.

fn set_timing_stats(&mut self, timing: Rc<TimingStatistics>)

Install the shared per-solve TimingStatistics so the linear-system factor/back-solve calls are attributed to linear_system_factorization / linear_system_back_solve. Default impl is a no-op (timing disabled); the standard solver overrides to record both fields, and composite solvers (LowRank) forward to their inner solver.

fn set_slack_scaling(&mut self, nx: Index, s_scale: &[Number])

Push the per-iterate part of linear_system_scaling=slack-based down to the linear solver’s scaling method. Default no-op; StdAugSystemSolver forwards to its TSymLinearSolver, and composite solvers forward to their inner solver.

fn handles_low_rank_w(&self) -> bool

Whether this solver can consume a LowRankUpdateSymMatrix as coeffs.w directly, applying it by Sherman-Morrison-Woodbury rather than needing an assembled triplet matrix.

fn solve( &mut self, coeffs: &AugSysCoeffs<'_>, rhs: &AugSysRhs<'_>, sol: &mut AugSysSol<'_>, check_neg_evals: bool, num_neg_evals: Index, ) -> ESymSolverStatus

One factor + back-substitution for the full 4×4 block system. check_neg_evals=true asks the linsol to verify that the observed inertia equals num_neg_evals; on mismatch the status is WrongInertia and the solution is left untouched.

fn system_dim(&self) -> Index

Dimension of the assembled augmented (KKT) system. Used by the interactive debugger to report inertia; default 0 for backends that don’t track it.

fn kkt_triplets(&self) -> Option<(Index, Vec<Index>, Vec<Index>, Vec<Number>)>

Triplets of the assembled KKT matrix (dim, irn, jcn, vals) (1-based lower triangle), for the debugger’s viz kkt. Default None for backends that don’t expose them.

fn l_factor(&self, _want_values: bool) -> Option<FactorPattern>

The LDLᵀ factor pattern (and optionally values) of the most recent factorization, for the debugger’s viz L. Default None.

fn set_diagnostics(&mut self, _diag: Rc<DiagnosticsState>)

Install the shared per-solve diagnostics state so KKT-dump sites can consult per-iter gating. Default impl is a no-op (diagnostics disabled); the standard solver overrides to wire in the dump path.

fn multi_solve( &mut self, coeffs: &AugSysCoeffs<'_>, rhs_list: &[&AugSysRhs<'_>], sol_list: &mut [&mut AugSysSol<'_>], check_neg_evals: bool, num_neg_evals: Index, ) -> ESymSolverStatus

Solve the same KKT system for nrhs right-hand sides. Default impl loops [solve]; concrete backends override only when they can amortize factorization across calls. Mirrors upstream’s AugSystemSolver::MultiSolve (IpAugSystemSolver.hpp:113-150).

fn try_resolve_many_flat( &mut self, _coeffs: &AugSysCoeffs<'_>, _packed_rhs: &mut [Number], _nrhs: usize, ) -> Option<ESymSolverStatus>

Back-substitution only against the cached factor for nrhs right-hand sides, packed in column-major layout in packed_rhs. Each column has length dim = n_x + n_s + n_y_c + n_y_d (the aug-system dim — z/v blocks are not part of this path; callers expand them via expand_bound_multipliers after the fact). Solutions overwrite packed_rhs in place.

fn try_solve_many_flat( &mut self, _coeffs: &AugSysCoeffs<'_>, _packed_rhs: &mut [Number], _nrhs: usize, _check_neg_evals: bool, _num_neg_evals: Index, ) -> Option<ESymSolverStatus>

Factorize and solve nrhs right-hand sides in a single backend call, with packed_rhs in the same column-major layout Self::try_resolve_many_flat uses. Solutions overwrite packed_rhs in place.

fn multi_solve_matches_single_solve(&self, _nrhs: usize) -> bool

Whether Self::try_resolve_many_flat with nrhs columns returns bit-identical results to nrhs separate Self::resolve calls.