Struct PairwiseBeta 

pub struct PairwiseBeta { /* private fields */ }

Rolling Beta of asset a’s log-returns on asset b’s log-returns.

Each update receives one (a, b) pair of raw prices. Internally the indicator differences consecutive prices into log-returns rₜ = ln(pₜ / pₜ₋₁) and runs a rolling ordinary-least-squares regression of a’s returns on b’s returns over the trailing window of period return pairs:

cov_ab = (1/n) · Σ rₐ·r_b − r̄ₐ·r̄_b
var_b  = (1/n) · Σ r_b²   − r̄_b²
Beta   = cov_ab / var_b

This is the slope of the OLS line and measures how much asset a moves, in return space, for a unit return of asset b. A reading of 1.0 means the two move together one-for-one; 2.0 means a typically doubles b’s moves; negative readings signal an inverse relationship and the basis for a hedge.

This differs from crate::Beta, which regresses the raw inputs it is fed. PairwiseBeta always works in return space: feed it raw price levels and it computes the returns for you, which is the conventional way to measure cross-asset Beta (a Beta on price levels is dominated by the shared trend and rarely what you want).

Each update is O(1): four running sums (Σrₐ, Σr_b, Σr_b², Σrₐ·r_b) are maintained as the window of returns slides. A flat b window has zero return variance and Beta is undefined; the indicator returns 0 in that case rather than producing NaN.

Prices must be strictly positive and finite for the log-return to be defined. A non-positive or non-finite price breaks the return chain: that sample is dropped and the next valid price re-seeds the previous-price reference, exactly as a real feed would resume after a bad tick.

Example

use wickra_core::{Indicator, PairwiseBeta};

let mut indicator = PairwiseBeta::new(10).unwrap();
let mut last = None;
for i in 0..30 {
    // A varying (non-constant-return) positive price path.
    let b = 100.0 + 10.0 * (f64::from(i) * 0.5).sin();
    // `a = b²`, so a's log-returns are exactly twice b's.
    last = indicator.update((b * b, b));
}
assert!((last.unwrap() - 2.0).abs() < 1e-9);

Implementations

impl PairwiseBeta

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

Construct a new rolling pairwise Beta over period return pairs.

Errors

Returns Error::InvalidPeriod if period < 2 (variance needs at least two returns).

pub const fn period(&self) -> usize

Configured period (number of return pairs in the rolling window).

Trait Implementations

impl Clone for PairwiseBeta

fn clone(&self) -> PairwiseBeta

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PairwiseBeta

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

Formats the value using the given formatter.

impl Indicator for PairwiseBeta

type Input = (f64, f64)

(a, b) price pair.

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.