Struct FitSensitivity 

pub struct FitSensitivity<'a> { /* private fields */ }

The one sensitivity operator built at the optimum. See module docs.

Implementations

impl<'a> FitSensitivity<'a>

pub fn from_faer_cholesky(factor: &'a FaerCholeskyFactor, dim: usize) -> Self

pub fn from_lower_triangular(factor: &'a Array2<f64>) -> Self

pub fn from_projected( basis: &'a Array2<f64>, reduced_inverse: &'a Array2<f64>, ) -> Self

pub fn dim(&self) -> usize

Coefficient dimension p the operator acts on.

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

H⁻¹ · rhs (pseudo-inverse action for the projected variant).

pub fn apply_multi(&self, rhs: ArrayView2<'_, f64>) -> Array2<f64>

H⁻¹ · RHS for a (p × m) block of right-hand sides — the batched form every multi-channel consumer should use (outer ρ-pair solves, ALO’s H⁻¹Xᵀ leverage block) so the factor is traversed once per block instead of once per column.

pub fn mode_response(&self, dg_dt: ArrayView2<'_, f64>) -> Option<Array2<f64>>

The IFT mode response ∂β̂/∂t = −H⁻¹ · ∂g/∂t for a (p × m) block of score perturbations — THE object of #935.

Returns None if any solved entry is non-finite (the factored curvature was unusable for this channel); callers must not substitute an approximation, matching the contract of the deleted ift_dbeta_drho_from_solver.

pub fn mode_response_coned( &self, hessian: ArrayView2<'_, f64>, dg_dt: ArrayView2<'_, f64>, col_supports: &[Range<usize>], ) -> Option<Array2<f64>>

Cone-of-influence mode response (#779), the lazy/local form of Self::mode_response. Each perturbation column ∂g/∂t_a is structurally supported only within col_supports[a], so its response −H⁻¹ ∂g/∂t_a is exactly zero outside the coupling component of hessian containing that support. Columns whose support is empty (a structurally inactive channel) are skipped with no solve; the active columns are solved as ONE batched block through Self::apply_multi — strictly better than the per-column BLAS-2 loop this replaces — and each result confined to its cone. On a fully coupled hessian every cone is the whole space and the result equals Self::mode_response bit-for-bit.

hessian must be the same curvature this operator inverts; a dimension mismatch (or any non-finite solved entry) returns None rather than silently substituting an approximation.

pub fn leverage_block(&self, design: &Array2<f64>) -> Array2<f64>

H⁻¹Xᵀ (p × n) — the shared leverage/case-sensitivity block: its column i is simultaneously ALO’s per-observation solve, the case- weight channel ∂g/∂w_i ∝ x_i, and the response channel ∂g/∂y_i ∝ x_i. One blocked solve serves all three diagnostics.

pub fn response_jacobian( &self, design: &Array2<f64>, working_weights: ArrayView1<'_, f64>, ) -> Option<Array2<f64>>

Data attribution ∂β̂/∂y (p × n) — how each fitted coefficient responds to each response value, the t = y channel of the one identity ∂β̂/∂t = −H⁻¹ ∂g/∂t.

The response enters the penalized score only through the working residual, so ∂g/∂y_i = −w_i x_i and therefore

  ∂β̂/∂y_i = w_i · H⁻¹ x_i,

i.e. column i of Self::leverage_block scaled by the working weight w_i. Contracting back through the design recovers the smoother/hat matrix A = X (∂β̂/∂y) = X H⁻¹ Xᵀ W, whose diagonal is the leverage already reported elsewhere. For a Gaussian penalized fit β̂ = H⁻¹ Xᵀ y, so this Jacobian is exact (and weight-free); for a GLM it is the one-step attribution at the fitted working weights.

Returns None on a shape mismatch.

pub fn case_deletion( &self, design: &Array2<f64>, working_weights: ArrayView1<'_, f64>, working_residual: ArrayView1<'_, f64>, phi: f64, ) -> Option<CaseDeletionInfluence>

Case-deletion influence (dfbetas + Cook’s distance) for every observation, built from the one sensitivity operator — the “leave-one-out” channel #935 was designed to unify.

Deleting observation i perturbs the penalized score by exactly its own contribution, so the IFT mode response gives the coefficient change in closed form (the penalized Sherman–Morrison identity):

  β̂ − β̂₍ᵢ₎ = (w_i r_i / (1 − h_ii)) · H⁻¹ x_i

where x_i is row i of design, w_i = working_weights[i] the IRLS working weight, r_i = working_residual[i] the working residual z_i − x_iᵀβ̂, and h_ii = w_i x_iᵀ H⁻¹ x_i the leverage. Column i of Self::leverage_block is H⁻¹ x_i, so each dfbeta is one scaled column — no per-observation refit, no second factorization. For a Gaussian penalized fit the identity is exact; for a GLM it is the standard one-step (ALO) approximation, consistent with the leverage already reported by AloDiagnostics.

Cook’s distance uses the metric the fit actually moves in, H = XᵀWX + S:

  D_i = (β̂−β̂₍ᵢ₎)ᵀ H (β̂−β̂₍ᵢ₎) / (p · φ)
      = scale_i² · (x_iᵀ H⁻¹ x_i) / (p · φ),   scale_i = w_i r_i / (1 − h_ii),

the second form following from (H⁻¹x_i)ᵀ H (H⁻¹x_i) = x_iᵀ H⁻¹ x_i, so the single quadratic form x_iᵀ H⁻¹ x_i gates the leverage, the deletion denominator, and Cook’s distance alike — no separate H apply.

This is an opt-in diagnostic: dfbeta is n × p and is never materialized on the default fit path (it would be ruinous at large-scale scale). Returns None on a shape mismatch or if any leverage reaches 1 (a point the deletion identity cannot resolve).