Struct KylesLambda 

pub struct KylesLambda { /* private fields */ }

Kyle’s Lambda — the rolling ordinary-least-squares slope of mid-price changes on signed trade volume, the canonical measure of market depth / price impact.

Each update receives a TradeQuote — a trade plus the mid prevailing at execution. Internally the indicator forms, per trade, the mid change since the previous trade (Δmid = midₜ − midₜ₋₁) and the signed volume (q = size · D, with D the aggressor sign), then runs a rolling OLS regression of Δmid on q over the trailing window of window trades:

cov = (1/n) · Σ q·Δmid − q̄·Δ̄mid
var = (1/n) · Σ q²      − q̄²
λ   = cov / var

λ is the estimated price move per unit of signed volume: a deep, liquid book absorbs flow with little movement and reads a small λ; a thin book moves sharply per unit traded and reads a large λ. It is a direct, model-light proxy for the slope of the demand curve in Kyle’s microstructure model.

Each update is O(1): four running sums (Σq, ΣΔmid, Σq², Σq·Δmid) are maintained as the window slides. A window of constant signed volume has zero variance and λ is undefined; the indicator returns 0 in that case rather than producing NaN.

Input = TradeQuote, Output = f64. It warms up for window + 1 trade-quotes: one to seed the previous mid, then window paired observations.

Example

use wickra_core::{Indicator, KylesLambda, Side, Trade, TradeQuote};

// A book where each trade moves the mid by exactly 0.5 per unit of signed
// volume gives λ = 0.5.
let mut lambda = KylesLambda::new(8).unwrap();
let mut mid = 100.0;
let mut last = None;
for i in 0..20 {
    let side = if i % 2 == 0 { Side::Buy } else { Side::Sell };
    let size = 1.0 + f64::from(i % 3);
    let signed = size * side.sign();
    mid += 0.5 * signed;
    let trade = Trade::new(mid, size, side, 0).unwrap();
    last = lambda.update(TradeQuote::new(trade, mid).unwrap());
}
assert!((last.unwrap() - 0.5).abs() < 1e-9);

Implementations

impl KylesLambda

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

Construct a rolling Kyle’s lambda over window paired observations.

Errors

Returns Error::InvalidPeriod if window < 2 (the regression variance needs at least two observations).

pub const fn window(&self) -> usize

The configured window length, in paired observations.

Trait Implementations

impl Clone for KylesLambda

fn clone(&self) -> KylesLambda

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KylesLambda

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

Formats the value using the given formatter.

impl Indicator for KylesLambda

type Input = TradeQuote

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, quote: TradeQuote) -> 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.