Struct TermCollectionDesign 

pub struct TermCollectionDesign {
    pub design: DesignMatrix,
    pub penalties: Vec<BlockwisePenalty>,
    pub nullspace_dims: Vec<usize>,
    pub penaltyinfo: Vec<PenaltyBlockInfo>,
    pub dropped_penaltyinfo: Vec<DroppedPenaltyBlockInfo>,
    pub coefficient_lower_bounds: Option<Array1<f64>>,
    pub linear_constraints: Option<LinearInequalityConstraints>,
    pub intercept_range: Range<usize>,
    pub linear_ranges: Vec<(String, Range<usize>)>,
    pub random_effect_ranges: Vec<(String, Range<usize>)>,
    pub random_effect_levels: Vec<(String, Vec<u64>)>,
    pub smooth: SmoothDesign,
}

Fields

design: DesignMatrix

The full design matrix.

Prefer a true sparse matrix when every block is sparse-compatible. If the collection already contains intrinsically sparse blocks, preserve that storage and let PIRLS decide later whether the penalized system is sparse-native eligible. Purely dense materialized blocks still fall back to the lazy block operator when sparse storage would just re-encode a dense matrix.

penalties: Vec<BlockwisePenalty>

nullspace_dims: Vec<usize>

penaltyinfo: Vec<PenaltyBlockInfo>

dropped_penaltyinfo: Vec<DroppedPenaltyBlockInfo>

coefficient_lower_bounds: Option<Array1<f64>>

Optional global coefficient lower bounds for constrained fitting. Length equals design.ncols() when present. Unconstrained entries are -inf.

linear_constraints: Option<LinearInequalityConstraints>

Optional global inequality constraints: A * beta >= b.

intercept_range: Range<usize>

linear_ranges: Vec<(String, Range<usize>)>

random_effect_ranges: Vec<(String, Range<usize>)>

random_effect_levels: Vec<(String, Vec<u64>)>

smooth: SmoothDesign

Implementations

impl TermCollectionDesign

pub fn penalties_as_penalty_matrix(&self) -> Vec<PenaltyMatrix>

Convert blockwise penalties to PenaltyMatrix::Blockwise without expanding to p_total × p_total. This is the preferred path for family modules that accept Vec<PenaltyMatrix>.

pub fn num_penalties(&self) -> usize

Number of penalty blocks.

pub fn realize_coefficient_groups( &self, groups: &[CoefficientGroupSpec], base_prior: &RhoPrior, ) -> Result<RealizedCoefficientGroups, BasisError>

Resolve coefficient groups against this design’s global coefficient layout and append their penalties after the existing term penalties.

pub fn kronecker_penalty_system(&self) -> Option<KroneckerPenaltySystem>

Extract a KroneckerPenaltySystem when the model’s only smooth term is a single Kronecker-factored tensor.

This is a deliberate single-tensor fast path, not a partial feature: any other shape — zero Kronecker terms, several of them, or a tensor mixed with non-tensor smooth terms — is served correctly by the standard block-separable assembly, so this returns None and the caller falls back to it. The two former conditions (len != 1 and “a non-Kronecker smooth term exists”) are jointly equivalent to “the sole smooth term is Kronecker”, which the slice pattern below expresses directly in one pass.

Trait Implementations

impl Clone for TermCollectionDesign

fn clone(&self) -> TermCollectionDesign

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TermCollectionDesign

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

Formats the value using the given formatter.