Struct SplineScanFit 

pub struct SplineScanFit {
    pub order: usize,
    pub knots: Vec<f64>,
    pub mean: Vec<f64>,
    pub deriv: Option<Vec<f64>>,
    pub var: Vec<f64>,
    pub sigma2: f64,
    pub restricted_loglik: f64,
    pub data_sse: f64,
    /* 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: Option<Vec<f64>>

Smoothed posterior mean of f′ at each knot, present only for order m ≥ 2. At m = 1 the latent process is Brownian motion, which has NO pointwise derivative state (it is a.s. nondifferentiable), so this is None rather than a fabricated zero.

var: Vec<f64>

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

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.

data_sse: f64

Weighted DATA residual sum of squares Σ wᵢ (yᵢ − f̂(xᵢ))² at the smoothed posterior mean. Stored explicitly because the profiled innovations quadratic σ̂²·(n − order) is the REML objective’s quadratic — data residual energy PLUS process/roughness energy at the posterior mode — and is therefore NOT the Gaussian deviance.

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) -> Option<(f64, f64)>

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

None at order m = 1: the latent process is Brownian motion, which is almost surely nondifferentiable — there is no derivative state, and fabricating a “known zero” (0, 0) would assert certainty about a quantity that does not exist.

pub fn lambda(&self) -> f64

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

pub fn log_lambda(&self) -> f64

pub fn training_sample_size(&self) -> usize

Number of original training rows / experimental units.

pub fn deviance(&self) -> f64

Gaussian deviance — the weighted DATA residual sum of squares Σ wᵢ(yᵢ − f̂ᵢ)² at the smoothed mean (#1046). This is the stored data_sse, computed against the fitted values at fit time. It is NOT σ̂²·(n − order): the profiled σ² divides the REML innovations quadratic, which is data residual energy PLUS process/roughness energy at the posterior mode (for order 1 on x = (0,1), y = (0,1), unit weights and λ = 1 the posterior mean is (1/3, 2/3); the data SSE is 2/9 while σ̂²·(n − order) = 1/3, the extra 1/9 being penalty energy).

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.