Struct Smoother 

pub struct Smoother { /* private fields */ }

Smooths a noisy signal with an exponential moving average.

Cheap sensors are noisy, and a single bad sample should not trip an alarm or flip an actuator. A Smoother dampens that jitter. The technique one layer down is an exponential moving average: each output is a weighted blend of the newest sample and the previous output, so recent readings count for more without storing a history buffer.

Examples

use pamoja_kit::Smoother;

let mut smoother = Smoother::new(0.5);
assert_eq!(smoother.update(10.0), 10.0); // the first sample seeds the average
assert_eq!(smoother.update(0.0), 5.0); // then each output blends halfway

Implementations

impl Smoother

pub fn new(weight: f32) -> Self

Creates a smoother with the given responsiveness.

Arguments

• weight - how much the newest sample counts, clamped to [0.0, 1.0]. 1.0 disables smoothing so the output follows the input; values near 0.0 smooth heavily and react slowly.

Returns

A smoother awaiting its first sample.

pub fn update(&mut self, sample: f32) -> f32

Folds a new sample into the average and returns the smoothed value.

The first sample seeds the average and is returned unchanged.

Arguments

• sample - the latest raw reading.

Returns

The smoothed value after including sample.

pub fn value(&self) -> Option<f32>

Returns the current smoothed value, or None before the first sample.

Returns

Some(value) once at least one sample has been seen, otherwise None.

pub fn reset(&mut self)

Forgets the smoothed value so the next sample seeds the average afresh.

Trait Implementations

impl Clone for Smoother

fn clone(&self) -> Smoother

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Smoother

impl Debug for Smoother

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

Formats the value using the given formatter.

impl PartialEq for Smoother

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Smoother