Struct HurstExponent 

pub struct HurstExponent { /* private fields */ }

Hurst Exponent of the last period values, estimated by rescaled-range (R/S) analysis.

The classic Hurst-Mandelbrot estimator forms log-log pairs of (n, R(n)/S(n)) for several window lengths n and reports the slope of the least-squares fit. Wickra uses a streaming-friendly variant that partitions the trailing window into chunks of equal size, computes (R/S) for each chunk length, and fits a log-log line to the resulting points:

for each chunk size m ∈ {n/2, n/3, …, n/chunks}:
    mean_m   = (1/m) · Σ x_i               over the chunk
    dev_m_i  = (Σ_{j ≤ i} (x_j − mean_m))  // cumulative deviation
    R_m      = max(dev_m) − min(dev_m)
    S_m      = population_stddev(chunk)
    pair     = (log m, log(R_m / S_m))
H = slope of OLS line through the (log m, log(R/S)) points

The interpretation is unchanged from the textbook:

• H ≈ 0.5 → random walk; recent moves carry no information about future direction (the efficient-markets baseline).
• H > 0.5 → persistent / trending; up moves are likelier to be followed by more up moves.
• H < 0.5 → anti-persistent / mean-reverting; up moves tend to reverse.

Use it as a regime filter: trend-following strategies prefer H > 0.55; mean-reversion prefers H < 0.45. The output is clamped to [0, 1] to absorb degenerate fits on very small windows.

period must be at least 2 · chunks so every chunk has at least two points (otherwise its stddev is zero). A perfectly flat window has all R/S = 0 and the indicator returns 0.5 (random-walk baseline) to avoid divide-by-zero / log-zero failures.

Each update is O(period); the window is stored in a deque and the chunked R/S computation runs once per emission, not per input.

Example

use wickra_core::{HurstExponent, Indicator};

let mut indicator = HurstExponent::new(100, 4).unwrap();
let mut last = None;
for i in 0..200 {
    last = indicator.update(f64::from(i));
}
assert!(last.is_some());

Implementations

impl HurstExponent

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

Construct a new Hurst Exponent over a window of period inputs, fitted across chunks log-log points.

chunks controls the number of R/S pairs that go into the slope fit; the typical value is 4 (the original Hurst paper used 5 — 9 points; smaller windows constrain the choice).

Errors

Returns Error::InvalidPeriod if chunks < 2 or period < 2 · chunks.

pub const fn period(&self) -> usize

Configured window period.

pub const fn chunks(&self) -> usize

Configured chunk count.

Trait Implementations

impl Clone for HurstExponent

fn clone(&self) -> HurstExponent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HurstExponent

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

Formats the value using the given formatter.

impl Indicator for HurstExponent

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 the indicator is still warming up.

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.