Struct MovingAverage 

pub struct MovingAverage<T: TemporalSample, const N: usize> { /* private fields */ }

Exact fixed-window moving average.

Updates are O(1) using a checked-range i64 running sum. Output begins only after all N samples have been supplied.

The per-type window cap on TemporalSample is an accumulator-safety ceiling so N copies of the widest sample still fit in i64. It is not a practical size: storage is [T; N] plus that sum, and firmware chooses N from available RAM.

Implementations

impl<T: TemporalSample, const N: usize> MovingAverage<T, N>

pub const fn new() -> Self

Construct an empty moving average.

Panics

Panics for a zero-sized window or a window larger than the accumulator-safety ceiling of T (see TemporalSample). That ceiling is not a recommended window size; N is fixed storage.

Examples found in repository

examples/no_std_generated_fixtures.rs (line 44)

pub fn runtime_api_smoke(code: u16, sample: u32) -> (i32, u16, u32, bool) {
    let transfer = PiecewiseLinearTransfer::new(
        &SMOKE_INPUTS,
        &SMOKE_OUTPUTS,
        MonotonicDirection::Increasing,
    );
    let calibrated = match AffineCalibration::new(transfer, 1_001, 0, 1_000) {
        Ok(value) => value,
        Err(_) => unreachable!(),
    };
    let physical = calibrated.convert(code).unwrap_or_default();
    let inverse = calibrated.invert(physical).unwrap_or_default();

    let affine = match AffineTransform::new(1_001, 0, 1_000) {
        Ok(value) => value,
        Err(_) => unreachable!(),
    };
    let _ = affine
        .apply(physical)
        .and_then(|value| affine.unapply(value));

    let mut average = MovingAverage::<u32, 1>::new();
    let filtered = match average.update(sample) {
        FilterOutput::Ready(value) => value,
        FilterOutput::WarmingUp { .. } => unreachable!(),
    };
    let mut latch = Hysteresis::<u32>::new(100, 200);
    (physical, inverse, filtered, latch.update(filtered))
}

pub const fn len(&self) -> usize

Number of retained samples.

pub const fn is_empty(&self) -> bool

Whether no samples are retained.

Trait Implementations

impl<T: Clone + TemporalSample, const N: usize> Clone for MovingAverage<T, N>

fn clone(&self) -> MovingAverage<T, N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + TemporalSample, const N: usize> Debug for MovingAverage<T, N>

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

Formats the value using the given formatter.

impl<T: TemporalSample, const N: usize> Default for MovingAverage<T, N>

fn default() -> Self

Returns the “default value” for a type.

impl<T: TemporalSample, const N: usize> TemporalFilter<T> for MovingAverage<T, N>

fn update(&mut self, value: T) -> FilterOutput<T>

Push one sample and return the current filter state.

fn reset(&mut self)

Discard all retained history.