Struct GrangerCausality 

pub struct GrangerCausality { /* private fields */ }

Granger causality of b on a over a rolling window, as an F-statistic.

Each update takes one (a, b) pair. Over the trailing window of period observations the indicator fits two autoregressions of a and compares them with an F-test:

restricted:    aₜ = c + Σ φᵢ·aₜ₋ᵢ                       (a's own lags only)
unrestricted:  aₜ = c + Σ φᵢ·aₜ₋ᵢ + Σ ψᵢ·bₜ₋ᵢ          (+ b's lags)
F = ((RSSᵣ − RSSᵤ) / lag) / (RSSᵤ / (n − 2·lag − 1))

If adding b’s lags significantly reduces the residual sum of squares, b Granger-causes a: past values of b carry information about the future of a beyond what a’s own past holds. A larger F means stronger predictive causality (lead–lag structure a stat-arb model can trade); a value near 0 means b adds nothing. Note Granger causality is purely predictive — it is not structural cause and effect.

The statistic is 0 when a regression is degenerate — a collinear or flat window makes the normal equations singular. The output is always ≥ 0.

Each update is O(period · lag² + lag³), bounded by the fixed parameters.

Example

use wickra_core::{GrangerCausality, Indicator};

let mut g = GrangerCausality::new(60, 1).unwrap();
let mut last = None;
for t in 0..120 {
    let drive = (f64::from(t) * 0.3).sin();
    // a echoes b's previous value plus noise ⇒ b Granger-causes a.
    let b = drive;
    let a = 0.5 * (f64::from(t.max(1) - 1) * 0.3).sin() + 0.1 * (f64::from(t) * 0.9).cos();
    last = g.update((a, b));
}
assert!(last.unwrap() >= 0.0);

Implementations

impl GrangerCausality

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

Construct a new Granger causality test.

period is the look-back window; lag is the autoregressive order (number of own/cross lags in each model).

Errors

Returns Error::InvalidPeriod if lag < 1 or if period < 3·lag + 2 (the smallest window that leaves the unrestricted regression at least one residual degree of freedom).

pub const fn period(&self) -> usize

Configured look-back window.

pub const fn lag(&self) -> usize

Configured autoregressive order.

Trait Implementations

impl Clone for GrangerCausality

fn clone(&self) -> GrangerCausality

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GrangerCausality

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

Formats the value using the given formatter.

impl Indicator for GrangerCausality

type Input = (f64, 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, 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.