Struct SparseDirectionalHyperOperator 

pub struct SparseDirectionalHyperOperator { /* private fields */ }

Operator-backed fixed-β Hessian drift for sparse-exact τ coordinates.

This stays in the original sparse/native coefficient basis and computes the exact first-order τ Hessian drift B_τ = X_τᵀ W X + Xᵀ W X_τ + Xᵀ diag(c ⊙ X_τ β̂) X + S_τ − (H_φ)_{τ}|_β without materializing the full dense matrix up front.

Trait Implementations

impl HyperOperator for SparseDirectionalHyperOperator

fn dim(&self) -> usize

Operator dimension p such that B · v consumes a p-vector and produces a p-vector.

fn mul_vec(&self, v: &Array1<f64>) -> Array1<f64>

Compute B · v (matrix-vector product). v and result are p-vectors.

fn is_implicit(&self) -> bool

Whether this operator uses implicit (non-materialized) storage.

fn as_any(&self) -> &(dyn Any + 'static)

Expose the concrete type for solver-local downcast helpers when the implementor has a 'static concrete type. Borrowing adapters may keep the default, which simply cannot downcast.

fn mul_vec_view( &self, v: ArrayBase<ViewRepr<&f64>, Dim<[usize; 1]>>, ) -> ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>

Compute B · v from a vector view.

fn mul_vec_into( &self, v: ArrayBase<ViewRepr<&f64>, Dim<[usize; 1]>>, out: ArrayBase<ViewRepr<&mut f64>, Dim<[usize; 1]>>, )

Compute B · v into caller-owned storage.

fn mul_mat( &self, factor: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>, ) -> ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>

Compute B · F where F is (p × k). Default dispatches per-column in parallel unless already inside a rayon worker.

fn trace_projected_factor( &self, factor: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>, ) -> f64

Compute trace(F^T B F) for a (p x k) factor matrix F.

fn projection_design_id(&self) -> Option<usize>

Optional stable identity for this operator’s action B. When Some, the default cached trace / projected-matrix paths memoize the B · F product in the shared ProjectedFactorCache under a (design_id, factor) key, so repeated projections of the same factor against the same operator within one outer iteration build B · F once. None (the default) disables that reuse: an operator with no design factor stable across calls cannot key the cache without risking a stale B · F, so it recomputes every time.

fn trace_projected_factor_cached( &self, factor: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>, factor_cache: &ProjectedFactorCache, ) -> f64

fn projected_matrix( &self, factor: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>, ) -> ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>

Compute the exact projected matrix F^T B F.

fn projected_matrix_cached( &self, factor: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>, factor_cache: &ProjectedFactorCache, ) -> ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>

Compute the exact projected matrix F^T B F, reusing caller-owned projection caches when the operator has a shared row/design factor.

fn mul_basis_columns_into( &self, start: usize, out: ArrayBase<ViewRepr<&mut f64>, Dim<[usize; 2]>>, )

Fill columns [start, start + out.ncols()) of B into out.

fn scaled_add_mul_vec( &self, v: ArrayBase<ViewRepr<&f64>, Dim<[usize; 1]>>, scale: f64, out: ArrayBase<ViewRepr<&mut f64>, Dim<[usize; 1]>>, )

Accumulate scale * B · v into caller-owned storage.

fn bilinear( &self, v: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, u: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, ) -> f64

Compute v^T · B · u (bilinear form).

fn bilinear_view( &self, v: ArrayBase<ViewRepr<&f64>, Dim<[usize; 1]>>, u: ArrayBase<ViewRepr<&f64>, Dim<[usize; 1]>>, ) -> f64

Compute v^T · B · u without requiring owned vector inputs.

fn has_fast_bilinear_view(&self) -> bool

Whether bilinear_view is implemented as a direct scalar contraction.

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

Full dense materialization.

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

If this operator is block-local, returns the block range and local matrix.