Struct BlockwisePenalty 

pub struct BlockwisePenalty {
    pub col_range: Range<usize>,
    pub local: Array2<f64>,
    pub prior_mean: CoefficientPriorMean,
    pub structure_hint: Option<PenaltyStructureHint>,
    pub op: Option<Arc<dyn PenaltyOp>>,
}

A penalty matrix stored at its natural block size together with the column range it occupies in the global coefficient vector.

Instead of embedding every penalty into a full p_total × p_total dense matrix filled with zeros, we keep the compact local matrix and reconstruct the global view only when a downstream consumer explicitly requires it.

Fields

col_range: Range<usize>

Column range in the global coefficient vector that this penalty covers.

local: Array2<f64>

The local penalty matrix — dimensions block_p × block_p where block_p = col_range.len().

prior_mean: CoefficientPriorMean

Optional nonzero centering vector for this coefficient block.

structure_hint: Option<PenaltyStructureHint>

Optional structural hint so downstream spectral/logdet code can stay block-local or factorized without reverse-engineering the matrix.

op: Option<Arc<dyn PenaltyOp>>

Optional operator-form handle bit-equivalent to local. Populated when the originating closed-form factory emitted an op-form penalty so exact operator algebra can use matvec instead of materializing the dense block_p × block_p Gram. None for ordinary dense penalties.

Implementations

impl BlockwisePenalty

pub fn new(col_range: Range<usize>, local: Array2<f64>) -> Self

Create a new blockwise penalty.

pub fn with_prior_mean(self, prior_mean: CoefficientPriorMean) -> Self

pub fn with_op(self, op: Option<Arc<dyn PenaltyOp>>) -> Self

Attach an op-form penalty handle bit-equivalent to local.

pub fn ridge(col_range: Range<usize>, scale: f64) -> Self

pub fn kronecker( col_range: Range<usize>, local: Array2<f64>, factors: Vec<Array2<f64>>, ) -> Self

pub fn to_global(&self, p_total: usize) -> Array2<f64>

Expand this blockwise penalty into a full p_total × p_total dense matrix (mostly zeros). Use sparingly — the whole point of blockwise storage is to avoid this allocation.

pub fn to_penalty_matrix(&self, total_dim: usize) -> PenaltyMatrix

Convert into a blockwise gam_problem::PenaltyMatrix without expanding to full dimensions.

pub fn block_size(&self) -> usize

The block size of this penalty.

Trait Implementations

impl Clone for BlockwisePenalty

fn clone(&self) -> BlockwisePenalty

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BlockwisePenalty

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

Formats the value using the given formatter.