Struct Atr 

pub struct Atr { /* private fields */ }

Average True Range with Wilder smoothing.

The first emitted value, by convention, appears after period candles: the first period − 1 true-range values seed the Wilder average alongside the period-th, then the smoothed update begins.

Example

use wickra_core::{Candle, Indicator, Atr};

let mut indicator = Atr::new(5).unwrap();
let mut last = None;
for i in 0..80 {
    let base = 100.0 + f64::from(i);
    let candle =
        Candle::new(base, base + 2.0, base - 2.0, base + 1.0, 10.0, i64::from(i)).unwrap();
    last = indicator.update(candle);
}
assert!(last.is_some());

Implementations

impl Atr

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

Construct an ATR with the given Wilder period.

Errors

Returns Error::PeriodZero if period == 0.

pub const fn period(&self) -> usize

Configured period.

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

Current value if available.

pub fn batch_atr( &mut self, high: &[f64], low: &[f64], close: &[f64], ) -> Vec<f64>

Vectorized batch over raw high/low/close columns: one f64 per bar (NaN during warmup). The caller guarantees the three slices are equal length and finite with valid OHLC ordering (the binding validates once up front); ATR only reads high, low and the previous close.

Allocates the result and fills it through batch_atr_into.

pub fn batch_atr_into( &mut self, high: &[f64], low: &[f64], close: &[f64], out: &mut [f64], )

batch_atr into a caller-owned buffer, overwriting every cell.

For a fresh indicator long enough to seed (n >= period) it runs the true-range seed once and then the bare Wilder recurrence as a dispatched kernel (hardware FMA where the CPU has it) — no per-bar Candle construction/validation, no Option, identical division at the seed and mul_add afterwards, so every value is bit-for-bit equal to replaying update over the same candles. Shorter or non-fresh inputs defer to an exact update replay.

Panics

Panics if the four slices differ in length.

pub fn batch_atr_fast_into( &mut self, high: &[f64], low: &[f64], close: &[f64], out: &mut [f64], )

Opt-in fast variant of batch_atr_into: the exact seed, then blocks of true ranges smoothed by a SIMD Wilder scan. Every value agrees with the exact batch to within a few units in the last place; the seed, warmup NaNs and length are identical, and the result is the same on every platform. Only a fresh indicator over finite values within 1e100, at least period bars long, takes the kernel; anything else is the exact batch. Afterwards the ATR continues streaming from the kernel’s last average.

Panics

Panics if the four slices differ in length.

pub fn batch_atr_fast( &mut self, high: &[f64], low: &[f64], close: &[f64], ) -> Vec<f64>

batch_atr_fast_into into a fresh vector.

Trait Implementations

impl Clone for Atr

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 Atr

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

Formats the value using the given formatter.

impl Indicator for Atr

type Input = Candle

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, candle: Candle) -> 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.

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

where Self::Input: Copy, Self::Output: Into<f64>,

Run the indicator over inputs, writing one output per input into the caller-owned out buffer (NaN where update returns None). It exists for every indicator whose output converts to an f64; the batch pipelines use it for the scalar f64 -> f64 ones.

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

where Self::Input: Copy, Self::Output: Into<f64>,

Opt-in fast batch: like batch_nan_into, but an indicator with a vectorised kernel may reassociate its arithmetic to run it in SIMD lanes. Each value then agrees with the exact batch to within the tolerance the indicator documents (a few units in the last place), not bit for bit; warmup positions, NaN placement and the output length are identical. The kernels are deterministic: the same input produces the same bits on every platform, with or without SIMD hardware.