Enum DenseDesignMatrix 

pub enum DenseDesignMatrix {
    Materialized(Arc<Array2<f64>>),
    Lazy(LazyDense),
}

Variants

Materialized(Arc<Array2<f64>>)

Lazy(LazyDense)

Implementations

impl DenseDesignMatrix

pub fn cache_identity(&self) -> usize

Stable identity for cache keying.

Returns the address of the inner shared Arc, which Clone shares by reference. Two DenseDesignMatrix values produced by cloning the same origin (e.g. the k per-coordinate GlmCurvatureCorrectionOperators all built from one converged design) report the same identity, so a X·F projection memoized under this id is reused across them within a single outer REML evaluation instead of being re-streamed once per coordinate.

pub fn nrows(&self) -> usize

pub fn ncols(&self) -> usize

pub fn as_dense_ref(&self) -> Option<&Array2<f64>>

pub const fn is_materialized_dense(&self) -> bool

pub const fn is_operator_backed(&self) -> bool

pub fn to_dense(&self) -> Array2<f64>

pub fn to_dense_arc(&self) -> Arc<Array2<f64>>

pub fn try_to_dense_arc( &self, context: &str, ) -> Result<Arc<Array2<f64>>, String>

pub fn try_to_dense_arc_with_policy( &self, context: &str, policy: &ResourcePolicy, ) -> Result<Arc<Array2<f64>>, String>

Policy-aware variant of Self::try_to_dense_arc.

Uses the supplied policy’s max_single_materialization_bytes cap when deciding whether to densify a lazy operator-backed design. The default try_to_dense_arc always uses ResourcePolicy::default_library() (the 1 GiB cap suitable for ad-hoc dense conversions, matching the CoefficientTransformOperator::MATERIALIZE_MAX_BYTES ceiling); cache layers that have their own larger cap (e.g. CoefficientTransformOperator::MATERIALIZE_MAX_BYTES) can call this method to consume the inner under their own threshold without forcing the conservative default on every consumer.

pub fn try_row_chunk( &self, rows: Range<usize>, ) -> Result<Array2<f64>, MatrixMaterializationError>

pub fn row_chunk_into( &self, rows: Range<usize>, out: ArrayViewMut2<'_, f64>, ) -> Result<(), MatrixMaterializationError>

Trait Implementations

impl Clone for DenseDesignMatrix

fn clone(&self) -> DenseDesignMatrix

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DenseDesignMatrix

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

Formats the value using the given formatter.

impl DenseDesignOperator for DenseDesignMatrix

fn compute_xtwy( &self, weights: &Array1<f64>, y: &Array1<f64>, ) -> Result<Array1<f64>, String>

fn quadratic_form_diag( &self, middle: &Array2<f64>, ) -> Result<Array1<f64>, String>

fn as_dense_ref(&self) -> Option<&Array2<f64>>

Borrow dense storage when this operator already owns it.

fn materialization_policy(&self) -> Option<MaterializationPolicy>

Materialization contract captured when this operator-backed design was selected. Composite operators propagate the strictest contract of their inputs so a later caller using a more permissive default cannot reverse an upstream streamed-storage decision.

fn row_chunk_into( &self, rows: Range<usize>, out: ArrayViewMut2<'_, f64>, ) -> Result<(), MatrixMaterializationError>

Fill a dense row chunk without materializing the full matrix. Required: every implementor must provide row-local access here.

fn to_dense(&self) -> Array2<f64>

Materialize the full dense matrix. Operators that exist precisely to avoid materialization should still support this for fallback paths, diagnostics, and prediction.

fn to_dense_arc(&self) -> Arc<Array2<f64>>

Shared dense materialization via the required row-chunk API.

fn try_row_chunk( &self, rows: Range<usize>, ) -> Result<Array2<f64>, MatrixMaterializationError>

Extract a dense row chunk without materializing the full matrix. Non-panicking owned-chunk API built on top of row_chunk_into.

fn apply_columns(&self, cols: &[usize]) -> Array2<f64>

Batched column extraction: returns an nrows × cols.len() dense block whose k-th column is apply(e_{cols[k]}).

fn estimated_dense_bytes(&self) -> usize

fn try_to_dense_with_policy( &self, policy: &MaterializationPolicy, context: &'static str, ) -> Result<Arc<Array2<f64>>, MatrixMaterializationError>

fn try_to_dense_governed_with_policy( &self, policy: &MaterializationPolicy, context: &'static str, ) -> Result<Governed<Array2<f64>>, MatrixMaterializationError>

Materialize through the process-wide governor and couple the returned matrix to its reservation. Unlike the older Arc-returning helper, this cannot release its ledger charge while the dense allocation is live.

impl From<Arc<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>> for DenseDesignMatrix

fn from(value: Arc<Array2<f64>>) -> Self

Converts to this type from the input type.

impl<T> From<Arc<T>> for DenseDesignMatrix

where T: DenseDesignOperator + 'static,

fn from(value: Arc<T>) -> Self

Converts to this type from the input type.

impl From<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>> for DenseDesignMatrix

fn from(value: Array2<f64>) -> Self

Converts to this type from the input type.

impl From<DenseDesignMatrix> for DesignMatrix

fn from(value: DenseDesignMatrix) -> Self

Converts to this type from the input type.

impl LinearOperator for DenseDesignMatrix

fn nrows(&self) -> usize

fn ncols(&self) -> usize

fn apply(&self, vector: &Array1<f64>) -> Array1<f64>

fn apply_transpose(&self, vector: &Array1<f64>) -> Array1<f64>

fn diag_xtw_x(&self, weights: &Array1<f64>) -> Result<Array2<f64>, String>

fn diag_gram(&self, weights: &Array1<f64>) -> Result<Array1<f64>, String>

fn apply_weighted_normal( &self, weights: FiniteSignedWeightsView<'_>, vector: &Array1<f64>, penalty: Option<&Array2<f64>>, ridge: f64, ) -> Array1<f64>

fn uses_matrix_free_pcg(&self) -> bool

fn xt_diag_x_signed_op( &self, weights: FiniteSignedWeightsView<'_>, ) -> Result<Array2<f64>, String>

Observed-Hessian / non-canonical-link Gram: XᵀWX with sign-honest weights. Returns a dense Array2<f64> because the result is symmetric but not guaranteed PSD (so consumers cannot assume the SymmetricMatrix PSD contract). Default impl delegates to diag_xtw_x for legacy operators; overriding impls may take a sign-aware fast path.

fn xt_diag_x_psd_op( &self, weights: PsdWeightsView<'_>, ) -> Result<SymmetricMatrix, String>

PSD-precondition Gram: XᵀWX with w ≥ 0 discharged at the PsdWeightsView constructor. Returns a typed SymmetricMatrix so downstream consumers can route through PSD-only solvers (Cholesky). Default impl wraps the signed path’s Array2 in SymmetricMatrix::Dense.

fn solve_system_matrix_free_pcg_try( &self, weights: &Array1<f64>, rhs: &Array1<f64>, penalty: Option<&Array2<f64>>, baseridge: f64, ) -> Result<Array1<f64>, String>

fn solve_system_matrix_free_pcg_with_info_try( &self, weights: &Array1<f64>, rhs: &Array1<f64>, penalty: Option<&Array2<f64>>, baseridge: f64, ) -> Result<(Array1<f64>, PcgSolveInfo), String>

fn factorize_system( &self, weights: &Array1<f64>, penalty: Option<&Array2<f64>>, ) -> Result<Box<dyn FactorizedSystem>, String>

fn solve_system( &self, weights: &Array1<f64>, rhs: &Array1<f64>, penalty: Option<&Array2<f64>>, ) -> Result<Array1<f64>, String>

fn solve_systemwith_policy( &self, weights: &Array1<f64>, rhs: &Array1<f64>, penalty: Option<&Array2<f64>>, ridge_floor: f64, ridge_policy: RidgePolicy, ) -> Result<Array1<f64>, String>