Enum ConstraintSet 

pub enum ConstraintSet {
    Dense(LinearInequalityConstraints),
    KhatriRaoCone(KhatriRaoConeConstraints),
    BlockDiagonal {
        blocks: Vec<PlacedConstraintBlock>,
        total_cols: usize,
    },
}

Closed union of the constraint carriers the blockwise solvers accept.

Variants

Dense(LinearInequalityConstraints)

Explicit rows, exactly as today.

KhatriRaoCone(KhatriRaoConeConstraints)

Factored Khatri-Rao nonnegativity cone.

BlockDiagonal

Block-diagonal composition over disjoint column ranges of a joint coefficient vector (the multi-block joint-Newton assembly). Row ids are the concatenation of the member row ids in order.

Fields

blocks: Vec<PlacedConstraintBlock>

total_cols: usize

Implementations

impl ConstraintSet

pub fn block_diagonal( blocks: Vec<PlacedConstraintBlock>, total_cols: usize, ) -> Result<Self, String>

Validated block-diagonal composition: member column ranges must lie inside the joint width and must not overlap.

pub fn nrows(&self) -> usize

pub fn ncols(&self) -> usize

pub fn values(&self, beta: ArrayView1<'_, f64>) -> Result<Array1<f64>, String>

Raw constraint values Aβ (dense) / factored functional values (cone).

pub fn bound(&self, row: usize) -> Result<f64, String>

Right-hand sides (b dense; cone bounds are zero unless delta-shifted).

pub fn row_norm(&self, row: usize) -> Result<f64, String>

pub fn shifted_to_delta( &self, beta: ArrayView1<'_, f64>, ) -> Result<Self, String>

The same constraint system expressed in delta coordinates around beta: A(β + δ) ≥ b ⇔ Aδ ≥ b − Aβ. The matrix carrier is shared; only the O(nrows) bounds change.

pub fn max_scaled_violation( &self, beta: ArrayView1<'_, f64>, ) -> Result<(f64, Option<usize>), String>

Scaled violation sweep: max_r (b_r − (Aβ)_r) / ‖a_r‖ restricted to non-vacuous rows, plus the arg-max row. Matches the canonicalized dense geometry (unit rows) without materializing it.

This is THE feasibility metric: β is feasible exactly when the value returned here is at or below PRIMAL_FEASIBILITY_TOL.

A vacuous row (‖a‖ = 0) with a bound at or below zero is 0 ≥ b, true for every β, and contributes nothing. A vacuous row with a POSITIVE bound is 0 ≥ b > 0: no β satisfies it, so its violation is infinite and the feasible set is empty. Reporting that as +∞ — rather than skipping the row — is what makes this metric agree with ConstraintSetOps::scaled_slack, which already answers −∞ for exactly this row, and keeps a gate built on this metric from silently admitting an unsatisfiable system.

A row that cannot be decided by comparison — a non-finite row norm, bound or a·β — is refused rather than skipped (gam#2721): feasibility of an iterate that is not a number is undefined, and violation > worst being false for NaN would report the neutral 0.0 — “nothing is violated” — for exactly the iterate this metric exists to catch.

pub fn max_feasible_step( &self, beta: ArrayView1<'_, f64>, delta: ArrayView1<'_, f64>, skip_rows: &[usize], ) -> Result<(f64, Option<usize>), String>

Largest t ∈ [0, 1] with β + t·δ feasible for every row, together with the first blocking row (the EXACT ratio test of a primal active-set method — zero tolerance, raw slacks). Rows already violated at β are reported as blocking at t = 0.

This is the pivot rule: it answers “where does this chord cross a hyperplane in exact arithmetic”, and its consumers (the feasible-chord clipper) want exactly that. It is NOT the rule for sizing a Newton step — a globalization that demands exact feasibility rejects steps this carrier’s own contract calls feasible. Use ConstraintSet::max_contract_feasible_step for that.

Like the contract rule, this one is TOTAL (gam#2721): a row that cannot be decided by comparison — a non-finite row norm, bound, a·β or a·δ — and that was not explicitly skipped is refused, because every comparison it would otherwise feed is false for NaN and the answer would be an unlimited t = 1.

pub fn gather_rows( &self, rows: &[usize], ) -> Result<LinearInequalityConstraints, String>

Materialize the requested rows densely (KKT systems on the active set).

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

Exact dense equivalent of the whole set (tests / small systems only).

Trait Implementations

impl Clone for ConstraintSet

fn clone(&self) -> ConstraintSet

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ConstraintSet

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

Formats the value using the given formatter.

impl From<LinearInequalityConstraints> for ConstraintSet

fn from(dense: LinearInequalityConstraints) -> Self

Converts to this type from the input type.