Struct UserIterate 

pub struct UserIterate {
    pub x: Vec<f64>,
    pub z_l: Vec<f64>,
    pub z_u: Vec<f64>,
    pub g: Vec<f64>,
    pub lambda: Vec<f64>,
    pub scaling: Option<IterateScaling>,
    pub x_l_alg: Vec<f64>,
    pub x_u_alg: Vec<f64>,
    pub grad_lag_x: Vec<f64>,
}

The materialised iterate of the user’s problem (full n, full m, original g order), and its window. Defined in pounce_nlp::live_iterate so the decorators that lift it one layer per intermediate_callback forward — presolve’s above all — can reach it; re-exported here, where callers have always found it.

The active-set SQP arm installs one at every fire. The interior-point arm installs one when the TNLP asks for it (pounce_nlp::tnlp::TNLP::wants_current_iterate), built by ipm_user_iterate. Iterate of a TNLP in that TNLP’s own index spaces (full n, full m, its g order), in the units finalize_solution reports: the unscaled-Lagrangian multipliers ∇f + Jᵀλ − z_L + z_U = 0.

Fields

x: Vec<f64>

z_l: Vec<f64>

z_u: Vec<f64>

g: Vec<f64>

lambda: Vec<f64>

scaling: Option<IterateScaling>

The scaling of the problem the algorithm solves, entry by entry in this iterate’s shape (see IterateScaling); what GetIpoptCurrentIterate / GetIpoptCurrentViolations with scaled = TRUE multiply by. None: not known (the scaled readers then report the unscaled values, scale 1).

x_l_alg: Vec<f64>

The variable bounds the algorithm measures its slacks to, in this iterate’s units and shape: the declared box widened by bound_relax_factor (and moved by any safe-slack adjustment) for a column the algorithm holds; the declared bound for one it does not (a fixed variable: its value; a column presolve removed); ±∞ where the column has no such bound. Upstream’s compl_x_* is the algorithm’s slack·z, so it is measured to these. Empty: not known (the declared bounds are used). One residual difference: under honor_original_bounds (off by default) the reported x is projected into the declared box, so x − x_L^alg is the projected point’s slack, not the algorithm’s.

x_u_alg: Vec<f64>

grad_lag_x: Vec<f64>

∇f + Jᵀλ − z_L + z_U at this iterate, unscaled, in this iterate’s shape, from evaluations the algorithm already made (its own ∇L on the interior-point and SQP arms; presolve layers evaluate the inner problem from the iteration’s record). 0 at a column the algorithm does not hold (upstream ResortX(…, usefixedvals=false)). Empty: not known (GetIpoptCurrentViolations then evaluates).

Trait Implementations

impl Clone for UserIterate

fn clone(&self) -> UserIterate

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for UserIterate

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

Formats the value using the given formatter.

impl Default for UserIterate

fn default() -> UserIterate

Returns the “default value” for a type.