Struct ActivityData 

pub struct ActivityData {
    pub x_l: BoundSide,
    pub x_u: BoundSide,
    pub d_l: BoundSide,
    pub d_u: BoundSide,
    pub sigma_x: Vec<f64>,
    pub sigma_s: Vec<f64>,
    pub hessian: Rc<dyn SymMatrix>,
    pub jac_c: Rc<dyn Matrix>,
    pub jac_d: Rc<dyn Matrix>,
}

The converged quantities the activity classification reads, in the engine frame. See crate::activity for what it does with them. The barrier parameter comes from BarrierIterate::barrier_mu, and the maps and scaling from BarrierIterate::model_maps and BarrierIterate::scaling.

Fields

x_l: BoundSide

Lower variable bounds.

x_u: BoundSide

Upper variable bounds.

d_l: BoundSide

Lower bounds of the inequality rows.

d_u: BoundSide

Upper bounds of the inequality rows.

sigma_x: Vec<f64>

The barrier diagonal of the x block, one entry per variable the engine kept, both sides summed.

An engine that bounds the diagonal in no way of its own writes mult / slack from Self::x_l and Self::x_u, summed. pounce writes the diagonal it factored instead, which differs from that sum where the gh#737 ceiling capped an entry or a crossover point took the declared-bound frame (gh#654).

sigma_s: Vec<f64>

The barrier diagonal of the s block, one entry per inequality row, from Self::d_l and Self::d_u as for Self::sigma_x.

hessian: Rc<dyn SymMatrix>

The exact Hessian of the Lagrangian at the converged point.

jac_c: Rc<dyn Matrix>

The Jacobian of the equality rows at the converged point.

jac_d: Rc<dyn Matrix>

The Jacobian of the inequality rows at the converged point.

Implementations

impl ActivityData

pub fn check(&self) -> Result<(), String>

Checks the lengths agree with each other, so the classification can index without bounds failures on data an outside engine supplied.