Struct Sma 

pub struct Sma { /* private fields */ }

Simple Moving Average over a fixed window.

Maintains a rolling sum so each update is O(1). Output equals sum(last period prices) / period once the window is full; None before.

On long-running streams a single-subtract incremental sum can accumulate rounding error (catastrophic cancellation when values of very different magnitudes are alternately added and removed). To keep drift bounded, the running sum is reseeded from the live window every 16 · period updates — O(1) amortised cost (O(period) work amortised over O(period) updates), zero observable behaviour change on inputs that did not drift to begin with, and a strict cap on accumulated rounding for streams that did.

Example

use wickra_core::{Indicator, Sma};

let mut indicator = Sma::new(3).unwrap();
let mut last = None;
for i in 0..80 {
    last = indicator.update(100.0 + f64::from(i));
}
assert!(last.is_some());

Implementations

impl Sma

pub fn new(period: usize) -> Result<Self>

Construct a new SMA with the given window length.

Errors

Returns Error::PeriodZero if period == 0.

pub const fn period(&self) -> usize

Configured window length.

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

Current value if available.

pub fn batch_nan(&mut self, inputs: &[f64]) -> Vec<f64>

Vectorized batch returning one f64 per input (NaN during warmup).

Kept as an inherent method so existing callers need no trait import; it allocates the result and fills it through batch_nan_into, which carries the fast path.

Trait Implementations

impl Clone for Sma

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Sma

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

Formats the value using the given formatter.

impl Indicator for Sma

fn batch_nan_into(&mut self, inputs: &[f64], out: &mut [f64])

For a fresh, all-finite slice this inlines update’s rolling sum and drift-reseed, writing the mean as a bare f64 (warmup → NaN) straight into out. Same add/subtract order, same reseed cadence, same sum / period division — so it is bit-for-bit equal to replaying update, including the long-stream drift bound. Any other state, or a non-finite element, defers to the exact update replay.

fn batch_fast_into(&mut self, inputs: &[f64], out: &mut [f64])

SIMD kernel: rolling sums as a prefix scan of x[i] - x[i - period], re-anchored on an exact window sum every 16 · period values like the exact path’s reseed, each sum scaled by 1 / period. Agrees with the exact batch to within a few units in the last place (a multiply by the reciprocal replaces the division, and the running sum is reassociated); warmup NaNs and length are identical. Afterwards the window holds the last period inputs and its sum is recomputed exactly, so streaming continues from a freshly reseeded state.

type Input = f64

Type of one input data point (typically f64 for a price, or Candle / Tick).

type Output = f64

Type of one output value.

fn update(&mut self, input: f64) -> Option<f64>

Feed one new data point into the indicator and return the freshly computed output, or None if there is no value for this input.

fn reset(&mut self)

Reset all internal state, leaving the indicator equivalent to a freshly constructed instance with the same parameters.

fn warmup_period(&self) -> usize

Number of inputs required before the first non-None output can be produced.

fn is_ready(&self) -> bool

Whether the indicator has emitted at least one value since the last reset.

fn name(&self) -> &'static str

Stable, human-readable indicator name. Used by chaining and diagnostics.