Struct ComplementarityInfo 

pub struct ComplementarityInfo {

    pub strategy: String,
    pub accepted_by: Option<String>,
    pub fallback: Option<String>,
    pub reported: String,
    pub summary: String,
    pub solves: Vec<ComplementaritySolveInfo>,
    pub total_iterations: usize,
    pub max_abs_product: Option<f64>,
    pub certificate: Option<ComplementarityCertificateInfo>,
    pub b_stationarity: Option<ComplementarityBStationarityInfo>,
    pub escapes: usize,
    pub lifted: usize,
    pub natural_residual: Option<f64>,
    pub polish: Option<ComplementarityPolishInfo>,
    pub polish_threshold: Option<f64>,
}

The complementarity driver’s record: which formulation answered, every lowered solve it ran, and the stationarity certificate of the reported point. Keyed like Python’s info["complementarity"].

statistics.iteration_count is the iteration count of the one lowered solve whose point was reported; the driver runs several, and Self::total_iterations is what the solve cost — the same honesty rule as SecondOpinionInfo::total_iteration_count.

Fields

strategy: String

complementarity_strategy: both, exact or continuation.

accepted_by: Option<String>

The formulation whose strongly stationary answer was reported, or None when no formulation answered.

fallback: Option<String>

The formulation whose weakly stationary point was reported when no formulation answered, if that is what was reported.

reported: String

What was reported and on what grounds: answer, weak_fallback, feasible_uncertified or verdict.

summary: String

The driver’s one-line account, as printed on the console.

solves: Vec<ComplementaritySolveInfo>

Every lowered solve, in order.

total_iterations: usize

Iterations summed over every lowered solve.

max_abs_product: Option<f64>

The reported point’s complementarity violation – the largest |G·H| over one-sided pairs, the largest positive part of a mixed pair’s products – or null when it has no point (a solve refused before iteration 0).

certificate: Option<ComplementarityCertificateInfo>

The stationarity certificate of the reported point; None only if the model could not be evaluated there.

b_stationarity: Option<ComplementarityBStationarityInfo>

The B-stationarity check of the reported point: run when it is feasible and not certified S (S implies B). None when it did not run. Additive; older reports without the field deserialize unchanged.

escapes: usize

Branch NLPs that moved the reported point off a non-B-stationary one. Additive; reads 0 on reports written before the field existed.

lifted: usize

Pairs whose row was lifted into a variable (complementarity_lift): their product rows were G·w, not G·H(x). Additive; reads 0 on reports written before the field existed.

natural_residual: Option<f64>

How complementary the reported point is: the largest min(|G|, |H|) over its pairs, in the units of the pair sides. A point whose pairs are complementary to tol reads near tol; one a relaxed stage left at a nearly biactive pair reads near sqrt(τ) even when max_abs_product reads τ. null when it could not be evaluated. Additive; absent on reports written before the field existed.

polish: Option<ComplementarityPolishInfo>

The branch re-solve of a nearly biactive answer, when it ran: whether its point was taken, the residual before and after, and why it was not taken. Absent when it did not run (the answer’s natural_residual was within 10·tol, or the point was not a feasible accepted one). Additive.

polish_threshold: Option<f64>

The natural_residual above which the driver runs the branch re-solve (10·tol). A residual at or below it was left alone on purpose. Additive; absent on reports written before the field existed.

Trait Implementations

impl Clone for ComplementarityInfo

fn clone(&self) -> ComplementarityInfo

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ComplementarityInfo

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ComplementarityInfo

fn deserialize<__D>( __deserializer: __D, ) -> Result<ComplementarityInfo, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ComplementarityInfo

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.