Enum Kernel 

pub enum Kernel {
    Squared,
    Huber(f64),
    Cauchy(f64),
    Tukey(f64),
    GemanMcClure(f64),
}

A loss function.

Each kernel’s parameter is a scale in units of the residual, that is, in metres. It sets the boundary of a “normal” error; three standard deviations of the sensor noise is a reasonable starting point.

Variants

Squared

Squared: ρ(e) = e²/2. Not robust; kept for comparison.

Huber(f64)

Huber: quadratic near zero, linear outside.

An outlier’s contribution still grows, but only linearly. Convex, so it creates no local minima.

Cauchy(f64)

Cauchy: the contribution grows logarithmically.

Suppresses harder than Huber, at the cost of being non-convex.

Tukey(f64)

Tukey: an outlier’s contribution is exactly zero past the threshold.

The harshest of these: a point beyond the threshold has no influence at all. It demands a decent initial guess.

GemanMcClure(f64)

Geman–McClure: smooth saturation without a hard threshold.

Implementations

impl Kernel

pub fn weight(self, residual: f64) -> f64

The IRLS weight w(e) = ψ(e)/e.

At zero every kernel gives one: near the origin all of them agree with the squared loss.

pub fn loss(self, residual: f64) -> f64

The value of ρ(e).

Needed by the LM step-acceptance test: what must be compared is the robust cost rather than the sum of squares, or a step that is right by the kernel’s own measure gets rejected.

pub fn scale(self) -> Option<f64>

The scale parameter, where one exists.

Trait Implementations

impl Clone for Kernel

fn clone(&self) -> Kernel

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Kernel

impl Debug for Kernel

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

Formats the value using the given formatter.

impl PartialEq for Kernel

fn eq(&self, other: &Kernel) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Kernel