Struct NormalEquationsCache 

pub struct NormalEquationsCache { /* private fields */ }

Cached symbolic machinery for forming the normal equations of a fixed Jacobian sparsity pattern.

Implementations

impl NormalEquationsCache

pub fn try_new(jacobian: &SparseColMat<usize, f64>) -> LinAlgResult<Self>

Build the cache for a Jacobian sparsity pattern.

pub fn matches(&self, jacobian: &SparseColMat<usize, f64>) -> bool

Whether the cache still describes jacobian’s sparsity pattern.

Full-pattern equality: dimensions and nonzero count reject fast, and the embedded hash rejects equal-nnz permutations that would otherwise reuse a stale symbolic product and value permutation.

pub fn product_symbolic(&self) -> SymbolicSparseColMat<usize>

Sparsity of JᵀJ, for building factorizations compatible with compute.

pub fn compute( &mut self, residuals: &Mat<f64>, jacobian: &SparseColMat<usize, f64>, ) -> LinAlgResult<NormalEquations>

Form H = JᵀJ and g = Jᵀr with parallel faer kernels.

pub fn damped_hessian( &self, damping: &Damping, ) -> LinAlgResult<SparseColMat<usize, f64>>

H + λ·D as an owned sparse matrix on the cached product pattern.

D_jj = clamp(H_jj, min_diagonal, max_diagonal) — see Damping. Each diagonal position is visited exactly once, so values[*pos] still holds the un-damped H_jj when the clamp reads it.

When JᵀJ is missing diagonal entries — a fully fixed variable contributes an all-zero column, so gauge fixing produces exactly that — the result is built on a widened pattern that carries the whole diagonal. That pattern is computed once, not per solve.

Callers holding a cached factorization symbolic must use Self::product_symbolic_for_damping to build it, so the two agree.

pub fn product_symbolic_for_damping(&self) -> SymbolicSparseColMat<usize>

The pattern Self::damped_hessian produces.

Equal to Self::product_symbolic unless the diagonal had to be widened; factorization symbolics for the damped system must be built from this one.