Struct ChunkedKernelDesignOperator 

pub struct ChunkedKernelDesignOperator<K: SpatialKernelEvaluator> { /* private fields */ }

Chunked kernel design operator for spatial smooths (TPS, Matérn, Duchon).

Instead of storing a dense n × k matrix, evaluates K(data[i], center[j]) on-the-fly in row chunks. Memory usage is O(chunk_size × k) instead of O(n × k).

The optional poly_basis appends polynomial columns after the kernel columns (e.g., linear polynomial for TPS identifiability).

The optional kernel_gauge restricts the kernel coefficient block through a Gauge section, so the effective design is [K_reduced | poly] instead of [K | poly].

Implementations

impl<K: SpatialKernelEvaluator> ChunkedKernelDesignOperator<K>

pub fn new( data: Arc<Array2<f64>>, centers: Arc<Array2<f64>>, kernel: K, kernel_gauge: Option<Arc<Gauge>>, poly_basis: Option<Arc<Array2<f64>>>, ) -> Result<Self, String>

Trait Implementations

impl<K: SpatialKernelEvaluator> DenseDesignOperator for ChunkedKernelDesignOperator<K>

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

Expose the cached [K_eff | poly] materialization so cross-block paths can use the Dense × Dense BLAS-3 fast path instead of falling back to chunked scalar accumulation.

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 compute_xtwy( &self, weights: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, y: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, ) -> Result<ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, String>

fn quadratic_form_diag( &self, middle: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>, ) -> Result<ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, String>

fn try_row_chunk( &self, rows: Range<usize>, ) -> Result<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>, 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], ) -> ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>

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<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>, MatrixMaterializationError>

fn to_dense_arc(&self) -> Arc<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>

Shared dense materialization via the required row-chunk API.

impl<K: SpatialKernelEvaluator> LinearOperator for ChunkedKernelDesignOperator<K>

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 xt_diag_x_signed_op( &self, weights: SignedWeightsView<'_>, ) -> Result<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>, 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 diag_gram( &self, weights: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, ) -> Result<ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, String>

fn apply_weighted_normal( &self, weights: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, vector: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, penalty: Option<&ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>, ridge: f64, ) -> ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>

fn uses_matrix_free_pcg(&self) -> bool

fn solve_system_matrix_free_pcg_try( &self, weights: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, rhs: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, penalty: Option<&ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>, baseridge: f64, ) -> Result<ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, String>

fn solve_system_matrix_free_pcg_with_info_try( &self, weights: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, rhs: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, penalty: Option<&ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>, baseridge: f64, ) -> Result<(ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, PcgSolveInfo), String>

fn factorize_system( &self, weights: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, penalty: Option<&ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>, ) -> Result<Box<dyn FactorizedSystem>, String>

fn solve_system( &self, weights: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, rhs: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, penalty: Option<&ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>, ) -> Result<ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, String>

fn solve_systemwith_policy( &self, weights: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, rhs: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, penalty: Option<&ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>, ridge_floor: f64, ridge_policy: RidgePolicy, ) -> Result<ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, String>