Struct Ema 

pub struct Ema { /* private fields */ }

Exponential Moving Average with smoothing factor alpha = 2 / (period + 1).

The first value is seeded with the simple mean of the first period inputs (the classical TA-Lib convention). From then on each new input contributes alpha * input + (1 - alpha) * previous.

Example

use wickra_core::{Indicator, Ema};

let mut indicator = Ema::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 Ema

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

Construct an EMA with the given period.

Errors

Returns Error::PeriodZero if period == 0.

pub fn with_alpha(alpha: f64) -> Result<Self>

Construct an EMA with a custom smoothing factor alpha in (0, 1].

The reported period is derived from alpha via 2/alpha - 1 and rounded; warmup_period() falls back to 1 because the implementation seeds from the very first input.

Errors

Returns Error::InvalidPeriod if alpha is not in (0.0, 1.0] or non-finite.

pub const fn period(&self) -> usize

Configured period.

pub const fn alpha(&self) -> f64

Smoothing factor.

pub const 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 Ema

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 Ema

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

Formats the value using the given formatter.

impl Indicator for Ema

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

For a fresh indicator over an all-finite slice this runs the seed (mean of the first period) once and then the bare alpha * x + (1 - alpha) * prev recurrence in a tight loop with no per-element is_finite/seeded branch and no Option — yet uses the identical mul_add, so every value is bit-for-bit equal to replaying update. 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: after the same seed (the mean of the first period inputs) the recurrence y = alpha * x + (1 - alpha) * y runs as a linear-recurrence scan, eight values per step. Agrees with the exact batch to within a few units in the last place (the scan reassociates the recurrence through powers of 1 - alpha); warmup NaNs and length are identical. Afterwards the EMA continues streaming from the kernel’s last value.

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.