Struct LinearInequalityConstraints 

pub struct LinearInequalityConstraints {
    pub a: Array2<f64>,
    pub b: Array1<f64>,
}

Fields

a: Array2<f64>

b: Array1<f64>

Implementations

impl LinearInequalityConstraints

pub fn new(a: Array2<f64>, b: Array1<f64>) -> Result<Self, String>

Construct with the equal-row-count invariant enforced. The dimensions a.nrows() == b.len() are required by every downstream KKT / active-set routine; routing every construction site through this constructor eliminates a class of “rows out of sync” bugs at the type boundary.

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

Canonicalize the system Aβ ≥ b into the scale-free form every downstream tolerance assumes, PRESERVING row count and order (so cached active-set row indices and warm-start hints remain valid):

• non-finite entries are rejected (a NaN row compares as neither feasible nor infeasible and silently evades active-set logic);
• an exactly-zero row 0ᵀβ ≥ b_i is INFEASIBLE for b_i > 0 (rejected loudly); for b_i ≤ 0 it is vacuous and kept verbatim — its geometric slack is +∞, so it can never activate downstream;
• every nonzero row is normalized to unit norm, (a_i, b_i)/‖a_i‖, so b_i becomes the signed distance of the constraint hyperplane from the origin and every absolute slack / violation / rank tolerance applied later is automatically scale-relative: 1e-20·β ≥ 1e-20 and β ≥ 1 canonicalize to the same row, as they are the same half-space.

pub fn from_per_coordinate_lower_bounds( lower_bounds: &Array1<f64>, ) -> Option<Self>

Build the per-coordinate β_i >= lower_bounds[i] inequality system. Non-finite entries are treated as “no bound” and skipped; returns None when every entry is non-finite so callers can short-circuit the no-constraint case without allocating the empty A/b pair.

pub fn max_contract_feasible_step( &self, beta: ArrayView1<'_, f64>, direction: ArrayView1<'_, f64>, ) -> Result<ContractFeasibleStep, ContractFeasibleStepError>

The contract-feasible ratio test on the dense system — the identical rule crate::ConstraintSet::max_contract_feasible_step applies, reached without wrapping (and therefore cloning) A into a crate::ConstraintSet.

A dense system a caller already holds and the ConstraintSet::Dense that wraps it must give bit-identical answers, or the barrier hook and the QP that enforce the same constraint would disagree about which steps are admissible.

Trait Implementations

impl Clone for LinearInequalityConstraints

fn clone(&self) -> LinearInequalityConstraints

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LinearInequalityConstraints

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LinearInequalityConstraints

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<LinearInequalityConstraints> for ConstraintSet

fn from(dense: LinearInequalityConstraints) -> Self

Converts to this type from the input type.

impl Serialize for LinearInequalityConstraints

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

where __S: Serializer,

Serialize this value into the given Serde serializer.