Struct SplineScanFit 

pub struct SplineScanFit {
    pub order: usize,
    pub knots: Vec<f64>,
    pub mean: Vec<f64>,
    pub deriv: Vec<f64>,
    pub var: Vec<f64>,
    pub log_lambda: f64,
    pub sigma2: f64,
    pub restricted_loglik: f64,
    pub n_obs: usize,
    /* private fields */
}

Fitted exact smoothing-spline posterior on the pooled knots.

Fields

order: usize

Smoothing-spline order m (penalize ∫(f^{(m)})²); state dimension. m = 1 is the random-walk/linear smoother, m = 2 the cubic smoother, m = 3 the quintic smoother.

knots: Vec<f64>

Distinct sorted abscissae (pooled knots).

mean: Vec<f64>

Smoothed posterior mean of f at each knot.

deriv: Vec<f64>

Smoothed posterior mean of f′ at each knot (0 for order m = 1, which carries no derivative state).

var: Vec<f64>

Posterior variance of f at each knot (scaled by sigma2).

log_lambda: f64

Selected (or supplied) log smoothing parameter log λ.

sigma2: f64

Profiled (or supplied) observation variance σ².

restricted_loglik: f64

Concentrated diffuse restricted log-likelihood at the optimum, up to a λ- and data-independent additive constant. Differences across λ are exact REML criterion differences.

n_obs: usize

Raw observation count n (pre-pooling; ties collapse to fewer knots). The profiled σ² used the restricted residual d.o.f. n − order, so this is exactly the count needed to recover the Gaussian deviance (σ²·(n − order)) and the residual d.o.f. for introspection (#1046).

Implementations

impl SplineScanFit

pub fn to_state(&self) -> SplineScanState

Snapshot the full smoother state for persistence (#1034).

pub fn from_state(state: &SplineScanState) -> Result<Self, String>

Rebuild the exact in-memory fit from a persisted snapshot (#1034).

Validates shape, finiteness, strict knot ordering, positive weights and σ², so a corrupt payload fails loudly here instead of inside a later predict. The restored fit replays the Gaussian bridge bit-for-bit: every field predict/edf/deriv_at_knot reads is either stored verbatim or derived by the same expressions the fitter uses.

pub fn predict(&self, x_new: f64) -> Result<(f64, f64), String>

Exact posterior (mean, variance) of f at an arbitrary abscissa.

Interior points use the Gaussian bridge conditional on the two flanking smoothed states with the exact lag-one smoothed cross-covariance Cov(α_t, α_{t+1} | y) = G_t · P^s_{t+1}; exterior points extrapolate from the boundary state (linear mean, cubically growing variance).

pub fn edf(&self) -> f64

Exact effective degrees of freedom of the fitted smoother.

For a Gaussian smoother the influence (hat) matrix is S = Cov_post · W / σ² (posterior mean is linear in y with that exact coefficient matrix), so EDF = tr(S) = tr(W · Cov_post) / σ² = Σ_t w_t · Var_smoothed(f_t) / σ². This is the standard Gaussian-process identity — no second smoother pass and no approximation. Tied abscissae pool exactly: each raw row i in tie-group k contributes ∂f̂(x_k)/∂y_i = C̃_kk · w_i (the pooled mean ȳ_k is precision-weighted), so the raw-row trace Σ_i w_i · C̃_{k(i),k(i)} collapses to Σ_k W_k · C̃_kk with the pooled weights W_k. smoothed_cov is stored at unit-σ² scale (C̃ = Cov_post / σ²), so the σ² factors cancel exactly.

pub fn deriv_at_knot(&self, t: usize) -> (f64, f64)

Posterior (mean, variance) of the derivative f′ at a knot index.

pub fn lambda(&self) -> f64

Selected smoothing parameter λ = e^{log λ} (#1046).

pub fn n_obs(&self) -> usize

Raw observation count n used to profile σ² (#1046).

pub fn deviance(&self) -> f64

Gaussian deviance — the weighted residual sum of squares Σ wᵢ(yᵢ − f̂ᵢ)² (#1046). The profiled σ² = RSS / (n − order) (the restricted residual d.o.f.), so RSS = σ²·(n − order) recovers the deviance exactly without re-touching the raw rows the scan deliberately does not retain.

Trait Implementations

impl Clone for SplineScanFit

fn clone(&self) -> SplineScanFit

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SplineScanFit

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

Formats the value using the given formatter.