Struct SScale 

pub struct SScale<R>
where
    R: RhoFunction,
{ /* private fields */ }

The M-estimate of scale (“S-scale”): the s > 0 solving (1/n) Σ ρ(rᵢ/s) = δ.

With a bounded, redescending ρ and δ = ρ.rho_sup()/2 this is the 50%-breakdown scale that S- and MM-regression minimize; with δ = E_Φ[ρ] it is Fisher-consistent for σ at the Gaussian (for the biweight the S-step tuning c ≈ 1.547 makes the two coincide). Generic over the loss, but the loss must have bounded ρ (rho_sup().is_some()): an unbounded ρ gives zero breakdown (a single rᵢ → ∞ drives s without limit) so new rejects it with RobustError::UnboundedLoss.

Solved by the standard fixed-point iteration s ← s·√(mean_i ρ(rᵢ/s) / δ) from a MAD start; g(s) = (1/n)Σρ(rᵢ/s) is monotone decreasing, so the root is unique.

Implementations

impl<R> SScale<R>

where R: RhoFunction,

pub fn new(rho: R, delta: f64) -> Result<SScale<R>, RobustError>

Create an S-scale for loss rho with consistency target 0 < delta < sup ρ.

Rejects an unbounded loss (rho_sup() == None) with RobustError::UnboundedLoss, since it cannot define a high-breakdown scale and a delta outside (0, sup ρ) (for which the scale equation has no root) with RobustError::InvalidTuning.

pub fn fisher_consistent( rho: R, quad_points: usize, ) -> Result<SScale<R>, RobustError>

Create a Fisher-consistent S-scale by setting δ = E_Φ[ρ], evaluated by Gauss–Hermite quadrature with quad_points nodes.

pub fn with_control(self, control: Control) -> SScale<R>

Override the default convergence control.

pub fn delta(&self) -> f64

The consistency target δ.

Trait Implementations

impl<R> Clone for SScale<R>

where R: Clone + RhoFunction,

fn clone(&self) -> SScale<R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R> Copy for SScale<R>

where R: Copy + RhoFunction,

impl<R> Debug for SScale<R>

where R: Debug + RhoFunction,

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

Formats the value using the given formatter.

impl<R> ScaleEstimator for SScale<R>

where R: RhoFunction,

fn scale(&self, residuals: &[f64]) -> Result<Scale, RobustError>

A robust scale of the given residuals.