Struct PdSensBacksolver 

pub struct PdSensBacksolver { /* private fields */ }

Adapter from PdFullSpaceSolver to SensBacksolver. Holds owning clones of the four pieces of the algorithm’s converged state, plus the 8-block iterate template used to allocate fresh RHS / LHS vectors.

The PD solver lives behind an Rc<RefCell<…>> because SensBacksolver::solve is &self but the upstream signature for PdFullSpaceSolver::solve is &mut self (it caches the last-solve dependency tags and the augsys-improved flag). The RefCell is single-thread-only, single-borrow, exactly matching the call pattern from pounce-sensitivity’s pipeline.

Owning (rather than borrowing) the four handles is what lets a PdSensBacksolver outlive the on_converged callback frame — required by the public Solver session API in pounce-algorithm, which retains the backsolver for repeated parametric_step / kkt_solve / compute_reduced_hessian calls after the IPM has returned. The data, cq, and nlp handles are already Rc<RefCell<…>> cheap-clone handles upstream, so this carries no allocation overhead.

Implementations

impl PdSensBacksolver

pub fn new( data: &IpoptDataHandle, cq: &IpoptCqHandle, nlp: &Rc<RefCell<dyn IpoptNlp>>, pd: Rc<RefCell<PdFullSpaceSolver>>, ) -> Result<Self, ()>

Construct from the four handles handed in by the on_converged callback. Returns Err(()) if data has no curr (i.e. the algorithm never reached an iterate — should not happen on SolveSucceeded).

pub fn block_dims(&self) -> [usize; 8]

Block dimensions of the compound KKT vector at convergence, in (x, s, y_c, y_d, z_l, z_u, v_l, v_u) order. Sum equals SensBacksolver::dim. Useful when a caller needs to compute the flat offset of a non-x block (e.g. n_x + n_s for the start of the equality-multiplier y_c block).

impl PdSensBacksolver

pub fn solve_many( &self, rhs_flat: &[Number], lhs_flat: &mut [Number], n_rhs: usize, ) -> bool

Batched-RHS back-solve over the held factor. rhs_flat and lhs_flat are row-major (n_rhs, dim) buffers. Equivalent to looping SensBacksolver::solve over each row but reuses one frozen IteratesVector for the RHS and one IteratesVectorMut for the result across all n_rhs calls into PdFullSpaceSolver::solve. The pack step writes into the existing DenseVector storage via Rc::get_mut + set_values, and the unpack step reads it back via values() /scalar() — skipping the per-call 8-block make_new_zeroed (Box alloc) in pack and the per-block expanded_values() Vec alloc in unpack that otherwise dominate the held-factor back-solve cost under jax.jacrev over a JaxProblem solve (pounce#77 follow-up).

The matrix and perturbation state inside PdFullSpaceSolver are unchanged across calls, so each iteration hits the cached fast path in solve_once (uptodate && !pretend_singular).

Trait Implementations

impl Clone for PdSensBacksolver

fn clone(&self) -> PdSensBacksolver

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl SensBacksolver for PdSensBacksolver

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: &[Number], lhs: &mut [Number]) -> 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().