Struct StandardError 

pub struct StandardError { /* private fields */ }

Standard Error of the regression line fit over the last period inputs.

Over the trailing window indexed x = 0, 1, …, period − 1 the OLS line y = a + b·x is fitted, then:

slope     = (n·Σxy − Σx·Σy) / (n·Σxx − (Σx)²)
SS_total  = Σy² − n·ȳ²                            // total sum of squares
RSS       = SS_total − slope² · S_xx              // residual sum of squares
StdErr    = √( RSS / (n − 2) )                    // n − 2 residual d.o.f.

where S_xx = (n·Σxx − (Σx)²) / n is the centred sum of squares of the design.

This is the textbook standard error of estimate of OLS: it measures the typical distance between the observed prices and the fitted line, using the residual degrees of freedom n − 2. It is the spread that drives crate::BollingerBands-style bands around a regression instead of around an SMA — when the price hugs its trend, StdErr is small.

Each update is O(period): the Σx and Σxx terms depend only on period and are precomputed once, but the residuals are summed directly over the window rather than reconstructed from rolling sums.

That is a deliberate trade. The residual sum of squares can be written as Σ(y − ȳ)² − slope²·S_xx, which slides in constant time, and this indicator did exactly that. But the two terms converge as the fit improves, so the subtraction cancels precisely when the answer is smallest: on a line carrying a wobble of 1e-4 around a price of 100 the constant-time form was 6.2e-08 out, and at a wobble of 1e-8 it was off by 215% — for the case the indicator is most likely to be asked about, a market hugging its trend. Summing the residuals costs one further pass over a window the indicator already holds, and is what the sibling crate::StandardErrorBands and crate::LinRegChannel have always done.

Example

use wickra_core::{Indicator, StandardError};

let mut indicator = StandardError::new(14).unwrap();
let mut last = None;
for i in 0..40 {
    last = indicator.update(100.0 + f64::from(i) + (f64::from(i) * 0.5).sin());
}
assert!(last.is_some());

Implementations

impl StandardError

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

Construct a new rolling standard error of regression.

Errors

Returns Error::InvalidPeriod if period < 3 — the residual degrees of freedom n − 2 would be non-positive.

pub const fn period(&self) -> usize

Configured period.

Trait Implementations

impl Clone for StandardError

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 StandardError

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

Formats the value using the given formatter.

impl Indicator for StandardError

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, value: 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.

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.