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) / max(‖a_r‖, 1) restricted to non-vacuous rows, plus the arg-max row. Matches the canonicalized dense geometry (unit rows) without materializing it.

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). Rows already violated at β (beyond tol in scaled units) are reported as blocking at t = 0.

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.