Struct SqpQpData 

pub struct SqpQpData {
    pub n: usize,
    pub m: usize,
    pub h: SymTMatrix,
    pub g: Vec<Number>,
    pub a: GenTMatrix,
    pub bl: Vec<Number>,
    pub bu: Vec<Number>,
    pub xl: Vec<Number>,
    pub xu: Vec<Number>,
    pub hessian_inertia: HessianInertia,
    pub hess_inf: Number,
    /* private fields */
}

Owned linearization data for a single SQP iteration.

n / m are always the NLP’s dimensions and a its Jacobian. When the subproblem is lifted (Self::build_low_rank) the QP the solver sees is larger: h, g, bl, bu, xl, xu hold the lifted problem’s data (lengths n + r, m + r), its first n / m entries being the unlifted ones, and the lifted constraint matrix lives in the private lift.

Fields

n: usize

m: usize

h: SymTMatrix

g: Vec<Number>

a: GenTMatrix

bl: Vec<Number>

bu: Vec<Number>

xl: Vec<Number>

xu: Vec<Number>

hessian_inertia: HessianInertia

hess_inf: Number

max |∇²L_ij| of the Hessian the step is computed against — the dense one, not the lifted diagonal, so the scale-relative QP tolerances do not depend on whether the QP was lifted.

Implementations

impl SqpQpData

pub fn build( x: &[Number], grad_f: &[Number], c_vals: &[Number], bl_c: &[Number], bu_c: &[Number], xl_orig: &[Number], xu_orig: &[Number], jac_c: Triplet, hess_lag: Triplet, hessian_inertia: HessianInertia, ) -> Self

Assemble from concrete linearization arrays at iterate x.

• grad_f — ∇f(x), length n.
• c_vals — c(x), length m (may contain inequality slack values too; convention is bl_c[i] ≤ c[i] ≤ bu_c[i]).
• bl_c, bu_c — original NLP constraint bounds.
• xl_orig, xu_orig — original NLP variable bounds.
• jac_c — ∇c(x) triplet, m × n.
• hess_lag — ∇²L(x, λ_g) triplet, n × n symmetric.

pub fn build_low_rank( x: &[Number], grad_f: &[Number], c_vals: &[Number], bl_c: &[Number], bu_c: &[Number], xl_orig: &[Number], xu_orig: &[Number], jac_c: Triplet, b: &LowRankHessian, ) -> Self

Assemble the subproblem for a low-rank Hessian B = σI + Σ ±vvᵀ without forming B — see the module docs. Same arguments as Self::build otherwise.

pub fn as_qp(&self) -> QpProblem<'_>

Borrowed QpProblem view ready for pounce_qp::QpSolver::solve.

pub fn as_qp_with_row_bounds<'a>( &'a self, bl: &'a [Number], bu: &'a [Number], ) -> QpProblem<'a>

Self::as_qp with replacement general-row bounds (the second-order correction re-centres them). bl / bu must have Self::bl’s length, lifted rows included.

pub fn is_lifted(&self) -> bool

Whether the QP the solver sees is lifted.

pub fn lift_working_set(&self, w: &WorkingSet) -> WorkingSet

A working set in the NLP’s dimensions, extended for the lifted QP: the lifted rows are equalities, the lifted variables free.

pub fn unlift_solution(&self, sol: QpSolution) -> QpSolution

A QP solution back in the NLP’s dimensions: the lifted variables’ values and the lifted rows’ multipliers are dropped. Exact, not an approximation: the lifted rows only define w, so the step p and the multipliers of the original rows and bounds are those of the unlifted QP.