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<ConstraintSet, 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: ArrayBase<ViewRepr<&f64>, Dim<[usize; 1]>>, ) -> Result<ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, 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 row_column_support( &self, row: ConstraintRowId, ) -> Result<Vec<usize>, String>

The coefficient (β) columns that constraint row row acts on, ascending and in the JOINT column space of this set — the one and only sanctioned route from constraint-row space to coefficient space.

Needed because the two spaces are genuinely different (see ConstraintRowId): a consumer building a free/pinned β mask from a reduced face has row ids in hand and coefficient positions to fill, and the identity map between them is valid only for a square box carrier. The block-diagonal arm is where it visibly fails — row ids advance by each member’s nrows() while columns advance by its ncols(), so the two run at different rates the moment any member constrains fewer rows than it has coefficients.

pub fn shifted_to_delta( &self, beta: ArrayBase<ViewRepr<&f64>, Dim<[usize; 1]>>, ) -> Result<ConstraintSet, 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: ArrayBase<ViewRepr<&f64>, Dim<[usize; 1]>>, ) -> 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: ArrayBase<ViewRepr<&f64>, Dim<[usize; 1]>>, delta: ArrayBase<ViewRepr<&f64>, Dim<[usize; 1]>>, 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 max_contract_feasible_step( &self, beta: ArrayBase<ViewRepr<&f64>, Dim<[usize; 1]>>, direction: ArrayBase<ViewRepr<&f64>, Dim<[usize; 1]>>, ) -> Result<ContractFeasibleStep, ContractFeasibleStepError>

Fraction-to-boundary limit denominated in the SAME metric and at the SAME tolerance as the primal-feasibility contract (PRIMAL_FEASIBILITY_TOL) — the globalization ratio test.

The rule, per non-vacuous row, on scaled slack s = (a·β − b)/‖a‖ and scaled drift d = (a·δ)/‖a‖:

• s < −tol — the current iterate is infeasible. There is no feasible origin to step from; report it (ContractFeasibleStepError::InfeasibleIterate) rather than returning a meaningless fraction.
• d ≥ 0 — the row cannot block; a step along δ only increases slack.
• s + d ≥ −tol — the WHOLE step lands inside the feasibility band. The row does not limit it. This is the clause that max_feasible_step lacks, and its absence is gam#2719: with s == 0 the exact rule returns 0 for a drift of −1e-15, refusing a step whose endpoint the very same carrier calls feasible.
• otherwise — the row genuinely blocks. Limit at the TRUE boundary, max(s, 0) / (−d), not at the band edge: aiming at −tol every step would walk the iterate to the edge of the contract and leave it there.

The returned fraction is therefore never larger than the exact ratio test’s answer EXCEPT on steps whose whole excursion is sub-tolerance, and the worst violation any accepted step can introduce is tol — the contract, exactly.

A fraction of 0.0 is an answer, not a failure: see ContractFeasibleStep::is_blocked_by_active_face.

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 ConstraintSetReducedFace for ConstraintSet

fn reduced_face( &self, beta: ArrayView1<'_, f64>, membership_tol: f64, ) -> Result<ReducedFace, EstimationError>

impl Debug for ConstraintSet

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

Formats the value using the given formatter.

impl From<LinearInequalityConstraints> for ConstraintSet

fn from(dense: LinearInequalityConstraints) -> ConstraintSet

Converts to this type from the input type.