kingchenc
0b85142ad1
* feat(core): add PairwiseBeta cross-asset indicator
Rolling OLS slope of one asset's log-returns on another's. Unlike Beta,
which regresses the raw inputs it is fed, PairwiseBeta differences
consecutive prices into log-returns internally -- the conventional way to
measure cross-asset beta, where a beta on price levels would be dominated
by the shared trend.
Two-series Indicator<Input = (f64, f64)>, exposed in Rust, Python, Node
and WASM, with unit/known-value/streaming tests and a pair fuzz target.
* feat(core): add PairSpreadZScore cross-asset indicator
Standardised log-spread ln(a) - beta*ln(b) of a pair, where beta is a
rolling-OLS hedge ratio and the spread is z-scored over its own look-back.
The canonical mean-reversion / statistical-arbitrage entry signal, with
independent beta_period and z_period windows.
Two-series Indicator<Input = (f64, f64)>, exposed in Rust, Python, Node
and WASM, with sign/known-value/streaming tests and a pair fuzz target.
* feat(core): add LeadLagCrossCorrelation cross-asset indicator
Reports the integer offset k in [-max_lag, max_lag] that maximises
|corr(a[t], b[t+k])|, answering which of two assets leads the other and by
how many bars. A positive lag means a leads b. Fully causal: a's window is
held centred while b's window slides across the buffered history, so every
lag is evaluated only against data already seen.
Struct output { lag, correlation }, exposed in Rust, Python, Node and WASM
with lead-detection/streaming tests and a pair fuzz driver.
* feat(core): add Cointegration (Engle-Granger + ADF) indicator
Rolling pairs-trading screen: an OLS hedge ratio of a on b, the spread
(residual) a - (alpha + beta*b), and an augmented Dickey-Fuller t-statistic
on the spread with configurable lags. A strongly negative statistic flags a
mean-reverting, tradeable spread. Includes a small Gaussian-elimination
solver for the augmented regression.
Struct output { hedge_ratio, spread, adf_stat }, exposed in Rust, Python,
Node and WASM with stationarity/hedge-ratio/streaming tests and a pair fuzz
driver.
* feat(core): add RelativeStrengthAB cross-asset indicator
Comparative relative strength of two assets: the ratio line a/b together
with its moving average and its RSI, the classic asset-vs-asset /
asset-vs-index rotation screen. Composes the existing Sma and Rsi over the
ratio; a zero denominator or non-finite price is skipped.
Struct output { ratio, ratio_ma, ratio_rsi }, exposed in Rust, Python, Node
and WASM with flat/rising-ratio/streaming tests and a pair fuzz driver.
* test(cointegration): cover ADF guard branches
The ADF helper's short-series and degrees-of-freedom guards and the
zero-dispersion (perfect AR) path are unreachable through the public
Cointegration API (period >= 2*adf_lags + 4), so exercise them with direct
unit tests on adf_no_constant. The second linear solve cannot be singular
once the coefficient solve on the same matrix has succeeded, so it now uses
expect() instead of a dead error branch.
65 lines
2.2 KiB
Rust
65 lines
2.2 KiB
Rust
#![no_main]
|
|
//! Fuzz two-input `Indicator<(f64, f64)>` implementations with arbitrary
|
|
//! `(asset, benchmark)` return pairs.
|
|
//!
|
|
//! Each iteration consumes a byte stream and interprets it as a sequence of
|
|
//! `(f64, f64)` pairs (8 bytes per `f64`), then drives every two-series
|
|
//! indicator over the sequence both streaming and as a batch. No path may
|
|
//! panic.
|
|
|
|
use libfuzzer_sys::fuzz_target;
|
|
use wickra_core::{
|
|
Alpha, BatchExt, Cointegration, Indicator, InformationRatio, LeadLagCrossCorrelation,
|
|
PairSpreadZScore, PairwiseBeta, RelativeStrengthAB, TreynorRatio,
|
|
};
|
|
|
|
#[inline(never)]
|
|
fn drive<I>(make: impl Fn() -> I, data: &[(f64, f64)])
|
|
where
|
|
I: Indicator<Input = (f64, f64), Output = f64> + BatchExt,
|
|
{
|
|
let mut streaming = make();
|
|
for &x in data {
|
|
let _ = streaming.update(x);
|
|
}
|
|
let _ = make().batch(data);
|
|
}
|
|
|
|
fuzz_target!(|data: &[u8]| {
|
|
// Pack two consecutive 8-byte chunks into one `(f64, f64)` pair.
|
|
let pairs: Vec<(f64, f64)> = data
|
|
.chunks_exact(16)
|
|
.map(|c| {
|
|
let a = f64::from_le_bytes(c[..8].try_into().expect("8 bytes"));
|
|
let b = f64::from_le_bytes(c[8..].try_into().expect("8 bytes"));
|
|
(a, b)
|
|
})
|
|
.collect();
|
|
|
|
drive(|| TreynorRatio::new(10, 0.0).unwrap(), &pairs);
|
|
drive(|| InformationRatio::new(10).unwrap(), &pairs);
|
|
drive(|| Alpha::new(10, 0.0).unwrap(), &pairs);
|
|
drive(|| PairwiseBeta::new(10).unwrap(), &pairs);
|
|
drive(|| PairSpreadZScore::new(10, 10).unwrap(), &pairs);
|
|
|
|
// Struct-output pair indicator: drive update + batch directly (the generic
|
|
// `drive` above only covers `Output = f64`).
|
|
let mut ll = LeadLagCrossCorrelation::new(8, 3).unwrap();
|
|
for &x in &pairs {
|
|
let _ = ll.update(x);
|
|
}
|
|
let _ = LeadLagCrossCorrelation::new(8, 3).unwrap().batch(&pairs);
|
|
|
|
let mut co = Cointegration::new(12, 1).unwrap();
|
|
for &x in &pairs {
|
|
let _ = co.update(x);
|
|
}
|
|
let _ = Cointegration::new(12, 1).unwrap().batch(&pairs);
|
|
|
|
let mut rs = RelativeStrengthAB::new(10, 14).unwrap();
|
|
for &x in &pairs {
|
|
let _ = rs.update(x);
|
|
}
|
|
let _ = RelativeStrengthAB::new(10, 14).unwrap().batch(&pairs);
|
|
});
|