扩展指标
This commit is contained in:
@@ -0,0 +1,39 @@
|
||||
[package]
|
||||
name = "ferro_ta_core"
|
||||
version = "1.2.0"
|
||||
edition = "2021"
|
||||
description = "Pure Rust core indicator library — no PyO3, no numpy dependency"
|
||||
license = "MIT"
|
||||
readme = "README.md"
|
||||
repository = "https://github.com/pratikbhadane24/ferro-ta"
|
||||
homepage = "https://github.com/pratikbhadane24/ferro-ta#readme"
|
||||
documentation = "https://docs.rs/ferro_ta_core"
|
||||
keywords = ["technical-analysis", "trading", "indicators", "finance", "ta-lib"]
|
||||
categories = ["finance", "mathematics"]
|
||||
|
||||
[lib]
|
||||
name = "ferro_ta_core"
|
||||
crate-type = ["lib"]
|
||||
|
||||
[dependencies]
|
||||
multiversion = { version = "0.8", optional = true }
|
||||
serde = { version = "1.0", features = ["derive"], optional = true }
|
||||
serde_json = { version = "1.0", optional = true }
|
||||
|
||||
[dev-dependencies]
|
||||
criterion = { version = "0.8", features = ["html_reports"] }
|
||||
|
||||
[[bench]]
|
||||
name = "indicators"
|
||||
harness = false
|
||||
|
||||
[features]
|
||||
# Runtime CPU-feature dispatch (multiversion). Default ON so `cargo add
|
||||
# ferro_ta_core` and the published wheels get SIMD-accelerated reductions
|
||||
# that adapt to the running CPU (baseline .. AVX-512 / NEON) WITHOUT pinning
|
||||
# a target-cpu — one binary runs on any CPU of the target arch, with no
|
||||
# illegal-instruction crashes on older chips. Disable with
|
||||
# `--no-default-features` for a pure-scalar build.
|
||||
default = ["simd"]
|
||||
simd = ["dep:multiversion"]
|
||||
serde = ["dep:serde", "dep:serde_json"]
|
||||
@@ -0,0 +1,87 @@
|
||||
# ferro_ta_core
|
||||
|
||||
`ferro_ta_core` is the pure Rust indicator engine behind [`ferro-ta`](https://github.com/pratikbhadane24/ferro-ta).
|
||||
|
||||
It provides allocation-friendly indicator functions over `&[f64]` slices without any
|
||||
PyO3, NumPy, or Python runtime dependency, which makes it a good fit for:
|
||||
|
||||
- Rust-native technical analysis workloads
|
||||
- custom services and backtesting engines
|
||||
- non-Python bindings (WASM, FFI)
|
||||
|
||||
## Installation
|
||||
|
||||
```toml
|
||||
[dependencies]
|
||||
ferro_ta_core = "1.2.0"
|
||||
```
|
||||
|
||||
## Design
|
||||
|
||||
- Pure functions over Rust slices
|
||||
- No Python or NumPy dependency
|
||||
- Shared core for the Python package and WASM bindings
|
||||
- Output shape matches TA-Lib-style full-length series with `NaN` warm-up values where applicable
|
||||
|
||||
## Modules
|
||||
|
||||
| Module | Functions | Highlights |
|
||||
|--------|-----------|------------|
|
||||
| `overlap` | 20 | SMA, EMA, WMA, DEMA, TEMA, TRIMA, KAMA, T3, BBANDS, MACD, MACDFIX, MACDEXT, SAR, SAREXT, MAMA, MIDPOINT, MIDPRICE, MA, MAVP, Hull MA |
|
||||
| `momentum` | 26 | RSI, MOM, STOCH, STOCHF, ADX, ADXR, DX, +DI, -DI, +DM, -DM, ROC, WILLR, AROON, CCI, BOP, STOCHRSI, APO, PPO, CMO, TRIX, ULTOSC |
|
||||
| `volatility` | 3 | ATR, NATR, TRANGE |
|
||||
| `volume` | 4 | OBV, MFI, AD, ADOSC |
|
||||
| `pattern` | 61 | All TA-Lib candlestick patterns (CDL2CROWS through CDLXSIDEGAP3METHODS) |
|
||||
| `statistic` | 9 | STDDEV, VAR, LINEARREG, LINEARREG_SLOPE/INTERCEPT/ANGLE, TSF, BETA, CORREL |
|
||||
| `math` | 24 | Rolling SUM/MAX/MIN/MAXINDEX/MININDEX, element-wise ADD/SUB/MULT/DIV, 15 transforms (trig, exp, log, sqrt, ceil, floor) |
|
||||
| `price_transform` | 4 | AVGPRICE, MEDPRICE, TYPPRICE, WCLPRICE |
|
||||
| `cycle` | 7 | Hilbert Transform: TRENDLINE, DCPERIOD, DCPHASE, PHASOR, SINE, TRENDMODE |
|
||||
| `extended` | 10 | VWAP, VWMA, Supertrend, Donchian, Keltner, Ichimoku, Pivot Points, Hull MA, Chandelier Exit, Choppiness Index |
|
||||
| `streaming` | 9 | Stateful bar-by-bar: SMA, EMA, RSI, ATR, BBands, MACD, Stoch, VWAP, Supertrend |
|
||||
| `batch` | 8 | Vectorized multi-column: batch_sma/ema/rsi/atr/stoch/adx, run_close/hlc_indicators |
|
||||
| `backtest` | 19 | Signal generators, close-only and OHLCV engines, walk-forward, Monte Carlo, performance metrics |
|
||||
| `options` | 18 | Black-Scholes/Black-76 pricing, Greeks, implied volatility, IV rank/percentile/zscore, smile metrics, chain analytics |
|
||||
| `futures` | 14 | Basis, annualized basis, carry, roll (weighted/back-adjusted/ratio), curve analysis, synthetic forward/spot |
|
||||
| `portfolio` | 10 | Beta, correlation matrix, drawdown, relative strength, spread, ratio, z-score, portfolio volatility |
|
||||
| `signals` | 4 | Rank values, compose rank, top/bottom N indices |
|
||||
| `alerts` | 3 | Threshold crossings, cross detection, alert bar collection |
|
||||
| `regime` | 4 | ADX regime, combined regime, CUSUM breaks, variance breaks |
|
||||
| `aggregation` | 3 | Tick bars, volume bars, time bars from trade data |
|
||||
| `resampling` | 2 | Volume bars, OHLCV aggregation by label |
|
||||
| `chunked` | 4 | Trim overlap, stitch chunks, make chunk ranges, forward fill NaN |
|
||||
| `crypto` | 3 | Funding cumulative PnL, continuous bar labels, session boundaries |
|
||||
|
||||
## Example
|
||||
|
||||
```rust
|
||||
use ferro_ta_core::overlap;
|
||||
|
||||
fn main() {
|
||||
let close = vec![1.0, 2.0, 3.0, 4.0, 5.0];
|
||||
let sma = overlap::sma(&close, 3);
|
||||
|
||||
assert!(sma[0].is_nan());
|
||||
assert!(sma[1].is_nan());
|
||||
assert!((sma[2] - 2.0).abs() < 1e-10);
|
||||
}
|
||||
```
|
||||
|
||||
## Relationship To `ferro-ta`
|
||||
|
||||
The published Python package (`ferro-ta` on PyPI) wraps this crate with PyO3 bindings and adds NumPy conversion, pandas/polars wrappers, and higher-level Python tooling. The WASM package (`ferro-ta-wasm` on npm) also wraps this crate with full feature parity.
|
||||
|
||||
If you only need Rust indicator functions, use `ferro_ta_core` directly.
|
||||
|
||||
## Development
|
||||
|
||||
From the repository root:
|
||||
|
||||
```bash
|
||||
cargo build -p ferro_ta_core
|
||||
cargo test -p ferro_ta_core
|
||||
cargo bench -p ferro_ta_core --no-run
|
||||
```
|
||||
|
||||
## License
|
||||
|
||||
MIT
|
||||
@@ -0,0 +1,212 @@
|
||||
//! Criterion benchmarks for ferro_ta_core — pure Rust indicator throughput.
|
||||
//!
|
||||
//! Run from repo root: cargo bench -p ferro_ta_core
|
||||
//! Or: cd crates/ferro_ta_core && cargo bench
|
||||
//!
|
||||
//! Input sizes: 1k, 10k, 100k, and 1M bars for key indicators.
|
||||
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
|
||||
use ferro_ta_core::{futures, momentum, options, overlap, volatility};
|
||||
use std::hint::black_box;
|
||||
|
||||
fn synthetic_close(n: usize) -> Vec<f64> {
|
||||
let mut v = Vec::with_capacity(n);
|
||||
let mut price = 100.0_f64;
|
||||
for i in 0..n {
|
||||
price += ((i as f64 * 0.1).sin()) * 0.5;
|
||||
v.push(price);
|
||||
}
|
||||
v
|
||||
}
|
||||
|
||||
fn synthetic_high_low_close(n: usize) -> (Vec<f64>, Vec<f64>, Vec<f64>) {
|
||||
let close = synthetic_close(n);
|
||||
let high: Vec<f64> = close.iter().map(|&c| c + 0.5).collect();
|
||||
let low: Vec<f64> = close.iter().map(|&c| c - 0.5).collect();
|
||||
(high, low, close)
|
||||
}
|
||||
|
||||
fn bench_sma(c: &mut Criterion) {
|
||||
let mut group = c.benchmark_group("SMA");
|
||||
for size in [1_000_usize, 10_000, 100_000, 1_000_000] {
|
||||
let close = synthetic_close(size);
|
||||
group.bench_with_input(BenchmarkId::from_parameter(size), &close, |b, close| {
|
||||
b.iter(|| overlap::sma(black_box(close), 14))
|
||||
});
|
||||
}
|
||||
group.finish();
|
||||
}
|
||||
|
||||
fn bench_ema(c: &mut Criterion) {
|
||||
let mut group = c.benchmark_group("EMA");
|
||||
for size in [1_000_usize, 10_000, 100_000, 1_000_000] {
|
||||
let close = synthetic_close(size);
|
||||
group.bench_with_input(BenchmarkId::from_parameter(size), &close, |b, close| {
|
||||
b.iter(|| overlap::ema(black_box(close), 14))
|
||||
});
|
||||
}
|
||||
group.finish();
|
||||
}
|
||||
|
||||
fn bench_rsi(c: &mut Criterion) {
|
||||
let mut group = c.benchmark_group("RSI");
|
||||
for size in [1_000_usize, 10_000, 100_000, 1_000_000] {
|
||||
let close = synthetic_close(size);
|
||||
group.bench_with_input(BenchmarkId::from_parameter(size), &close, |b, close| {
|
||||
b.iter(|| momentum::rsi(black_box(close), 14))
|
||||
});
|
||||
}
|
||||
group.finish();
|
||||
}
|
||||
|
||||
fn bench_atr(c: &mut Criterion) {
|
||||
let mut group = c.benchmark_group("ATR");
|
||||
for size in [1_000_usize, 10_000, 100_000, 1_000_000] {
|
||||
let (high, low, close) = synthetic_high_low_close(size);
|
||||
group.bench_with_input(
|
||||
BenchmarkId::from_parameter(size),
|
||||
&(high.clone(), low.clone(), close),
|
||||
|b, (high, low, close)| {
|
||||
b.iter(|| volatility::atr(black_box(high), black_box(low), black_box(close), 14))
|
||||
},
|
||||
);
|
||||
}
|
||||
group.finish();
|
||||
}
|
||||
|
||||
fn bench_bbands(c: &mut Criterion) {
|
||||
let mut group = c.benchmark_group("BBANDS");
|
||||
for size in [1_000_usize, 10_000, 100_000, 1_000_000] {
|
||||
let close = synthetic_close(size);
|
||||
group.bench_with_input(BenchmarkId::from_parameter(size), &close, |b, close| {
|
||||
b.iter(|| overlap::bbands(black_box(close), 20, 2.0, 2.0))
|
||||
});
|
||||
}
|
||||
group.finish();
|
||||
}
|
||||
|
||||
fn bench_bsm_price(c: &mut Criterion) {
|
||||
let mut group = c.benchmark_group("BSM_PRICE");
|
||||
for size in [1_000_usize, 10_000, 100_000] {
|
||||
let close = synthetic_close(size);
|
||||
let strikes: Vec<f64> = close.iter().map(|_| 100.0).collect();
|
||||
let vols: Vec<f64> = close.iter().map(|_| 0.2).collect();
|
||||
group.bench_with_input(BenchmarkId::from_parameter(size), &close, |b, close| {
|
||||
b.iter(|| {
|
||||
close
|
||||
.iter()
|
||||
.zip(strikes.iter())
|
||||
.zip(vols.iter())
|
||||
.map(|((&spot, &strike), &vol)| {
|
||||
options::pricing::black_scholes_price(
|
||||
black_box(spot),
|
||||
black_box(strike),
|
||||
black_box(0.02),
|
||||
black_box(0.0),
|
||||
black_box(0.5),
|
||||
black_box(vol),
|
||||
options::OptionKind::Call,
|
||||
)
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
})
|
||||
});
|
||||
}
|
||||
group.finish();
|
||||
}
|
||||
|
||||
fn bench_implied_volatility(c: &mut Criterion) {
|
||||
let mut group = c.benchmark_group("IMPLIED_VOL");
|
||||
for size in [1_000_usize, 10_000] {
|
||||
let prices: Vec<f64> = (0..size)
|
||||
.map(|i| {
|
||||
let spot = 90.0 + (i % 20) as f64;
|
||||
options::pricing::black_scholes_price(
|
||||
spot,
|
||||
100.0,
|
||||
0.02,
|
||||
0.0,
|
||||
0.5,
|
||||
0.2,
|
||||
options::OptionKind::Call,
|
||||
)
|
||||
})
|
||||
.collect();
|
||||
group.bench_with_input(BenchmarkId::from_parameter(size), &prices, |b, prices| {
|
||||
b.iter(|| {
|
||||
prices
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(i, &price)| {
|
||||
options::iv::implied_volatility(
|
||||
options::OptionContract {
|
||||
model: options::PricingModel::BlackScholes,
|
||||
underlying: black_box(90.0 + (i % 20) as f64),
|
||||
strike: black_box(100.0),
|
||||
rate: black_box(0.02),
|
||||
carry: black_box(0.0),
|
||||
time_to_expiry: black_box(0.5),
|
||||
kind: options::OptionKind::Call,
|
||||
},
|
||||
black_box(price),
|
||||
options::IvSolverConfig {
|
||||
initial_guess: black_box(0.25),
|
||||
tolerance: black_box(1e-8),
|
||||
max_iterations: black_box(100),
|
||||
},
|
||||
)
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
})
|
||||
});
|
||||
}
|
||||
group.finish();
|
||||
}
|
||||
|
||||
fn bench_smile_metrics(c: &mut Criterion) {
|
||||
let mut group = c.benchmark_group("SMILE_METRICS");
|
||||
let strikes: Vec<f64> = (0..41).map(|i| 80.0 + i as f64).collect();
|
||||
let vols: Vec<f64> = strikes
|
||||
.iter()
|
||||
.map(|&k| 0.18 + ((k - 100.0).abs() / 100.0) * 0.15)
|
||||
.collect();
|
||||
group.bench_function("single_chain", |b| {
|
||||
b.iter(|| {
|
||||
options::surface::smile_metrics(
|
||||
black_box(&strikes),
|
||||
black_box(&vols),
|
||||
black_box(100.0),
|
||||
black_box(0.02),
|
||||
black_box(0.0),
|
||||
black_box(0.5),
|
||||
options::PricingModel::BlackScholes,
|
||||
)
|
||||
})
|
||||
});
|
||||
group.finish();
|
||||
}
|
||||
|
||||
fn bench_curve_summary(c: &mut Criterion) {
|
||||
let mut group = c.benchmark_group("FUTURES_CURVE");
|
||||
let tenors = vec![0.1, 0.25, 0.5, 0.75, 1.0];
|
||||
let prices = vec![101.0, 101.8, 102.7, 103.4, 104.1];
|
||||
group.bench_function("curve_summary", |b| {
|
||||
b.iter(|| {
|
||||
futures::curve::curve_summary(black_box(100.0), black_box(&tenors), black_box(&prices))
|
||||
})
|
||||
});
|
||||
group.finish();
|
||||
}
|
||||
|
||||
criterion_group!(
|
||||
benches,
|
||||
bench_sma,
|
||||
bench_ema,
|
||||
bench_rsi,
|
||||
bench_atr,
|
||||
bench_bbands,
|
||||
bench_bsm_price,
|
||||
bench_implied_volatility,
|
||||
bench_smile_metrics,
|
||||
bench_curve_summary
|
||||
);
|
||||
criterion_main!(benches);
|
||||
@@ -0,0 +1,340 @@
|
||||
//! Tick / Trade Aggregation Pipeline — pure Rust, no PyO3.
|
||||
//!
|
||||
//! Aggregates raw tick/trade data into OHLCV bars:
|
||||
//! - **tick bars** — fixed number of ticks per bar
|
||||
//! - **volume bars** — fixed volume threshold per bar
|
||||
//! - **time bars** — label-based grouping (labels from Python timestamps)
|
||||
|
||||
/// OHLCV 5-tuple return type alias.
|
||||
type Ohlcv5 = (Vec<f64>, Vec<f64>, Vec<f64>, Vec<f64>, Vec<f64>);
|
||||
|
||||
/// OHLCV 5-tuple plus labels return type alias.
|
||||
type Ohlcv5AndLabels = (Vec<f64>, Vec<f64>, Vec<f64>, Vec<f64>, Vec<f64>, Vec<i64>);
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// aggregate_tick_bars
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Aggregate tick/trade data into tick bars (every N ticks become one bar).
|
||||
///
|
||||
/// Returns `(open, high, low, close, volume)` where volume = sum of sizes.
|
||||
///
|
||||
/// # Panics
|
||||
/// Panics if `ticks_per_bar == 0`, arrays are empty, or lengths differ.
|
||||
pub fn aggregate_tick_bars(price: &[f64], size: &[f64], ticks_per_bar: usize) -> Ohlcv5 {
|
||||
assert!(ticks_per_bar >= 1, "ticks_per_bar must be >= 1");
|
||||
let n = price.len();
|
||||
assert!(
|
||||
n > 0 && size.len() == n,
|
||||
"price and size must be non-empty and equal length"
|
||||
);
|
||||
|
||||
let n_bars = n.div_ceil(ticks_per_bar);
|
||||
let mut out_open = Vec::with_capacity(n_bars);
|
||||
let mut out_high = Vec::with_capacity(n_bars);
|
||||
let mut out_low = Vec::with_capacity(n_bars);
|
||||
let mut out_close = Vec::with_capacity(n_bars);
|
||||
let mut out_vol = Vec::with_capacity(n_bars);
|
||||
|
||||
let mut i = 0;
|
||||
while i < n {
|
||||
let end = (i + ticks_per_bar).min(n);
|
||||
let bar_p = &price[i..end];
|
||||
let bar_s = &size[i..end];
|
||||
let bar_open = bar_p[0];
|
||||
let bar_high = bar_p.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
|
||||
let bar_low = bar_p.iter().cloned().fold(f64::INFINITY, f64::min);
|
||||
let bar_close = *bar_p.last().expect("slice cannot be empty");
|
||||
let bar_vol: f64 = bar_s.iter().sum();
|
||||
out_open.push(bar_open);
|
||||
out_high.push(bar_high);
|
||||
out_low.push(bar_low);
|
||||
out_close.push(bar_close);
|
||||
out_vol.push(bar_vol);
|
||||
i = end;
|
||||
}
|
||||
|
||||
(out_open, out_high, out_low, out_close, out_vol)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// aggregate_volume_bars_ticks
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Aggregate tick data into volume bars (fixed volume threshold).
|
||||
///
|
||||
/// Accumulates ticks until cumulative size >= `volume_threshold`, then emits
|
||||
/// a bar. Any remaining partial bar is also emitted.
|
||||
///
|
||||
/// Returns `(open, high, low, close, volume)`.
|
||||
///
|
||||
/// # Panics
|
||||
/// Panics if `volume_threshold <= 0`, arrays are empty, or lengths differ.
|
||||
pub fn aggregate_volume_bars_ticks(price: &[f64], size: &[f64], volume_threshold: f64) -> Ohlcv5 {
|
||||
assert!(volume_threshold > 0.0, "volume_threshold must be > 0");
|
||||
let n = price.len();
|
||||
assert!(
|
||||
n > 0 && size.len() == n,
|
||||
"price and size must be non-empty and equal length"
|
||||
);
|
||||
|
||||
let mut out_open: Vec<f64> = Vec::new();
|
||||
let mut out_high: Vec<f64> = Vec::new();
|
||||
let mut out_low: Vec<f64> = Vec::new();
|
||||
let mut out_close: Vec<f64> = Vec::new();
|
||||
let mut out_vol: Vec<f64> = Vec::new();
|
||||
|
||||
let mut bar_open = price[0];
|
||||
let mut bar_high = price[0];
|
||||
let mut bar_low = price[0];
|
||||
let mut bar_close = price[0];
|
||||
let mut bar_vol = size[0];
|
||||
|
||||
for i in 1..n {
|
||||
bar_high = bar_high.max(price[i]);
|
||||
bar_low = bar_low.min(price[i]);
|
||||
bar_close = price[i];
|
||||
bar_vol += size[i];
|
||||
|
||||
if bar_vol >= volume_threshold {
|
||||
out_open.push(bar_open);
|
||||
out_high.push(bar_high);
|
||||
out_low.push(bar_low);
|
||||
out_close.push(bar_close);
|
||||
out_vol.push(bar_vol);
|
||||
if i + 1 < n {
|
||||
bar_open = price[i + 1];
|
||||
bar_high = price[i + 1];
|
||||
bar_low = price[i + 1];
|
||||
bar_close = price[i + 1];
|
||||
bar_vol = size[i + 1];
|
||||
} else {
|
||||
bar_vol = 0.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
// Push remaining partial bar
|
||||
if bar_vol > 0.0 {
|
||||
out_open.push(bar_open);
|
||||
out_high.push(bar_high);
|
||||
out_low.push(bar_low);
|
||||
out_close.push(bar_close);
|
||||
out_vol.push(bar_vol);
|
||||
}
|
||||
|
||||
(out_open, out_high, out_low, out_close, out_vol)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// aggregate_time_bars
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Aggregate tick data into time bars using pre-computed integer bucket labels.
|
||||
///
|
||||
/// Each tick is assigned a `label` (e.g. unix_ts // period_secs). Ticks with
|
||||
/// the same label are accumulated into one bar. Labels must be non-decreasing.
|
||||
///
|
||||
/// Returns `(open, high, low, close, volume, unique_labels)`.
|
||||
///
|
||||
/// # Panics
|
||||
/// Panics if arrays are empty or have unequal lengths.
|
||||
pub fn aggregate_time_bars(price: &[f64], size: &[f64], labels: &[i64]) -> Ohlcv5AndLabels {
|
||||
let n = price.len();
|
||||
assert!(
|
||||
n > 0 && size.len() == n && labels.len() == n,
|
||||
"price, size, and labels must be non-empty and equal length"
|
||||
);
|
||||
|
||||
let mut out_open: Vec<f64> = Vec::new();
|
||||
let mut out_high: Vec<f64> = Vec::new();
|
||||
let mut out_low: Vec<f64> = Vec::new();
|
||||
let mut out_close: Vec<f64> = Vec::new();
|
||||
let mut out_vol: Vec<f64> = Vec::new();
|
||||
let mut out_labels: Vec<i64> = Vec::new();
|
||||
|
||||
let mut cur_label = labels[0];
|
||||
let mut bar_open = price[0];
|
||||
let mut bar_high = price[0];
|
||||
let mut bar_low = price[0];
|
||||
let mut bar_close = price[0];
|
||||
let mut bar_vol = size[0];
|
||||
|
||||
for i in 1..n {
|
||||
if labels[i] != cur_label {
|
||||
out_open.push(bar_open);
|
||||
out_high.push(bar_high);
|
||||
out_low.push(bar_low);
|
||||
out_close.push(bar_close);
|
||||
out_vol.push(bar_vol);
|
||||
out_labels.push(cur_label);
|
||||
cur_label = labels[i];
|
||||
bar_open = price[i];
|
||||
bar_high = price[i];
|
||||
bar_low = price[i];
|
||||
bar_close = price[i];
|
||||
bar_vol = size[i];
|
||||
} else {
|
||||
bar_high = bar_high.max(price[i]);
|
||||
bar_low = bar_low.min(price[i]);
|
||||
bar_close = price[i];
|
||||
bar_vol += size[i];
|
||||
}
|
||||
}
|
||||
out_open.push(bar_open);
|
||||
out_high.push(bar_high);
|
||||
out_low.push(bar_low);
|
||||
out_close.push(bar_close);
|
||||
out_vol.push(bar_vol);
|
||||
out_labels.push(cur_label);
|
||||
|
||||
(out_open, out_high, out_low, out_close, out_vol, out_labels)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
// -- aggregate_tick_bars -------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn test_tick_bars_exact_division() {
|
||||
let price = [10.0, 11.0, 12.0, 13.0, 14.0, 15.0];
|
||||
let size = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0];
|
||||
let (o, h, l, c, v) = aggregate_tick_bars(&price, &size, 3);
|
||||
assert_eq!(o.len(), 2);
|
||||
// Bar 0: ticks 0..3
|
||||
assert!((o[0] - 10.0).abs() < 1e-10);
|
||||
assert!((h[0] - 12.0).abs() < 1e-10);
|
||||
assert!((l[0] - 10.0).abs() < 1e-10);
|
||||
assert!((c[0] - 12.0).abs() < 1e-10);
|
||||
assert!((v[0] - 6.0).abs() < 1e-10);
|
||||
// Bar 1: ticks 3..6
|
||||
assert!((o[1] - 13.0).abs() < 1e-10);
|
||||
assert!((h[1] - 15.0).abs() < 1e-10);
|
||||
assert!((l[1] - 13.0).abs() < 1e-10);
|
||||
assert!((c[1] - 15.0).abs() < 1e-10);
|
||||
assert!((v[1] - 15.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_tick_bars_partial_last_bar() {
|
||||
let price = [10.0, 11.0, 12.0, 13.0, 14.0];
|
||||
let size = [1.0, 2.0, 3.0, 4.0, 5.0];
|
||||
let (o, _h, _l, c, v) = aggregate_tick_bars(&price, &size, 3);
|
||||
assert_eq!(o.len(), 2);
|
||||
// Partial bar: ticks 3..5
|
||||
assert!((o[1] - 13.0).abs() < 1e-10);
|
||||
assert!((c[1] - 14.0).abs() < 1e-10);
|
||||
assert!((v[1] - 9.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_tick_bars_single_tick() {
|
||||
let (o, h, l, c, v) = aggregate_tick_bars(&[42.0], &[100.0], 5);
|
||||
assert_eq!(o.len(), 1);
|
||||
assert!((o[0] - 42.0).abs() < 1e-10);
|
||||
assert!((h[0] - 42.0).abs() < 1e-10);
|
||||
assert!((l[0] - 42.0).abs() < 1e-10);
|
||||
assert!((c[0] - 42.0).abs() < 1e-10);
|
||||
assert!((v[0] - 100.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic(expected = "ticks_per_bar must be >= 1")]
|
||||
fn test_tick_bars_zero_ticks() {
|
||||
aggregate_tick_bars(&[1.0], &[1.0], 0);
|
||||
}
|
||||
|
||||
// -- aggregate_volume_bars_ticks -----------------------------------------
|
||||
|
||||
#[test]
|
||||
fn test_volume_bars_ticks_basic() {
|
||||
let price = [10.0, 11.0, 12.0, 13.0, 14.0];
|
||||
let size = [30.0, 40.0, 50.0, 20.0, 60.0];
|
||||
// threshold=70: bar0 = ticks 0+1 (vol=70), bar1 = tick2 (vol=50) + tick3 (vol=70),
|
||||
// then tick4 as partial
|
||||
let (o, h, l, c, v) = aggregate_volume_bars_ticks(&price, &size, 70.0);
|
||||
// First bar: 30+40=70 >= 70
|
||||
assert!((o[0] - 10.0).abs() < 1e-10);
|
||||
assert!((c[0] - 11.0).abs() < 1e-10);
|
||||
assert!((v[0] - 70.0).abs() < 1e-10);
|
||||
assert!((h[0] - 11.0).abs() < 1e-10);
|
||||
assert!((l[0] - 10.0).abs() < 1e-10);
|
||||
assert!(v.len() >= 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_volume_bars_ticks_single() {
|
||||
let (o, _h, _l, _c, v) = aggregate_volume_bars_ticks(&[5.0], &[10.0], 100.0);
|
||||
assert_eq!(o.len(), 1);
|
||||
assert!((v[0] - 10.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic(expected = "volume_threshold must be > 0")]
|
||||
fn test_volume_bars_ticks_zero_threshold() {
|
||||
aggregate_volume_bars_ticks(&[1.0], &[1.0], 0.0);
|
||||
}
|
||||
|
||||
// -- aggregate_time_bars -------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn test_time_bars_basic() {
|
||||
let price = [10.0, 11.0, 12.0, 13.0, 14.0];
|
||||
let size = [1.0, 2.0, 3.0, 4.0, 5.0];
|
||||
let labels: [i64; 5] = [0, 0, 1, 1, 1];
|
||||
let (o, h, l, c, v, out_lbl) = aggregate_time_bars(&price, &size, &labels);
|
||||
assert_eq!(o.len(), 2);
|
||||
assert_eq!(out_lbl, vec![0, 1]);
|
||||
// Group 0: ticks 0,1
|
||||
assert!((o[0] - 10.0).abs() < 1e-10);
|
||||
assert!((h[0] - 11.0).abs() < 1e-10);
|
||||
assert!((l[0] - 10.0).abs() < 1e-10);
|
||||
assert!((c[0] - 11.0).abs() < 1e-10);
|
||||
assert!((v[0] - 3.0).abs() < 1e-10);
|
||||
// Group 1: ticks 2,3,4
|
||||
assert!((o[1] - 12.0).abs() < 1e-10);
|
||||
assert!((h[1] - 14.0).abs() < 1e-10);
|
||||
assert!((l[1] - 12.0).abs() < 1e-10);
|
||||
assert!((c[1] - 14.0).abs() < 1e-10);
|
||||
assert!((v[1] - 12.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_time_bars_all_same_label() {
|
||||
let price = [5.0, 6.0, 4.0];
|
||||
let size = [10.0, 20.0, 30.0];
|
||||
let labels: [i64; 3] = [42, 42, 42];
|
||||
let (o, h, l, c, v, out_lbl) = aggregate_time_bars(&price, &size, &labels);
|
||||
assert_eq!(o.len(), 1);
|
||||
assert_eq!(out_lbl, vec![42]);
|
||||
assert!((o[0] - 5.0).abs() < 1e-10);
|
||||
assert!((h[0] - 6.0).abs() < 1e-10);
|
||||
assert!((l[0] - 4.0).abs() < 1e-10);
|
||||
assert!((c[0] - 4.0).abs() < 1e-10);
|
||||
assert!((v[0] - 60.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_time_bars_each_tick_own_label() {
|
||||
let price = [10.0, 20.0, 30.0];
|
||||
let size = [1.0, 2.0, 3.0];
|
||||
let labels: [i64; 3] = [0, 1, 2];
|
||||
let (o, _h, _l, _c, v, out_lbl) = aggregate_time_bars(&price, &size, &labels);
|
||||
assert_eq!(o.len(), 3);
|
||||
assert_eq!(out_lbl, vec![0, 1, 2]);
|
||||
assert!((v[0] - 1.0).abs() < 1e-10);
|
||||
assert!((v[1] - 2.0).abs() < 1e-10);
|
||||
assert!((v[2] - 3.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic(expected = "price, size, and labels must be non-empty and equal length")]
|
||||
fn test_time_bars_empty() {
|
||||
aggregate_time_bars(&[], &[], &[]);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,126 @@
|
||||
//! Alerts — condition evaluation helpers.
|
||||
//!
|
||||
//! - `check_threshold` — fires when a series crosses above/below a level
|
||||
//! - `check_cross` — fires when *fast* crosses above or below *slow*
|
||||
//! - `collect_alert_bars` — returns indices of bars where a mask is non-zero
|
||||
|
||||
/// Fire an alert when `series` crosses a threshold level.
|
||||
///
|
||||
/// `direction`: `1` = cross above, `-1` = cross below.
|
||||
///
|
||||
/// Returns a `Vec<i8>` with `1` at crossing bars, `0` elsewhere.
|
||||
/// Element 0 is always 0.
|
||||
pub fn check_threshold(series: &[f64], level: f64, direction: i32) -> Vec<i8> {
|
||||
let n = series.len();
|
||||
let mut out = vec![0i8; n];
|
||||
if n < 2 {
|
||||
return out;
|
||||
}
|
||||
for i in 1..n {
|
||||
let prev = series[i - 1];
|
||||
let curr = series[i];
|
||||
if prev.is_nan() || curr.is_nan() {
|
||||
continue;
|
||||
}
|
||||
if (direction == 1 && prev <= level && curr > level)
|
||||
|| (direction == -1 && prev >= level && curr < level)
|
||||
{
|
||||
out[i] = 1;
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Detect cross-over / cross-under events between two series.
|
||||
///
|
||||
/// Returns `Vec<i8>`: `1` = bullish cross (fast above slow), `-1` = bearish, `0` = none.
|
||||
/// Element 0 is always 0.
|
||||
pub fn check_cross(fast: &[f64], slow: &[f64]) -> Vec<i8> {
|
||||
let n = fast.len();
|
||||
let mut out = vec![0i8; n];
|
||||
if n < 2 {
|
||||
return out;
|
||||
}
|
||||
for i in 1..n {
|
||||
let fp = fast[i - 1];
|
||||
let fc = fast[i];
|
||||
let sp = slow[i - 1];
|
||||
let sc = slow[i];
|
||||
if fp.is_nan() || fc.is_nan() || sp.is_nan() || sc.is_nan() {
|
||||
continue;
|
||||
}
|
||||
if fp <= sp && fc > sc {
|
||||
out[i] = 1;
|
||||
} else if fp >= sp && fc < sc {
|
||||
out[i] = -1;
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Collect bar indices where `mask` is non-zero.
|
||||
pub fn collect_alert_bars(mask: &[i8]) -> Vec<i64> {
|
||||
mask.iter()
|
||||
.enumerate()
|
||||
.filter(|(_, &v)| v != 0)
|
||||
.map(|(i, _)| i as i64)
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_check_threshold_cross_above() {
|
||||
let series = vec![10.0, 20.0, 30.0, 40.0, 50.0];
|
||||
let result = check_threshold(&series, 25.0, 1);
|
||||
assert_eq!(result, vec![0, 0, 1, 0, 0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_check_threshold_cross_below() {
|
||||
let series = vec![50.0, 40.0, 30.0, 20.0, 10.0];
|
||||
let result = check_threshold(&series, 25.0, -1);
|
||||
assert_eq!(result, vec![0, 0, 0, 1, 0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_check_cross_bullish() {
|
||||
let fast = vec![1.0, 2.0, 5.0];
|
||||
let slow = vec![3.0, 3.0, 3.0];
|
||||
let result = check_cross(&fast, &slow);
|
||||
assert_eq!(result, vec![0, 0, 1]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_check_cross_bearish() {
|
||||
let fast = vec![5.0, 4.0, 1.0];
|
||||
let slow = vec![3.0, 3.0, 3.0];
|
||||
let result = check_cross(&fast, &slow);
|
||||
assert_eq!(result, vec![0, 0, -1]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_collect_alert_bars() {
|
||||
let mask = vec![0i8, 1, 0, -1, 0, 1];
|
||||
let result = collect_alert_bars(&mask);
|
||||
assert_eq!(result, vec![1, 3, 5]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_empty() {
|
||||
assert_eq!(check_threshold(&[], 0.0, 1), Vec::<i8>::new());
|
||||
assert_eq!(check_cross(&[], &[]), Vec::<i8>::new());
|
||||
assert_eq!(collect_alert_bars(&[]), Vec::<i64>::new());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_nan_handling() {
|
||||
let series = vec![10.0, f64::NAN, 30.0, 40.0];
|
||||
let result = check_threshold(&series, 25.0, 1);
|
||||
// NaN bars are skipped
|
||||
assert_eq!(result[1], 0);
|
||||
assert_eq!(result[2], 0); // prev is NaN
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,333 @@
|
||||
//! Performance attribution and trade analysis — pure Rust, no PyO3.
|
||||
//!
|
||||
//! Functions
|
||||
//! ---------
|
||||
//! - `trade_stats` — win rate, avg win/loss, profit factor, avg hold
|
||||
//! - `monthly_contribution` — group bar returns by month index and sum
|
||||
//! - `signal_attribution` — group bar returns by signal label and sum
|
||||
//! - `extract_trades` — extract trade pnl and hold durations from positions
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// trade_stats
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Compute trade-level statistics from trade PnL and hold durations.
|
||||
///
|
||||
/// Returns `(win_rate, avg_win, avg_loss, profit_factor, avg_hold_bars)`.
|
||||
///
|
||||
/// - **win_rate** : fraction of trades with PnL > 0
|
||||
/// - **avg_win** : mean PnL of winning trades (0 if none)
|
||||
/// - **avg_loss** : mean PnL of losing trades (negative; 0 if none)
|
||||
/// - **profit_factor** : gross profit / |gross loss| (inf if no losses)
|
||||
/// - **avg_hold_bars** : mean hold duration across all trades
|
||||
///
|
||||
/// # Panics
|
||||
/// Panics if `pnl` is empty or `pnl.len() != hold_bars.len()`.
|
||||
pub fn trade_stats(pnl: &[f64], hold_bars: &[f64]) -> (f64, f64, f64, f64, f64) {
|
||||
let n = pnl.len();
|
||||
assert!(n > 0, "pnl must be non-empty");
|
||||
assert_eq!(
|
||||
n,
|
||||
hold_bars.len(),
|
||||
"pnl and hold_bars must have equal length"
|
||||
);
|
||||
|
||||
let mut wins: Vec<f64> = Vec::new();
|
||||
let mut losses: Vec<f64> = Vec::new();
|
||||
for &v in pnl.iter() {
|
||||
if v > 0.0 {
|
||||
wins.push(v);
|
||||
} else if v < 0.0 {
|
||||
losses.push(v);
|
||||
}
|
||||
}
|
||||
|
||||
let win_rate = wins.len() as f64 / n as f64;
|
||||
let avg_win = if wins.is_empty() {
|
||||
0.0
|
||||
} else {
|
||||
wins.iter().sum::<f64>() / wins.len() as f64
|
||||
};
|
||||
let avg_loss = if losses.is_empty() {
|
||||
0.0
|
||||
} else {
|
||||
losses.iter().sum::<f64>() / losses.len() as f64
|
||||
};
|
||||
|
||||
let gross_profit: f64 = wins.iter().sum();
|
||||
let gross_loss: f64 = losses.iter().map(|v| v.abs()).sum();
|
||||
let profit_factor = if gross_loss == 0.0 {
|
||||
f64::INFINITY
|
||||
} else {
|
||||
gross_profit / gross_loss
|
||||
};
|
||||
|
||||
let avg_hold = hold_bars.iter().sum::<f64>() / n as f64;
|
||||
|
||||
(win_rate, avg_win, avg_loss, profit_factor, avg_hold)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// monthly_contribution
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Group per-bar returns by month index and sum each month's contribution.
|
||||
///
|
||||
/// Returns `(months, contributions)` where `months` is sorted unique month
|
||||
/// indices and `contributions` is the corresponding total return per month.
|
||||
/// NaN returns are skipped.
|
||||
///
|
||||
/// # Panics
|
||||
/// Panics if `bar_returns.len() != month_index.len()`.
|
||||
pub fn monthly_contribution(bar_returns: &[f64], month_index: &[i64]) -> (Vec<i64>, Vec<f64>) {
|
||||
let n = bar_returns.len();
|
||||
assert_eq!(
|
||||
n,
|
||||
month_index.len(),
|
||||
"bar_returns and month_index must have equal length"
|
||||
);
|
||||
|
||||
let mut map: HashMap<i64, f64> = HashMap::new();
|
||||
for i in 0..n {
|
||||
if !bar_returns[i].is_nan() {
|
||||
*map.entry(month_index[i]).or_insert(0.0) += bar_returns[i];
|
||||
}
|
||||
}
|
||||
|
||||
let mut months: Vec<i64> = map.keys().copied().collect();
|
||||
months.sort_unstable();
|
||||
let contributions: Vec<f64> = months.iter().map(|m| map[m]).collect();
|
||||
|
||||
(months, contributions)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// signal_attribution
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Attribute per-bar returns to each signal label.
|
||||
///
|
||||
/// Returns `(labels, contributions)` where `labels` is sorted unique signal
|
||||
/// labels and `contributions` is the corresponding total return per label.
|
||||
/// NaN returns are skipped.
|
||||
///
|
||||
/// # Panics
|
||||
/// Panics if `bar_returns.len() != signal_labels.len()`.
|
||||
pub fn signal_attribution(bar_returns: &[f64], signal_labels: &[i64]) -> (Vec<i64>, Vec<f64>) {
|
||||
let n = bar_returns.len();
|
||||
assert_eq!(
|
||||
n,
|
||||
signal_labels.len(),
|
||||
"bar_returns and signal_labels must have equal length"
|
||||
);
|
||||
|
||||
let mut map: HashMap<i64, f64> = HashMap::new();
|
||||
for i in 0..n {
|
||||
if !bar_returns[i].is_nan() {
|
||||
*map.entry(signal_labels[i]).or_insert(0.0) += bar_returns[i];
|
||||
}
|
||||
}
|
||||
|
||||
let mut labels: Vec<i64> = map.keys().copied().collect();
|
||||
labels.sort_unstable();
|
||||
let contributions: Vec<f64> = labels.iter().map(|l| map[l]).collect();
|
||||
|
||||
(labels, contributions)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// extract_trades
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Extract trade-level PnL and hold durations from positions and strategy returns.
|
||||
///
|
||||
/// A trade is a maximal contiguous run of non-zero position values with the
|
||||
/// same sign/magnitude. Returns `(pnl, hold_durations)`.
|
||||
///
|
||||
/// # Panics
|
||||
/// Panics if `positions.len() != strategy_returns.len()`.
|
||||
pub fn extract_trades(positions: &[f64], strategy_returns: &[f64]) -> (Vec<f64>, Vec<f64>) {
|
||||
let n = positions.len();
|
||||
assert_eq!(
|
||||
n,
|
||||
strategy_returns.len(),
|
||||
"positions and strategy_returns must have equal length"
|
||||
);
|
||||
|
||||
let mut pnl = Vec::<f64>::new();
|
||||
let mut hold = Vec::<f64>::new();
|
||||
|
||||
let mut i = 0usize;
|
||||
while i < n {
|
||||
if positions[i] == 0.0 {
|
||||
i += 1;
|
||||
continue;
|
||||
}
|
||||
let mut j = i + 1;
|
||||
while j < n && positions[j] == positions[i] {
|
||||
j += 1;
|
||||
}
|
||||
let mut trade_pnl = 0.0_f64;
|
||||
for v in strategy_returns.iter().take(j).skip(i) {
|
||||
trade_pnl += *v;
|
||||
}
|
||||
pnl.push(trade_pnl);
|
||||
hold.push((j - i) as f64);
|
||||
i = j;
|
||||
}
|
||||
|
||||
(pnl, hold)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
// -- trade_stats ---------------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn test_trade_stats_basic() {
|
||||
let pnl = [100.0, -50.0, 200.0, -30.0, 150.0];
|
||||
let hold = [5.0, 3.0, 7.0, 2.0, 6.0];
|
||||
let (wr, aw, al, pf, ah) = trade_stats(&pnl, &hold);
|
||||
|
||||
// 3 wins out of 5
|
||||
assert!((wr - 0.6).abs() < 1e-10);
|
||||
// avg win = (100+200+150)/3
|
||||
assert!((aw - 150.0).abs() < 1e-10);
|
||||
// avg loss = (-50 + -30)/2 = -40
|
||||
assert!((al - (-40.0)).abs() < 1e-10);
|
||||
// profit_factor = 450 / 80
|
||||
assert!((pf - 5.625).abs() < 1e-10);
|
||||
// avg hold = (5+3+7+2+6)/5 = 4.6
|
||||
assert!((ah - 4.6).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_trade_stats_all_wins() {
|
||||
let pnl = [10.0, 20.0];
|
||||
let hold = [1.0, 2.0];
|
||||
let (wr, _aw, al, pf, _ah) = trade_stats(&pnl, &hold);
|
||||
assert!((wr - 1.0).abs() < 1e-10);
|
||||
assert!((al - 0.0).abs() < 1e-10);
|
||||
assert!(pf.is_infinite());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_trade_stats_all_losses() {
|
||||
let pnl = [-10.0, -20.0];
|
||||
let hold = [1.0, 2.0];
|
||||
let (wr, aw, _al, pf, _ah) = trade_stats(&pnl, &hold);
|
||||
assert!((wr - 0.0).abs() < 1e-10);
|
||||
assert!((aw - 0.0).abs() < 1e-10);
|
||||
assert!((pf - 0.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic(expected = "pnl must be non-empty")]
|
||||
fn test_trade_stats_empty() {
|
||||
trade_stats(&[], &[]);
|
||||
}
|
||||
|
||||
// -- monthly_contribution ------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn test_monthly_contribution_basic() {
|
||||
let returns = [0.01, 0.02, -0.01, 0.03, -0.02];
|
||||
let months = [0, 0, 1, 1, 2];
|
||||
let (m, c) = monthly_contribution(&returns, &months);
|
||||
assert_eq!(m, vec![0, 1, 2]);
|
||||
assert!((c[0] - 0.03).abs() < 1e-10);
|
||||
assert!((c[1] - 0.02).abs() < 1e-10);
|
||||
assert!((c[2] - (-0.02)).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_monthly_contribution_nan_skipped() {
|
||||
let returns = [0.01, f64::NAN, 0.03];
|
||||
let months = [0, 0, 1];
|
||||
let (m, c) = monthly_contribution(&returns, &months);
|
||||
assert_eq!(m, vec![0, 1]);
|
||||
assert!((c[0] - 0.01).abs() < 1e-10);
|
||||
assert!((c[1] - 0.03).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_monthly_contribution_empty() {
|
||||
let (m, c) = monthly_contribution(&[], &[]);
|
||||
assert!(m.is_empty());
|
||||
assert!(c.is_empty());
|
||||
}
|
||||
|
||||
// -- signal_attribution --------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn test_signal_attribution_basic() {
|
||||
let returns = [0.05, -0.02, 0.03, 0.01];
|
||||
let labels = [1, -1, 2, 1];
|
||||
let (l, c) = signal_attribution(&returns, &labels);
|
||||
assert_eq!(l, vec![-1, 1, 2]);
|
||||
assert!((c[0] - (-0.02)).abs() < 1e-10);
|
||||
assert!((c[1] - 0.06).abs() < 1e-10); // 0.05 + 0.01
|
||||
assert!((c[2] - 0.03).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_signal_attribution_nan_skipped() {
|
||||
let returns = [0.05, f64::NAN];
|
||||
let labels = [1, 2];
|
||||
let (l, c) = signal_attribution(&returns, &labels);
|
||||
assert_eq!(l, vec![1]);
|
||||
assert!((c[0] - 0.05).abs() < 1e-10);
|
||||
}
|
||||
|
||||
// -- extract_trades ------------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn test_extract_trades_basic() {
|
||||
// positions: flat, long, long, flat, short, short
|
||||
let positions = [0.0, 1.0, 1.0, 0.0, -1.0, -1.0];
|
||||
let strat_ret = [0.0, 0.01, 0.02, 0.0, -0.01, 0.03];
|
||||
let (pnl, hold) = extract_trades(&positions, &strat_ret);
|
||||
assert_eq!(pnl.len(), 2);
|
||||
assert_eq!(hold.len(), 2);
|
||||
// First trade: bars 1..3 => 0.01 + 0.02 = 0.03
|
||||
assert!((pnl[0] - 0.03).abs() < 1e-10);
|
||||
assert!((hold[0] - 2.0).abs() < 1e-10);
|
||||
// Second trade: bars 4..6 => -0.01 + 0.03 = 0.02
|
||||
assert!((pnl[1] - 0.02).abs() < 1e-10);
|
||||
assert!((hold[1] - 2.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_extract_trades_all_flat() {
|
||||
let positions = [0.0, 0.0, 0.0];
|
||||
let strat_ret = [0.01, 0.02, 0.03];
|
||||
let (pnl, hold) = extract_trades(&positions, &strat_ret);
|
||||
assert!(pnl.is_empty());
|
||||
assert!(hold.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_extract_trades_empty() {
|
||||
let (pnl, hold) = extract_trades(&[], &[]);
|
||||
assert!(pnl.is_empty());
|
||||
assert!(hold.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_extract_trades_single_bar_trade() {
|
||||
let positions = [0.0, 1.0, 0.0];
|
||||
let strat_ret = [0.0, 0.05, 0.0];
|
||||
let (pnl, hold) = extract_trades(&positions, &strat_ret);
|
||||
assert_eq!(pnl.len(), 1);
|
||||
assert!((pnl[0] - 0.05).abs() < 1e-10);
|
||||
assert!((hold[0] - 1.0).abs() < 1e-10);
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,641 @@
|
||||
//! Pure-Rust batch operations — apply indicators across multiple series
|
||||
//! (columns) sequentially. The PyO3 wrapper can add Rayon parallelism on top.
|
||||
//!
|
||||
//! Input convention: `data[j]` is column *j* (one time-series). All columns
|
||||
//! must have the same length.
|
||||
|
||||
use crate::{momentum, overlap, statistic, volatility};
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// helpers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Validate that every column in `data` has the same length. Returns `Ok(n)`
|
||||
/// where `n` is the common length, or `Err` with a message.
|
||||
fn validate_columns(data: &[Vec<f64>]) -> Result<usize, String> {
|
||||
if data.is_empty() {
|
||||
return Ok(0);
|
||||
}
|
||||
let n = data[0].len();
|
||||
for (idx, col) in data.iter().enumerate() {
|
||||
if col.len() != n {
|
||||
return Err(format!(
|
||||
"column 0 has length {n}, but column {idx} has length {}",
|
||||
col.len()
|
||||
));
|
||||
}
|
||||
}
|
||||
Ok(n)
|
||||
}
|
||||
|
||||
fn validate_hlc_columns(
|
||||
high: &[Vec<f64>],
|
||||
low: &[Vec<f64>],
|
||||
close: &[Vec<f64>],
|
||||
) -> Result<(usize, usize), String> {
|
||||
let n_series = high.len();
|
||||
if low.len() != n_series || close.len() != n_series {
|
||||
return Err(format!(
|
||||
"high has {} columns, low has {}, close has {} — must be equal",
|
||||
n_series,
|
||||
low.len(),
|
||||
close.len()
|
||||
));
|
||||
}
|
||||
if n_series == 0 {
|
||||
return Ok((0, 0));
|
||||
}
|
||||
let n = high[0].len();
|
||||
for (idx, (h, (l, c))) in high.iter().zip(low.iter().zip(close.iter())).enumerate() {
|
||||
if h.len() != n || l.len() != n || c.len() != n {
|
||||
return Err(format!(
|
||||
"column {idx}: high len={}, low len={}, close len={} — must all be {n}",
|
||||
h.len(),
|
||||
l.len(),
|
||||
c.len()
|
||||
));
|
||||
}
|
||||
}
|
||||
Ok((n, n_series))
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// rolling linear regression (self-contained so core has no PyO3 dep)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
fn linreg(window: &[f64]) -> (f64, f64) {
|
||||
let n = window.len() as f64;
|
||||
let sum_x: f64 = (0..window.len()).map(|i| i as f64).sum();
|
||||
let sum_y: f64 = window.iter().sum();
|
||||
let sum_xy: f64 = window.iter().enumerate().map(|(i, &y)| i as f64 * y).sum();
|
||||
let sum_x2: f64 = (0..window.len()).map(|i| (i as f64).powi(2)).sum();
|
||||
let denom = n * sum_x2 - sum_x * sum_x;
|
||||
let slope = if denom != 0.0 {
|
||||
(n * sum_xy - sum_x * sum_y) / denom
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
let intercept = (sum_y - slope * sum_x) / n;
|
||||
(slope, intercept)
|
||||
}
|
||||
|
||||
fn rolling_linreg_apply<F>(prices: &[f64], timeperiod: usize, mut map: F) -> Vec<f64>
|
||||
where
|
||||
F: FnMut(f64, f64) -> f64,
|
||||
{
|
||||
let n = prices.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if timeperiod == 0 || n < timeperiod {
|
||||
return result;
|
||||
}
|
||||
|
||||
if prices.iter().any(|value| !value.is_finite()) {
|
||||
for end in (timeperiod - 1)..n {
|
||||
let window = &prices[(end + 1 - timeperiod)..=end];
|
||||
let (slope, intercept) = linreg(window);
|
||||
result[end] = map(slope, intercept);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
let period = timeperiod as f64;
|
||||
let last_x = (timeperiod - 1) as f64;
|
||||
let sum_x = last_x * period / 2.0;
|
||||
let sum_x2 = last_x * period * (2.0 * period - 1.0) / 6.0;
|
||||
let denom = period * sum_x2 - sum_x * sum_x;
|
||||
|
||||
let mut sum_y = prices[..timeperiod].iter().sum::<f64>();
|
||||
let mut sum_xy = prices[..timeperiod]
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(idx, &value)| idx as f64 * value)
|
||||
.sum::<f64>();
|
||||
|
||||
for end in (timeperiod - 1)..n {
|
||||
let slope = if denom != 0.0 {
|
||||
(period * sum_xy - sum_x * sum_y) / denom
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
let intercept = (sum_y - slope * sum_x) / period;
|
||||
result[end] = map(slope, intercept);
|
||||
|
||||
if end + 1 < n {
|
||||
let outgoing = prices[end + 1 - timeperiod];
|
||||
let incoming = prices[end + 1];
|
||||
let prev_sum_y = sum_y;
|
||||
|
||||
sum_y = prev_sum_y - outgoing + incoming;
|
||||
sum_xy = sum_xy - (prev_sum_y - outgoing) + last_x * incoming;
|
||||
}
|
||||
}
|
||||
|
||||
result
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// CCI / WILLR helpers (no external dep)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
fn compute_cci(high: &[f64], low: &[f64], close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let n = high.len();
|
||||
let typical_price: Vec<f64> = high
|
||||
.iter()
|
||||
.zip(low.iter())
|
||||
.zip(close.iter())
|
||||
.map(|((&h, &l), &c)| (h + l + c) / 3.0)
|
||||
.collect();
|
||||
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if timeperiod == 0 || n < timeperiod {
|
||||
return result;
|
||||
}
|
||||
for end in (timeperiod - 1)..n {
|
||||
let window = &typical_price[(end + 1 - timeperiod)..=end];
|
||||
let mean = window.iter().sum::<f64>() / timeperiod as f64;
|
||||
let mad = window
|
||||
.iter()
|
||||
.map(|&value| (value - mean).abs())
|
||||
.sum::<f64>()
|
||||
/ timeperiod as f64;
|
||||
result[end] = if mad != 0.0 {
|
||||
(typical_price[end] - mean) / (0.015 * mad)
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
fn compute_willr(high: &[f64], low: &[f64], close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let n = high.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if timeperiod == 0 || n < timeperiod {
|
||||
return result;
|
||||
}
|
||||
|
||||
// Use simple sliding-window max/min
|
||||
for end in (timeperiod - 1)..n {
|
||||
let start = end + 1 - timeperiod;
|
||||
let mut highest = f64::NEG_INFINITY;
|
||||
let mut lowest = f64::INFINITY;
|
||||
for i in start..=end {
|
||||
if high[i] > highest {
|
||||
highest = high[i];
|
||||
}
|
||||
if low[i] < lowest {
|
||||
lowest = low[i];
|
||||
}
|
||||
}
|
||||
let range = highest - lowest;
|
||||
result[end] = if range != 0.0 {
|
||||
-100.0 * (highest - close[end]) / range
|
||||
} else {
|
||||
-50.0
|
||||
};
|
||||
}
|
||||
|
||||
result
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// batch_sma
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Apply SMA to each column. Returns one output column per input column.
|
||||
pub fn batch_sma(data: &[Vec<f64>], timeperiod: usize) -> Result<Vec<Vec<f64>>, String> {
|
||||
if timeperiod == 0 {
|
||||
return Err("timeperiod must be >= 1".into());
|
||||
}
|
||||
validate_columns(data)?;
|
||||
Ok(data
|
||||
.iter()
|
||||
.map(|col| overlap::sma(col, timeperiod))
|
||||
.collect())
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// batch_ema
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Apply EMA to each column.
|
||||
pub fn batch_ema(data: &[Vec<f64>], timeperiod: usize) -> Result<Vec<Vec<f64>>, String> {
|
||||
if timeperiod == 0 {
|
||||
return Err("timeperiod must be >= 1".into());
|
||||
}
|
||||
validate_columns(data)?;
|
||||
Ok(data
|
||||
.iter()
|
||||
.map(|col| overlap::ema(col, timeperiod))
|
||||
.collect())
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// batch_rsi
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Apply RSI to each column.
|
||||
pub fn batch_rsi(data: &[Vec<f64>], timeperiod: usize) -> Result<Vec<Vec<f64>>, String> {
|
||||
if timeperiod == 0 {
|
||||
return Err("timeperiod must be >= 1".into());
|
||||
}
|
||||
validate_columns(data)?;
|
||||
Ok(data
|
||||
.iter()
|
||||
.map(|col| momentum::rsi(col, timeperiod))
|
||||
.collect())
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// batch_atr
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Apply ATR to each set of (high, low, close) columns.
|
||||
pub fn batch_atr(
|
||||
high: &[Vec<f64>],
|
||||
low: &[Vec<f64>],
|
||||
close: &[Vec<f64>],
|
||||
timeperiod: usize,
|
||||
) -> Result<Vec<Vec<f64>>, String> {
|
||||
if timeperiod == 0 {
|
||||
return Err("timeperiod must be >= 1".into());
|
||||
}
|
||||
validate_hlc_columns(high, low, close)?;
|
||||
Ok((0..high.len())
|
||||
.map(|i| volatility::atr(&high[i], &low[i], &close[i], timeperiod))
|
||||
.collect())
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// batch_stoch
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Apply Stochastic to each set of (high, low, close) columns.
|
||||
/// Returns `(slowk_columns, slowd_columns)`.
|
||||
#[allow(clippy::type_complexity)]
|
||||
pub fn batch_stoch(
|
||||
high: &[Vec<f64>],
|
||||
low: &[Vec<f64>],
|
||||
close: &[Vec<f64>],
|
||||
fastk_period: usize,
|
||||
slowk_period: usize,
|
||||
slowd_period: usize,
|
||||
) -> Result<(Vec<Vec<f64>>, Vec<Vec<f64>>), String> {
|
||||
validate_hlc_columns(high, low, close)?;
|
||||
let mut all_k = Vec::with_capacity(high.len());
|
||||
let mut all_d = Vec::with_capacity(high.len());
|
||||
for i in 0..high.len() {
|
||||
let (k, d) = momentum::stoch(
|
||||
&high[i],
|
||||
&low[i],
|
||||
&close[i],
|
||||
fastk_period,
|
||||
slowk_period,
|
||||
slowd_period,
|
||||
);
|
||||
all_k.push(k);
|
||||
all_d.push(d);
|
||||
}
|
||||
Ok((all_k, all_d))
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// batch_adx
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Apply ADX to each set of (high, low, close) columns.
|
||||
pub fn batch_adx(
|
||||
high: &[Vec<f64>],
|
||||
low: &[Vec<f64>],
|
||||
close: &[Vec<f64>],
|
||||
timeperiod: usize,
|
||||
) -> Result<Vec<Vec<f64>>, String> {
|
||||
if timeperiod == 0 {
|
||||
return Err("timeperiod must be >= 1".into());
|
||||
}
|
||||
validate_hlc_columns(high, low, close)?;
|
||||
Ok((0..high.len())
|
||||
.map(|i| momentum::adx(&high[i], &low[i], &close[i], timeperiod))
|
||||
.collect())
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// run_close_indicators
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
fn validate_indicator_requests(names: &[String], timeperiods: &[usize]) -> Result<(), String> {
|
||||
if names.len() != timeperiods.len() {
|
||||
return Err(format!(
|
||||
"names length ({}) must equal timeperiods length ({})",
|
||||
names.len(),
|
||||
timeperiods.len()
|
||||
));
|
||||
}
|
||||
for (name, &tp) in names.iter().zip(timeperiods.iter()) {
|
||||
if tp == 0 {
|
||||
return Err(format!("{name}: timeperiod must be >= 1"));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn compute_close_indicator(
|
||||
name: &str,
|
||||
close: &[f64],
|
||||
timeperiod: usize,
|
||||
) -> Result<Vec<f64>, String> {
|
||||
match name {
|
||||
"SMA" => Ok(overlap::sma(close, timeperiod)),
|
||||
"EMA" => Ok(overlap::ema(close, timeperiod)),
|
||||
"RSI" => Ok(momentum::rsi(close, timeperiod)),
|
||||
"STDDEV" => Ok(statistic::stddev(close, timeperiod, 1.0)),
|
||||
"VAR" => Ok(statistic::stddev(close, timeperiod, 1.0)
|
||||
.into_iter()
|
||||
.map(|v| if v.is_nan() { v } else { v * v })
|
||||
.collect()),
|
||||
"LINEARREG" => {
|
||||
let last_x = (timeperiod - 1) as f64;
|
||||
Ok(rolling_linreg_apply(
|
||||
close,
|
||||
timeperiod,
|
||||
|slope, intercept| intercept + slope * last_x,
|
||||
))
|
||||
}
|
||||
"LINEARREG_SLOPE" => Ok(rolling_linreg_apply(close, timeperiod, |slope, _| slope)),
|
||||
"LINEARREG_INTERCEPT" => Ok(rolling_linreg_apply(close, timeperiod, |_, intercept| {
|
||||
intercept
|
||||
})),
|
||||
"LINEARREG_ANGLE" => Ok(rolling_linreg_apply(close, timeperiod, |slope, _| {
|
||||
slope.atan() * 180.0 / std::f64::consts::PI
|
||||
})),
|
||||
"TSF" => {
|
||||
let forecast_x = timeperiod as f64;
|
||||
Ok(rolling_linreg_apply(
|
||||
close,
|
||||
timeperiod,
|
||||
|slope, intercept| intercept + slope * forecast_x,
|
||||
))
|
||||
}
|
||||
_ => Err(format!(
|
||||
"unsupported close indicator for grouped execution: {name}"
|
||||
)),
|
||||
}
|
||||
}
|
||||
|
||||
/// Run multiple close-only indicators on the same series.
|
||||
/// Returns `Vec<Result<Vec<f64>, String>>` — one result per (name, timeperiod) pair.
|
||||
pub fn run_close_indicators(
|
||||
close: &[f64],
|
||||
names: &[String],
|
||||
timeperiods: &[usize],
|
||||
) -> Result<Vec<Vec<f64>>, String> {
|
||||
validate_indicator_requests(names, timeperiods)?;
|
||||
let mut results = Vec::with_capacity(names.len());
|
||||
for (name, &tp) in names.iter().zip(timeperiods.iter()) {
|
||||
results.push(compute_close_indicator(name, close, tp)?);
|
||||
}
|
||||
Ok(results)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// run_hlc_indicators
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
fn compute_hlc_indicator(
|
||||
name: &str,
|
||||
high: &[f64],
|
||||
low: &[f64],
|
||||
close: &[f64],
|
||||
timeperiod: usize,
|
||||
) -> Result<Vec<f64>, String> {
|
||||
match name {
|
||||
"ATR" => Ok(volatility::atr(high, low, close, timeperiod)),
|
||||
"NATR" => {
|
||||
let atr_vals = volatility::atr(high, low, close, timeperiod);
|
||||
Ok(atr_vals
|
||||
.into_iter()
|
||||
.zip(close.iter())
|
||||
.map(|(a, &c)| {
|
||||
if a.is_nan() || c == 0.0 {
|
||||
f64::NAN
|
||||
} else {
|
||||
(a / c) * 100.0
|
||||
}
|
||||
})
|
||||
.collect())
|
||||
}
|
||||
"ADX" => Ok(momentum::adx(high, low, close, timeperiod)),
|
||||
"ADXR" => Ok(momentum::adxr(high, low, close, timeperiod)),
|
||||
"CCI" => Ok(compute_cci(high, low, close, timeperiod)),
|
||||
"WILLR" => Ok(compute_willr(high, low, close, timeperiod)),
|
||||
_ => Err(format!(
|
||||
"unsupported HLC indicator for grouped execution: {name}"
|
||||
)),
|
||||
}
|
||||
}
|
||||
|
||||
/// Run multiple HLC indicators on the same series.
|
||||
pub fn run_hlc_indicators(
|
||||
high: &[f64],
|
||||
low: &[f64],
|
||||
close: &[f64],
|
||||
names: &[String],
|
||||
timeperiods: &[usize],
|
||||
) -> Result<Vec<Vec<f64>>, String> {
|
||||
validate_indicator_requests(names, timeperiods)?;
|
||||
if high.len() != low.len() || high.len() != close.len() {
|
||||
return Err("high, low, and close must have equal length".into());
|
||||
}
|
||||
let mut results = Vec::with_capacity(names.len());
|
||||
for (name, &tp) in names.iter().zip(timeperiods.iter()) {
|
||||
results.push(compute_hlc_indicator(name, high, low, close, tp)?);
|
||||
}
|
||||
Ok(results)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn close_data() -> Vec<f64> {
|
||||
vec![
|
||||
44.34, 44.09, 43.61, 44.33, 44.83, 45.10, 45.42, 45.84, 46.08, 45.89, 46.03, 45.61,
|
||||
46.28, 46.28, 46.00, 46.03, 46.41, 46.22, 45.64,
|
||||
]
|
||||
}
|
||||
|
||||
fn hlc_data() -> (Vec<f64>, Vec<f64>, Vec<f64>) {
|
||||
let close = close_data();
|
||||
let high: Vec<f64> = close.iter().map(|c| c + 0.5).collect();
|
||||
let low: Vec<f64> = close.iter().map(|c| c - 0.5).collect();
|
||||
(high, low, close)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_batch_sma_basic() {
|
||||
let col1 = vec![1.0, 2.0, 3.0, 4.0, 5.0];
|
||||
let col2 = vec![10.0, 20.0, 30.0, 40.0, 50.0];
|
||||
let data = vec![col1, col2];
|
||||
let result = batch_sma(&data, 3).unwrap();
|
||||
assert_eq!(result.len(), 2);
|
||||
assert!(result[0][0].is_nan());
|
||||
assert!(result[0][1].is_nan());
|
||||
assert!((result[0][2] - 2.0).abs() < 1e-10);
|
||||
assert!((result[1][2] - 20.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_batch_sma_zero_period() {
|
||||
let data = vec![vec![1.0, 2.0]];
|
||||
assert!(batch_sma(&data, 0).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_batch_ema_basic() {
|
||||
let data = vec![vec![1.0, 2.0, 3.0, 4.0, 5.0]];
|
||||
let result = batch_ema(&data, 3).unwrap();
|
||||
assert_eq!(result.len(), 1);
|
||||
assert!(result[0][0].is_nan());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_batch_rsi_basic() {
|
||||
let data = vec![close_data()];
|
||||
let result = batch_rsi(&data, 14).unwrap();
|
||||
assert_eq!(result.len(), 1);
|
||||
// First 14 values should be NaN
|
||||
for i in 0..14 {
|
||||
assert!(result[0][i].is_nan(), "index {i} should be NaN");
|
||||
}
|
||||
// Value at index 14 should be a valid RSI
|
||||
let rsi_val = result[0][14];
|
||||
assert!(!rsi_val.is_nan());
|
||||
assert!(rsi_val >= 0.0 && rsi_val <= 100.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_batch_atr_basic() {
|
||||
let (h, l, c) = hlc_data();
|
||||
let high = vec![h];
|
||||
let low = vec![l];
|
||||
let close = vec![c];
|
||||
let result = batch_atr(&high, &low, &close, 14).unwrap();
|
||||
assert_eq!(result.len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_batch_stoch_basic() {
|
||||
let (h, l, c) = hlc_data();
|
||||
let high = vec![h];
|
||||
let low = vec![l];
|
||||
let close = vec![c];
|
||||
let (k, d) = batch_stoch(&high, &low, &close, 5, 3, 3).unwrap();
|
||||
assert_eq!(k.len(), 1);
|
||||
assert_eq!(d.len(), 1);
|
||||
assert_eq!(k[0].len(), d[0].len());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_batch_adx_basic() {
|
||||
let (h, l, c) = hlc_data();
|
||||
let high = vec![h];
|
||||
let low = vec![l];
|
||||
let close = vec![c];
|
||||
let result = batch_adx(&high, &low, &close, 14).unwrap();
|
||||
assert_eq!(result.len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_run_close_indicators_basic() {
|
||||
let close = close_data();
|
||||
let names = vec!["SMA".to_string(), "EMA".to_string()];
|
||||
let timeperiods = vec![5, 5];
|
||||
let result = run_close_indicators(&close, &names, &timeperiods).unwrap();
|
||||
assert_eq!(result.len(), 2);
|
||||
assert_eq!(result[0].len(), close.len());
|
||||
assert_eq!(result[1].len(), close.len());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_run_close_indicators_mismatched_lengths() {
|
||||
let close = close_data();
|
||||
let names = vec!["SMA".to_string()];
|
||||
let timeperiods = vec![5, 10]; // different length
|
||||
assert!(run_close_indicators(&close, &names, &timeperiods).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_run_close_indicators_linreg_variants() {
|
||||
let close = close_data();
|
||||
let names = vec![
|
||||
"LINEARREG".to_string(),
|
||||
"LINEARREG_SLOPE".to_string(),
|
||||
"LINEARREG_INTERCEPT".to_string(),
|
||||
"LINEARREG_ANGLE".to_string(),
|
||||
"TSF".to_string(),
|
||||
];
|
||||
let timeperiods = vec![5, 5, 5, 5, 5];
|
||||
let result = run_close_indicators(&close, &names, &timeperiods).unwrap();
|
||||
assert_eq!(result.len(), 5);
|
||||
// First 4 values should be NaN for period=5
|
||||
for series in &result {
|
||||
for i in 0..4 {
|
||||
assert!(series[i].is_nan());
|
||||
}
|
||||
assert!(!series[4].is_nan());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_run_hlc_indicators_basic() {
|
||||
let (h, l, c) = hlc_data();
|
||||
let names = vec!["ATR".to_string(), "CCI".to_string()];
|
||||
let timeperiods = vec![14, 14];
|
||||
let result = run_hlc_indicators(&h, &l, &c, &names, &timeperiods).unwrap();
|
||||
assert_eq!(result.len(), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_run_hlc_indicators_unsupported() {
|
||||
let (h, l, c) = hlc_data();
|
||||
let names = vec!["UNKNOWN".to_string()];
|
||||
let timeperiods = vec![14];
|
||||
assert!(run_hlc_indicators(&h, &l, &c, &names, &timeperiods).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_validate_hlc_mismatched_columns() {
|
||||
let high = vec![vec![1.0, 2.0]];
|
||||
let low = vec![vec![1.0, 2.0], vec![3.0, 4.0]]; // 2 cols vs 1
|
||||
let close = vec![vec![1.0, 2.0]];
|
||||
assert!(batch_atr(&high, &low, &close, 5).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_empty_data() {
|
||||
let data: Vec<Vec<f64>> = vec![];
|
||||
let result = batch_sma(&data, 3).unwrap();
|
||||
assert!(result.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_batch_multiple_columns() {
|
||||
let data = vec![
|
||||
vec![1.0, 2.0, 3.0, 4.0, 5.0],
|
||||
vec![5.0, 4.0, 3.0, 2.0, 1.0],
|
||||
vec![2.0, 4.0, 6.0, 8.0, 10.0],
|
||||
];
|
||||
let result = batch_sma(&data, 3).unwrap();
|
||||
assert_eq!(result.len(), 3);
|
||||
// col 0: sma(3) at index 2 = (1+2+3)/3 = 2.0
|
||||
assert!((result[0][2] - 2.0).abs() < 1e-10);
|
||||
// col 1: sma(3) at index 2 = (5+4+3)/3 = 4.0
|
||||
assert!((result[1][2] - 4.0).abs() < 1e-10);
|
||||
// col 2: sma(3) at index 2 = (2+4+6)/3 = 4.0
|
||||
assert!((result[2][2] - 4.0).abs() < 1e-10);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,123 @@
|
||||
//! Chunked / out-of-core execution helpers.
|
||||
//!
|
||||
//! - `trim_overlap` — remove the first N elements from a slice
|
||||
//! - `stitch_chunks` — concatenate trimmed chunk results
|
||||
//! - `make_chunk_ranges` — compute (start, end) index pairs for chunked processing
|
||||
//! - `forward_fill_nan` — forward-fill NaN values
|
||||
|
||||
/// Remove the first `overlap` elements from a slice.
|
||||
pub fn trim_overlap(chunk_out: &[f64], overlap: usize) -> Vec<f64> {
|
||||
if overlap > chunk_out.len() {
|
||||
return vec![];
|
||||
}
|
||||
chunk_out[overlap..].to_vec()
|
||||
}
|
||||
|
||||
/// Concatenate a list of slices into a single Vec.
|
||||
pub fn stitch_chunks(chunks: &[&[f64]]) -> Vec<f64> {
|
||||
let mut out = Vec::new();
|
||||
for &chunk in chunks {
|
||||
out.extend_from_slice(chunk);
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Compute (start, end) index pairs for chunked processing.
|
||||
///
|
||||
/// Returns a flat Vec of pairs: [start0, end0, start1, end1, ...].
|
||||
/// `chunk_size` is the desired output bars per chunk, `overlap` is the warm-up prefix.
|
||||
pub fn make_chunk_ranges(n: usize, chunk_size: usize, overlap: usize) -> Vec<i64> {
|
||||
if chunk_size == 0 || n == 0 {
|
||||
return vec![];
|
||||
}
|
||||
let mut ranges: Vec<i64> = Vec::new();
|
||||
let mut start: usize = 0;
|
||||
loop {
|
||||
let end = (start + chunk_size + overlap).min(n);
|
||||
ranges.push(start as i64);
|
||||
ranges.push(end as i64);
|
||||
if end >= n {
|
||||
break;
|
||||
}
|
||||
start = end.saturating_sub(overlap);
|
||||
}
|
||||
ranges
|
||||
}
|
||||
|
||||
/// Forward-fill NaN values in a 1-D array.
|
||||
/// Leading NaN values are preserved until the first non-NaN value appears.
|
||||
pub fn forward_fill_nan(values: &[f64]) -> Vec<f64> {
|
||||
let mut out = Vec::with_capacity(values.len());
|
||||
let mut last = f64::NAN;
|
||||
for &value in values {
|
||||
if value.is_nan() {
|
||||
out.push(last);
|
||||
} else {
|
||||
last = value;
|
||||
out.push(value);
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_trim_overlap() {
|
||||
let data = vec![1.0, 2.0, 3.0, 4.0, 5.0];
|
||||
let result = trim_overlap(&data, 2);
|
||||
assert_eq!(result, vec![3.0, 4.0, 5.0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_trim_overlap_zero() {
|
||||
let data = vec![1.0, 2.0, 3.0];
|
||||
assert_eq!(trim_overlap(&data, 0), data);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_trim_overlap_exceeds() {
|
||||
let data = vec![1.0, 2.0];
|
||||
assert!(trim_overlap(&data, 5).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_stitch_chunks() {
|
||||
let a = vec![1.0, 2.0];
|
||||
let b = vec![3.0, 4.0, 5.0];
|
||||
let chunks: Vec<&[f64]> = vec![&a, &b];
|
||||
let result = stitch_chunks(&chunks);
|
||||
assert_eq!(result, vec![1.0, 2.0, 3.0, 4.0, 5.0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_make_chunk_ranges() {
|
||||
let ranges = make_chunk_ranges(10, 4, 2);
|
||||
// Expected: [0,6], [4,10]
|
||||
assert_eq!(ranges.len() % 2, 0);
|
||||
assert!(ranges.len() >= 4);
|
||||
assert_eq!(ranges[0], 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_forward_fill_nan() {
|
||||
let data = vec![f64::NAN, 1.0, f64::NAN, f64::NAN, 2.0, f64::NAN];
|
||||
let result = forward_fill_nan(&data);
|
||||
assert!(result[0].is_nan()); // leading NaN preserved
|
||||
assert!((result[1] - 1.0).abs() < 1e-10);
|
||||
assert!((result[2] - 1.0).abs() < 1e-10); // filled
|
||||
assert!((result[3] - 1.0).abs() < 1e-10); // filled
|
||||
assert!((result[4] - 2.0).abs() < 1e-10);
|
||||
assert!((result[5] - 2.0).abs() < 1e-10); // filled
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_empty() {
|
||||
assert!(trim_overlap(&[], 0).is_empty());
|
||||
assert!(stitch_chunks(&[]).is_empty());
|
||||
assert!(make_chunk_ranges(0, 4, 2).is_empty());
|
||||
assert!(forward_fill_nan(&[]).is_empty());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,295 @@
|
||||
//! Commission, tax, and fee model for Indian and global markets.
|
||||
//!
|
||||
//! All `_rate` fields are fractions (0.001 = 0.1%).
|
||||
//! All per-unit fields (`flat_per_order`, `per_lot`) are in base currency units (e.g., INR).
|
||||
//! The model is self-contained: pass `trade_value`, `num_lots`, `is_buy` to get total cost.
|
||||
|
||||
#[cfg(feature = "serde")]
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
/// Advanced commission and tax model.
|
||||
///
|
||||
/// # Fields (all public for direct construction)
|
||||
/// - **Brokerage**: `flat_per_order`, `rate_of_value`, `per_lot`, `max_brokerage`
|
||||
/// - **STT**: `stt_rate`, `stt_on_buy`, `stt_on_sell`
|
||||
/// - **Levies**: `exchange_charges_rate`, `regulatory_charges_rate`, `gst_rate`, `stamp_duty_rate`
|
||||
/// - **Sizing**: `lot_size`
|
||||
///
|
||||
/// # Indian market notes
|
||||
/// - STT (Securities Transaction Tax) is applied on turnover (buy/sell legs vary by segment).
|
||||
/// - Exchange charges and regulatory body charges are on turnover.
|
||||
/// - GST (18%) applies on brokerage + exchange charges + regulatory body charges (not STT/stamp).
|
||||
/// - Stamp duty is on buy-side value only.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
||||
pub struct CommissionModel {
|
||||
// --- Brokerage ---------------------------------------------------------
|
||||
/// Fixed fee per order (e.g., ₹20 flat fee per order). 0.0 = none.
|
||||
pub flat_per_order: f64,
|
||||
/// Proportional brokerage as fraction of `trade_value` (e.g., 0.001 = 0.1%). 0.0 = none.
|
||||
pub rate_of_value: f64,
|
||||
/// Fixed fee per lot (e.g., ₹2 per lot). 0.0 = none.
|
||||
pub per_lot: f64,
|
||||
/// Brokerage cap in currency units. 0.0 = no cap.
|
||||
/// Effective brokerage = min(flat + rate × value + per_lot × lots, max_brokerage).
|
||||
pub max_brokerage: f64,
|
||||
/// Bid-ask spread model in basis points. Half-spread is paid on each leg (entry and exit),
|
||||
/// so total roundtrip cost = spread_bps in bps. 0.0 = no spread cost.
|
||||
pub spread_bps: f64,
|
||||
|
||||
// --- Securities Transaction Tax (STT) ----------------------------------
|
||||
/// STT rate as fraction of trade value. 0.0 = no STT.
|
||||
pub stt_rate: f64,
|
||||
/// Apply STT on the buy leg.
|
||||
pub stt_on_buy: bool,
|
||||
/// Apply STT on the sell leg.
|
||||
pub stt_on_sell: bool,
|
||||
|
||||
// --- Exchange & Regulatory Levies --------------------------------------
|
||||
/// Exchange transaction charges rate (fraction of trade value).
|
||||
pub exchange_charges_rate: f64,
|
||||
/// Regulatory body turnover charges rate (fraction of trade value). Typically ~0.000001.
|
||||
pub regulatory_charges_rate: f64,
|
||||
/// Indirect tax (GST) rate applied on (brokerage + exchange_charges + regulatory_charges).
|
||||
/// Typically 0.18 in India.
|
||||
pub gst_rate: f64,
|
||||
/// Stamp duty rate on buy side only (fraction of trade value).
|
||||
pub stamp_duty_rate: f64,
|
||||
|
||||
// --- Instrument Sizing ------------------------------------------------
|
||||
/// Lot size for the instrument.
|
||||
/// Equities: 1.0. Index futures/options: contract lot size (e.g., 25, 50, 75).
|
||||
/// Used for per_lot cost: cost += per_lot × ceil(quantity / lot_size).
|
||||
pub lot_size: f64,
|
||||
|
||||
// --- Short Selling ----------------------------------------------------
|
||||
/// Annualised short borrow rate as a fraction (e.g. 0.03 = 3% p.a.).
|
||||
/// Applied per bar to short positions. 0.0 = no borrow cost.
|
||||
pub short_borrow_rate_annual: f64,
|
||||
}
|
||||
|
||||
impl Default for CommissionModel {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
flat_per_order: 0.0,
|
||||
rate_of_value: 0.0,
|
||||
per_lot: 0.0,
|
||||
max_brokerage: 0.0,
|
||||
spread_bps: 0.0,
|
||||
stt_rate: 0.0,
|
||||
stt_on_buy: false,
|
||||
stt_on_sell: false,
|
||||
exchange_charges_rate: 0.0,
|
||||
regulatory_charges_rate: 0.0,
|
||||
gst_rate: 0.0,
|
||||
stamp_duty_rate: 0.0,
|
||||
lot_size: 1.0,
|
||||
short_borrow_rate_annual: 0.0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl CommissionModel {
|
||||
// ------------------------------------------------------------------
|
||||
// Core computation
|
||||
// ------------------------------------------------------------------
|
||||
|
||||
/// Compute total transaction cost in **absolute currency units**.
|
||||
///
|
||||
/// # Parameters
|
||||
/// - `trade_value`: price × quantity in base currency
|
||||
/// - `num_lots`: number of lots transacted
|
||||
/// - `is_buy`: true for buy (entry) leg, false for sell (exit) leg
|
||||
pub fn total_cost(&self, trade_value: f64, num_lots: f64, is_buy: bool) -> f64 {
|
||||
// Brokerage (optionally capped)
|
||||
let raw_brokerage =
|
||||
self.flat_per_order + self.rate_of_value * trade_value + self.per_lot * num_lots;
|
||||
let brokerage = if self.max_brokerage > 0.0 {
|
||||
raw_brokerage.min(self.max_brokerage)
|
||||
} else {
|
||||
raw_brokerage
|
||||
};
|
||||
|
||||
// STT
|
||||
let stt = if (is_buy && self.stt_on_buy) || (!is_buy && self.stt_on_sell) {
|
||||
self.stt_rate * trade_value
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
|
||||
let exchange = self.exchange_charges_rate * trade_value;
|
||||
let regulatory = self.regulatory_charges_rate * trade_value;
|
||||
|
||||
// GST on brokerage + exchange + regulatory (NOT on STT or stamp duty)
|
||||
let gst = self.gst_rate * (brokerage + exchange + regulatory);
|
||||
|
||||
// Stamp duty only on buy side
|
||||
let stamp = if is_buy {
|
||||
self.stamp_duty_rate * trade_value
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
|
||||
// Bid-ask spread: half-spread paid on each leg
|
||||
let spread_cost = self.spread_bps / 2.0 / 10_000.0 * trade_value;
|
||||
|
||||
brokerage + stt + exchange + regulatory + gst + stamp + spread_cost
|
||||
}
|
||||
|
||||
/// Borrow cost per bar for a short position.
|
||||
///
|
||||
/// # Parameters
|
||||
/// - `trade_value`: abs(price × quantity)
|
||||
/// - `periods_per_year`: 252 for daily, 52 for weekly, etc.
|
||||
pub fn short_borrow_cost(&self, trade_value: f64, periods_per_year: f64) -> f64 {
|
||||
if self.short_borrow_rate_annual <= 0.0 || periods_per_year <= 0.0 {
|
||||
return 0.0;
|
||||
}
|
||||
self.short_borrow_rate_annual / periods_per_year * trade_value
|
||||
}
|
||||
|
||||
/// Compute cost as a **fraction of `initial_capital`** for use in normalised equity loops.
|
||||
///
|
||||
/// Returns 0.0 if `initial_capital` ≤ 0.
|
||||
pub fn cost_fraction(
|
||||
&self,
|
||||
trade_value: f64,
|
||||
num_lots: f64,
|
||||
is_buy: bool,
|
||||
initial_capital: f64,
|
||||
) -> f64 {
|
||||
if initial_capital <= 0.0 {
|
||||
return 0.0;
|
||||
}
|
||||
self.total_cost(trade_value, num_lots, is_buy) / initial_capital
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// Built-in Presets
|
||||
// ------------------------------------------------------------------
|
||||
|
||||
/// Zero commission — useful for clean research/comparison runs.
|
||||
pub fn zero() -> Self {
|
||||
Self::default()
|
||||
}
|
||||
|
||||
/// Indian equity **delivery** (long-term hold).
|
||||
///
|
||||
/// Brokerage: 0.1% (capped at ₹20), STT 0.1% both sides,
|
||||
/// exchange charges, regulatory body charges, 18% GST, stamp duty.
|
||||
pub fn equity_delivery_india() -> Self {
|
||||
Self {
|
||||
flat_per_order: 0.0,
|
||||
rate_of_value: 0.001, // 0.1%
|
||||
per_lot: 0.0,
|
||||
max_brokerage: 20.0, // ₹20 cap
|
||||
spread_bps: 0.0,
|
||||
stt_rate: 0.001, // 0.1%
|
||||
stt_on_buy: true,
|
||||
stt_on_sell: true,
|
||||
exchange_charges_rate: 0.0000297,
|
||||
regulatory_charges_rate: 0.000001,
|
||||
gst_rate: 0.18,
|
||||
stamp_duty_rate: 0.00015,
|
||||
lot_size: 1.0,
|
||||
short_borrow_rate_annual: 0.0,
|
||||
}
|
||||
}
|
||||
|
||||
/// Indian equity **intraday** (same-day square-off).
|
||||
///
|
||||
/// Brokerage: 0.03% (capped at ₹20), STT 0.025% sell side only,
|
||||
/// exchange charges, regulatory body charges, 18% GST, stamp duty on buy.
|
||||
pub fn equity_intraday_india() -> Self {
|
||||
Self {
|
||||
flat_per_order: 0.0,
|
||||
rate_of_value: 0.0003, // 0.03%
|
||||
per_lot: 0.0,
|
||||
max_brokerage: 20.0,
|
||||
spread_bps: 0.0,
|
||||
stt_rate: 0.00025, // 0.025%
|
||||
stt_on_buy: false,
|
||||
stt_on_sell: true,
|
||||
exchange_charges_rate: 0.0000297,
|
||||
regulatory_charges_rate: 0.000001,
|
||||
gst_rate: 0.18,
|
||||
stamp_duty_rate: 0.000003,
|
||||
lot_size: 1.0,
|
||||
short_borrow_rate_annual: 0.0,
|
||||
}
|
||||
}
|
||||
|
||||
/// Indian **index futures** (indicative rates per current regulations).
|
||||
///
|
||||
/// Flat ₹20 per order, STT 0.05% sell side only, exchange charges,
|
||||
/// regulatory body charges, 18% GST, stamp duty on buy.
|
||||
/// `lot_size` defaults to 25 — update as needed for the specific contract.
|
||||
pub fn futures_india() -> Self {
|
||||
Self {
|
||||
flat_per_order: 20.0,
|
||||
rate_of_value: 0.0,
|
||||
per_lot: 0.0,
|
||||
max_brokerage: 0.0,
|
||||
spread_bps: 0.0,
|
||||
stt_rate: 0.0005, // 0.05%
|
||||
stt_on_buy: false,
|
||||
stt_on_sell: true,
|
||||
exchange_charges_rate: 0.0000019,
|
||||
regulatory_charges_rate: 0.000001,
|
||||
gst_rate: 0.18,
|
||||
stamp_duty_rate: 0.00002,
|
||||
lot_size: 25.0,
|
||||
short_borrow_rate_annual: 0.0,
|
||||
}
|
||||
}
|
||||
|
||||
/// Indian **index options** (indicative rates per current regulations).
|
||||
///
|
||||
/// Flat ₹20 per order, STT 0.15% on premium sell side only, exchange charges,
|
||||
/// regulatory body charges, 18% GST, stamp duty on buy.
|
||||
/// `lot_size` defaults to 25 — update as needed for the specific contract.
|
||||
pub fn options_india() -> Self {
|
||||
Self {
|
||||
flat_per_order: 20.0,
|
||||
rate_of_value: 0.0,
|
||||
per_lot: 0.0,
|
||||
max_brokerage: 0.0,
|
||||
spread_bps: 0.0,
|
||||
stt_rate: 0.0015, // 0.15% on premium
|
||||
stt_on_buy: false,
|
||||
stt_on_sell: true,
|
||||
exchange_charges_rate: 0.0000053,
|
||||
regulatory_charges_rate: 0.000001,
|
||||
gst_rate: 0.18,
|
||||
stamp_duty_rate: 0.000003,
|
||||
lot_size: 25.0,
|
||||
short_borrow_rate_annual: 0.0,
|
||||
}
|
||||
}
|
||||
|
||||
/// Simple proportional model — e.g., `proportional(0.001)` = 0.1% both sides.
|
||||
///
|
||||
/// No taxes, no levies — suitable for non-Indian markets or simplified modelling.
|
||||
pub fn proportional(rate: f64) -> Self {
|
||||
Self {
|
||||
rate_of_value: rate,
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// JSON serialization (requires "serde" feature)
|
||||
// ------------------------------------------------------------------
|
||||
|
||||
/// Serialize to a pretty-printed JSON string.
|
||||
#[cfg(feature = "serde")]
|
||||
pub fn to_json(&self) -> Result<String, serde_json::Error> {
|
||||
serde_json::to_string_pretty(self)
|
||||
}
|
||||
|
||||
/// Deserialize from a JSON string.
|
||||
#[cfg(feature = "serde")]
|
||||
pub fn from_json(s: &str) -> Result<Self, serde_json::Error> {
|
||||
serde_json::from_str(s)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,91 @@
|
||||
//! Crypto and 24/7 market helpers.
|
||||
//!
|
||||
//! - `funding_cumulative_pnl` — cumulative PnL from periodic funding rate payments
|
||||
//! - `continuous_bar_labels` — assign sequential integer labels based on fixed period size
|
||||
//! - `mark_session_boundaries` — return indices where a new UTC day begins
|
||||
|
||||
/// Compute the cumulative PnL from funding rate payments.
|
||||
///
|
||||
/// `position_size` and `funding_rate` must have the same length.
|
||||
/// PnL at period i = -position_size[i] * funding_rate[i] (longs pay when rate > 0).
|
||||
pub fn funding_cumulative_pnl(position_size: &[f64], funding_rate: &[f64]) -> Vec<f64> {
|
||||
let n = position_size.len();
|
||||
let mut out = vec![0.0_f64; n];
|
||||
let mut cumulative = 0.0_f64;
|
||||
for i in 0..n {
|
||||
cumulative += -position_size[i] * funding_rate[i];
|
||||
out[i] = cumulative;
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Assign a sequential integer label per bar based on a fixed-size period.
|
||||
///
|
||||
/// Bars 0..(period_bars-1) get label 0, bars period_bars..(2*period_bars-1) get label 1, etc.
|
||||
/// `period_bars` must be >= 1.
|
||||
pub fn continuous_bar_labels(n_bars: usize, period_bars: usize) -> Vec<i64> {
|
||||
(0..n_bars).map(|i| (i / period_bars) as i64).collect()
|
||||
}
|
||||
|
||||
/// Return bar indices where a new UTC day begins (based on nanosecond timestamps).
|
||||
///
|
||||
/// Bar 0 is always included as the first boundary.
|
||||
pub fn mark_session_boundaries(timestamps_ns: &[i64]) -> Vec<i64> {
|
||||
let n = timestamps_ns.len();
|
||||
if n == 0 {
|
||||
return vec![];
|
||||
}
|
||||
const NS_PER_DAY: i64 = 86_400_000_000_000;
|
||||
let mut out = vec![0i64]; // bar 0 is always a boundary
|
||||
let mut prev_day = timestamps_ns[0].div_euclid(NS_PER_DAY);
|
||||
for (i, &t) in timestamps_ns.iter().enumerate().skip(1) {
|
||||
let day = t.div_euclid(NS_PER_DAY);
|
||||
if day != prev_day {
|
||||
out.push(i as i64);
|
||||
prev_day = day;
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_funding_cumulative_pnl() {
|
||||
let pos = vec![100.0, 100.0, -50.0];
|
||||
let rate = vec![0.001, -0.002, 0.001];
|
||||
let result = funding_cumulative_pnl(&pos, &rate);
|
||||
assert!((result[0] - (-0.1)).abs() < 1e-10);
|
||||
assert!((result[1] - 0.1).abs() < 1e-10); // -0.1 + 0.2 = 0.1
|
||||
assert!((result[2] - 0.15).abs() < 1e-10); // 0.1 + 0.05 = 0.15
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_continuous_bar_labels() {
|
||||
let labels = continuous_bar_labels(7, 3);
|
||||
assert_eq!(labels, vec![0, 0, 0, 1, 1, 1, 2]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_mark_session_boundaries() {
|
||||
let ns_per_day: i64 = 86_400_000_000_000;
|
||||
let ts = vec![
|
||||
0, // day 0
|
||||
ns_per_day / 2, // day 0
|
||||
ns_per_day, // day 1
|
||||
ns_per_day + ns_per_day / 2, // day 1
|
||||
ns_per_day * 2, // day 2
|
||||
];
|
||||
let result = mark_session_boundaries(&ts);
|
||||
assert_eq!(result, vec![0, 2, 4]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_empty() {
|
||||
assert!(funding_cumulative_pnl(&[], &[]).is_empty());
|
||||
assert!(continuous_bar_labels(0, 1).is_empty());
|
||||
assert!(mark_session_boundaries(&[]).is_empty());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,173 @@
|
||||
//! Currency metadata and Indian number formatting.
|
||||
|
||||
/// Immutable currency descriptor.
|
||||
///
|
||||
/// Carries the currency code, symbol, decimal places, and whether to use
|
||||
/// Indian lakh/crore grouping (1,23,45,678.00) instead of standard
|
||||
/// Western grouping (1,234,567.89).
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct Currency {
|
||||
/// IETF currency code, e.g. "INR", "USD".
|
||||
pub code: &'static str,
|
||||
/// Display symbol, e.g. "₹", "$".
|
||||
pub symbol: &'static str,
|
||||
/// Number of decimal places for formatting.
|
||||
pub decimal_places: u8,
|
||||
/// Use Indian lakh/crore digit grouping (true only for INR).
|
||||
pub lakh_grouping: bool,
|
||||
}
|
||||
|
||||
impl Currency {
|
||||
pub const INR: Currency = Currency {
|
||||
code: "INR",
|
||||
symbol: "₹",
|
||||
decimal_places: 2,
|
||||
lakh_grouping: true,
|
||||
};
|
||||
pub const USD: Currency = Currency {
|
||||
code: "USD",
|
||||
symbol: "$",
|
||||
decimal_places: 2,
|
||||
lakh_grouping: false,
|
||||
};
|
||||
pub const EUR: Currency = Currency {
|
||||
code: "EUR",
|
||||
symbol: "€",
|
||||
decimal_places: 2,
|
||||
lakh_grouping: false,
|
||||
};
|
||||
pub const GBP: Currency = Currency {
|
||||
code: "GBP",
|
||||
symbol: "£",
|
||||
decimal_places: 2,
|
||||
lakh_grouping: false,
|
||||
};
|
||||
pub const JPY: Currency = Currency {
|
||||
code: "JPY",
|
||||
symbol: "¥",
|
||||
decimal_places: 0,
|
||||
lakh_grouping: false,
|
||||
};
|
||||
pub const USDT: Currency = Currency {
|
||||
code: "USDT",
|
||||
symbol: "₮",
|
||||
decimal_places: 2,
|
||||
lakh_grouping: false,
|
||||
};
|
||||
|
||||
/// Look up a currency by IETF code (case-insensitive).
|
||||
/// Returns `None` if the code is not recognised.
|
||||
pub fn from_code(code: &str) -> Option<&'static Currency> {
|
||||
match code.to_ascii_uppercase().as_str() {
|
||||
"INR" => Some(&Currency::INR),
|
||||
"USD" => Some(&Currency::USD),
|
||||
"EUR" => Some(&Currency::EUR),
|
||||
"GBP" => Some(&Currency::GBP),
|
||||
"JPY" => Some(&Currency::JPY),
|
||||
"USDT" => Some(&Currency::USDT),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Format `amount` according to this currency's style.
|
||||
///
|
||||
/// - INR uses Indian lakh/crore grouping: `₹1,23,45,678.00`
|
||||
/// - Others use standard Western grouping: `$1,234,567.89`
|
||||
pub fn format(&self, amount: f64) -> String {
|
||||
let neg = amount < 0.0;
|
||||
let abs = amount.abs();
|
||||
let integer_part = abs.floor() as u64;
|
||||
let frac_part = abs - abs.floor();
|
||||
|
||||
let grouped = if self.lakh_grouping {
|
||||
format_lakh(integer_part)
|
||||
} else {
|
||||
format_standard(integer_part)
|
||||
};
|
||||
|
||||
let dp = self.decimal_places as usize;
|
||||
let decimal_str = if dp > 0 {
|
||||
let frac = (frac_part * 10f64.powi(dp as i32)).round() as u64;
|
||||
format!(".{:0>width$}", frac, width = dp)
|
||||
} else {
|
||||
String::new()
|
||||
};
|
||||
|
||||
let sign = if neg { "-" } else { "" };
|
||||
format!("{}{}{}{}", sign, self.symbol, grouped, decimal_str)
|
||||
}
|
||||
}
|
||||
|
||||
/// Indian lakh/crore grouping: last 3 digits, then groups of 2 from the right.
|
||||
/// e.g. 12345678 → "1,23,45,678"
|
||||
fn format_lakh(n: u64) -> String {
|
||||
let s = n.to_string();
|
||||
if s.len() <= 3 {
|
||||
return s;
|
||||
}
|
||||
let (rest, last3) = s.split_at(s.len() - 3);
|
||||
let mut out = String::new();
|
||||
let chars: Vec<char> = rest.chars().collect();
|
||||
let first_len = chars.len() % 2;
|
||||
if first_len > 0 {
|
||||
out.push_str(&chars[..first_len].iter().collect::<String>());
|
||||
}
|
||||
let mut i = first_len;
|
||||
while i < chars.len() {
|
||||
if !out.is_empty() {
|
||||
out.push(',');
|
||||
}
|
||||
out.push_str(&chars[i..i + 2].iter().collect::<String>());
|
||||
i += 2;
|
||||
}
|
||||
if !out.is_empty() {
|
||||
out.push(',');
|
||||
}
|
||||
out.push_str(last3);
|
||||
out
|
||||
}
|
||||
|
||||
/// Standard Western grouping: groups of 3 digits from the right.
|
||||
/// e.g. 1234567 → "1,234,567"
|
||||
fn format_standard(n: u64) -> String {
|
||||
let s = n.to_string();
|
||||
let mut out = String::new();
|
||||
for (i, c) in s.chars().rev().enumerate() {
|
||||
if i > 0 && i % 3 == 0 {
|
||||
out.push(',');
|
||||
}
|
||||
out.push(c);
|
||||
}
|
||||
out.chars().rev().collect()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_inr_format() {
|
||||
assert_eq!(Currency::INR.format(123456.78), "₹1,23,456.78");
|
||||
assert_eq!(Currency::INR.format(10000000.0), "₹1,00,00,000.00");
|
||||
assert_eq!(Currency::INR.format(100.0), "₹100.00");
|
||||
assert_eq!(Currency::INR.format(-5000.0), "-₹5,000.00");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_usd_format() {
|
||||
assert_eq!(Currency::USD.format(1234567.89), "$1,234,567.89");
|
||||
assert_eq!(Currency::USD.format(0.5), "$0.50");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_jpy_format() {
|
||||
assert_eq!(Currency::JPY.format(1000000.0), "¥1,000,000");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_from_code() {
|
||||
assert_eq!(Currency::from_code("inr"), Some(&Currency::INR));
|
||||
assert_eq!(Currency::from_code("USD"), Some(&Currency::USD));
|
||||
assert_eq!(Currency::from_code("UNKNOWN"), None);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,370 @@
|
||||
//! Cycle indicators — Hilbert Transform-based cycle analysis (Ehlers).
|
||||
//!
|
||||
//! Based on John Ehlers' Discrete Hilbert Transform as implemented in TA-Lib.
|
||||
//! Reference: "Cybernetic Analysis for Stocks and Futures" by J.F. Ehlers
|
||||
//!
|
||||
//! All HT functions share a 63-bar lookback period.
|
||||
|
||||
use std::f64::consts::PI;
|
||||
|
||||
/// Number of leading bars that are set to NaN / zero.
|
||||
pub const HT_LOOKBACK: usize = 63;
|
||||
|
||||
/// Shared output from the core Hilbert Transform computation.
|
||||
pub struct HtCore {
|
||||
pub trendline: Vec<f64>,
|
||||
pub dc_period: Vec<f64>,
|
||||
pub dc_phase: Vec<f64>,
|
||||
pub inphase: Vec<f64>,
|
||||
pub quadrature: Vec<f64>,
|
||||
pub trend_mode: Vec<i32>,
|
||||
}
|
||||
|
||||
/// Run the full Hilbert Transform pipeline on a slice of close prices.
|
||||
pub fn compute_ht_core(prices: &[f64]) -> HtCore {
|
||||
let n = prices.len();
|
||||
|
||||
let mut trendline = vec![f64::NAN; n];
|
||||
let mut dc_period = vec![f64::NAN; n];
|
||||
let mut dc_phase = vec![f64::NAN; n];
|
||||
let mut inphase = vec![f64::NAN; n];
|
||||
let mut quadrature = vec![f64::NAN; n];
|
||||
let mut trend_mode = vec![0i32; n];
|
||||
|
||||
if n <= HT_LOOKBACK {
|
||||
return HtCore {
|
||||
trendline,
|
||||
dc_period,
|
||||
dc_phase,
|
||||
inphase,
|
||||
quadrature,
|
||||
trend_mode,
|
||||
};
|
||||
}
|
||||
|
||||
// Step 1: Smooth the price series (4-bar weighted average)
|
||||
let mut smooth = vec![0.0f64; n];
|
||||
for i in 0..n {
|
||||
smooth[i] = if i >= 3 {
|
||||
(4.0 * prices[i] + 3.0 * prices[i - 1] + 2.0 * prices[i - 2] + prices[i - 3]) / 10.0
|
||||
} else {
|
||||
prices[i]
|
||||
};
|
||||
}
|
||||
|
||||
// Step 2: Full Hilbert Transform pipeline
|
||||
let mut detrender = vec![0.0f64; n];
|
||||
let mut q1 = vec![0.0f64; n];
|
||||
let mut i1 = vec![0.0f64; n];
|
||||
let mut ji = vec![0.0f64; n];
|
||||
let mut jq = vec![0.0f64; n];
|
||||
let mut i2 = vec![0.0f64; n];
|
||||
let mut q2 = vec![0.0f64; n];
|
||||
let mut re = vec![0.0f64; n];
|
||||
let mut im = vec![0.0f64; n];
|
||||
let mut period = vec![0.0f64; n];
|
||||
let mut smooth_period = vec![0.0f64; n];
|
||||
let mut phase = vec![0.0f64; n];
|
||||
|
||||
for i in 6..n {
|
||||
let prev_period = period[i - 1];
|
||||
// Alpha coefficient for HT filters depends on the current period estimate
|
||||
let alpha = 0.075 * prev_period + 0.54;
|
||||
|
||||
// Discrete Hilbert Transform of smooth price (detrender)
|
||||
detrender[i] = (0.0962 * smooth[i] + 0.5769 * smooth[i - 2]
|
||||
- 0.5769 * smooth[i - 4]
|
||||
- 0.0962 * smooth[i - 6])
|
||||
* alpha;
|
||||
|
||||
// Q1: HT of detrender
|
||||
if i >= 12 {
|
||||
q1[i] = (0.0962 * detrender[i] + 0.5769 * detrender[i - 2]
|
||||
- 0.5769 * detrender[i - 4]
|
||||
- 0.0962 * detrender[i - 6])
|
||||
* alpha;
|
||||
}
|
||||
|
||||
// I1: delayed detrender
|
||||
if i >= 9 {
|
||||
i1[i] = detrender[i - 3];
|
||||
}
|
||||
|
||||
// jI: HT of I1
|
||||
if i >= 15 {
|
||||
ji[i] = (0.0962 * i1[i] + 0.5769 * i1[i - 2] - 0.5769 * i1[i - 4] - 0.0962 * i1[i - 6])
|
||||
* alpha;
|
||||
}
|
||||
|
||||
// jQ: HT of Q1
|
||||
if i >= 18 {
|
||||
jq[i] = (0.0962 * q1[i] + 0.5769 * q1[i - 2] - 0.5769 * q1[i - 4] - 0.0962 * q1[i - 6])
|
||||
* alpha;
|
||||
}
|
||||
|
||||
// Phase components
|
||||
let i2_raw = i1[i] - jq[i];
|
||||
let q2_raw = q1[i] + ji[i];
|
||||
|
||||
// EMA smoothing of I2 and Q2
|
||||
let i2_prev = i2[i - 1];
|
||||
let q2_prev = q2[i - 1];
|
||||
i2[i] = 0.2 * i2_raw + 0.8 * i2_prev;
|
||||
q2[i] = 0.2 * q2_raw + 0.8 * q2_prev;
|
||||
|
||||
// Cross-product for period estimation
|
||||
let re_raw = i2[i] * i2_prev + q2[i] * q2_prev;
|
||||
let im_raw = i2[i] * q2_prev - q2[i] * i2_prev;
|
||||
|
||||
// EMA smoothing of Re and Im
|
||||
re[i] = 0.2 * re_raw + 0.8 * re[i - 1];
|
||||
im[i] = 0.2 * im_raw + 0.8 * im[i - 1];
|
||||
|
||||
// Compute period from cross-product of consecutive phasors.
|
||||
let mut p = if re[i] != 0.0 && im[i] != 0.0 && re[i] > 0.0 {
|
||||
2.0 * PI / (im[i] / re[i]).atan()
|
||||
} else {
|
||||
prev_period
|
||||
};
|
||||
|
||||
// Clamp period relative to previous
|
||||
if prev_period > 0.0 {
|
||||
if p > 1.5 * prev_period {
|
||||
p = 1.5 * prev_period;
|
||||
}
|
||||
if p < 0.67 * prev_period {
|
||||
p = 0.67 * prev_period;
|
||||
}
|
||||
}
|
||||
// Hard clamp to [6, 50] bars
|
||||
p = p.clamp(6.0, 50.0);
|
||||
|
||||
// EMA smooth the period
|
||||
period[i] = 0.2 * p + 0.8 * prev_period;
|
||||
|
||||
// Smooth the smoothed period once more
|
||||
smooth_period[i] = 0.33 * period[i] + 0.67 * smooth_period[i - 1];
|
||||
|
||||
// Phase from I1 and Q1
|
||||
phase[i] = if i1[i] != 0.0 {
|
||||
q1[i].atan2(i1[i]) * 180.0 / PI
|
||||
} else if q1[i] > 0.0 {
|
||||
90.0
|
||||
} else if q1[i] < 0.0 {
|
||||
-90.0
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
|
||||
// Write outputs once past lookback
|
||||
if i >= HT_LOOKBACK {
|
||||
dc_period[i] = smooth_period[i];
|
||||
dc_phase[i] = phase[i];
|
||||
inphase[i] = i1[i];
|
||||
quadrature[i] = q1[i];
|
||||
|
||||
// Trend mode: cycle when SmoothPeriod >= 20, trend when < 20
|
||||
trend_mode[i] = if smooth_period[i] < 20.0 { 1 } else { 0 };
|
||||
}
|
||||
}
|
||||
|
||||
// Trendline: average over the current dominant cycle period
|
||||
for i in HT_LOOKBACK..n {
|
||||
let sp = smooth_period[i];
|
||||
let dc = (sp.round() as usize).max(1).min(i + 1);
|
||||
let sum: f64 = (0..dc).map(|j| smooth[i - j]).sum();
|
||||
trendline[i] = sum / dc as f64;
|
||||
}
|
||||
|
||||
HtCore {
|
||||
trendline,
|
||||
dc_period,
|
||||
dc_phase,
|
||||
inphase,
|
||||
quadrature,
|
||||
trend_mode,
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Public indicator functions
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Hilbert Transform Instantaneous Trendline (Ehlers).
|
||||
/// Smooths price over the dominant cycle period.
|
||||
pub fn ht_trendline(close: &[f64]) -> Vec<f64> {
|
||||
compute_ht_core(close).trendline
|
||||
}
|
||||
|
||||
/// Hilbert Transform Dominant Cycle Period in bars.
|
||||
pub fn ht_dcperiod(close: &[f64]) -> Vec<f64> {
|
||||
compute_ht_core(close).dc_period
|
||||
}
|
||||
|
||||
/// Hilbert Transform Dominant Cycle Phase in degrees.
|
||||
pub fn ht_dcphase(close: &[f64]) -> Vec<f64> {
|
||||
compute_ht_core(close).dc_phase
|
||||
}
|
||||
|
||||
/// Hilbert Transform Phasor components. Returns `(inphase, quadrature)`.
|
||||
pub fn ht_phasor(close: &[f64]) -> (Vec<f64>, Vec<f64>) {
|
||||
let core = compute_ht_core(close);
|
||||
(core.inphase, core.quadrature)
|
||||
}
|
||||
|
||||
/// Hilbert Transform SineWave. Returns `(sine, leadsine)` where leadsine
|
||||
/// leads sine by 45 degrees.
|
||||
pub fn ht_sine(close: &[f64]) -> (Vec<f64>, Vec<f64>) {
|
||||
let n = close.len();
|
||||
let core = compute_ht_core(close);
|
||||
|
||||
let mut sine = vec![f64::NAN; n];
|
||||
let mut lead_sine = vec![f64::NAN; n];
|
||||
|
||||
for i in HT_LOOKBACK..n {
|
||||
if !core.dc_phase[i].is_nan() {
|
||||
let phase_rad = core.dc_phase[i] * PI / 180.0;
|
||||
sine[i] = phase_rad.sin();
|
||||
lead_sine[i] = (phase_rad + PI / 4.0).sin(); // 45-degree lead
|
||||
}
|
||||
}
|
||||
|
||||
(sine, lead_sine)
|
||||
}
|
||||
|
||||
/// Hilbert Transform Trend vs Cycle Mode: 1 = trending, 0 = cycling.
|
||||
pub fn ht_trendmode(close: &[f64]) -> Vec<i32> {
|
||||
compute_ht_core(close).trend_mode
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// Generate a simple sine wave for testing cycle detection.
|
||||
fn sine_wave(n: usize, period: f64) -> Vec<f64> {
|
||||
(0..n)
|
||||
.map(|i| 100.0 + 10.0 * (2.0 * PI * i as f64 / period).sin())
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Flat price series for baseline testing.
|
||||
fn flat_prices(n: usize) -> Vec<f64> {
|
||||
vec![100.0; n]
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ht_trendline_length_and_lookback() {
|
||||
let close = sine_wave(200, 20.0);
|
||||
let result = ht_trendline(&close);
|
||||
assert_eq!(result.len(), close.len());
|
||||
// First HT_LOOKBACK values must be NaN
|
||||
for v in &result[..HT_LOOKBACK] {
|
||||
assert!(v.is_nan(), "expected NaN in lookback region");
|
||||
}
|
||||
// Values after lookback must be finite
|
||||
for v in &result[HT_LOOKBACK..] {
|
||||
assert!(v.is_finite(), "expected finite value after lookback");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ht_dcperiod_length_and_lookback() {
|
||||
let close = sine_wave(200, 20.0);
|
||||
let result = ht_dcperiod(&close);
|
||||
assert_eq!(result.len(), close.len());
|
||||
for v in &result[..HT_LOOKBACK] {
|
||||
assert!(v.is_nan());
|
||||
}
|
||||
// After lookback, period should be positive and finite
|
||||
for v in &result[HT_LOOKBACK..] {
|
||||
assert!(v.is_finite());
|
||||
assert!(*v >= 6.0 && *v <= 50.0, "period {} out of [6,50]", v);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ht_dcphase_length_and_lookback() {
|
||||
let close = sine_wave(200, 20.0);
|
||||
let result = ht_dcphase(&close);
|
||||
assert_eq!(result.len(), close.len());
|
||||
for v in &result[..HT_LOOKBACK] {
|
||||
assert!(v.is_nan());
|
||||
}
|
||||
for v in &result[HT_LOOKBACK..] {
|
||||
assert!(v.is_finite());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ht_phasor_dual_output() {
|
||||
let close = sine_wave(200, 20.0);
|
||||
let (inp, quad) = ht_phasor(&close);
|
||||
assert_eq!(inp.len(), close.len());
|
||||
assert_eq!(quad.len(), close.len());
|
||||
for v in &inp[..HT_LOOKBACK] {
|
||||
assert!(v.is_nan());
|
||||
}
|
||||
for v in &quad[..HT_LOOKBACK] {
|
||||
assert!(v.is_nan());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ht_sine_dual_output() {
|
||||
let close = sine_wave(200, 20.0);
|
||||
let (s, ls) = ht_sine(&close);
|
||||
assert_eq!(s.len(), close.len());
|
||||
assert_eq!(ls.len(), close.len());
|
||||
for v in &s[..HT_LOOKBACK] {
|
||||
assert!(v.is_nan());
|
||||
}
|
||||
// Sine values should be in [-1, 1]
|
||||
for v in &s[HT_LOOKBACK..] {
|
||||
assert!(v.is_finite());
|
||||
assert!(*v >= -1.0 && *v <= 1.0, "sine {} out of [-1,1]", v);
|
||||
}
|
||||
for v in &ls[HT_LOOKBACK..] {
|
||||
assert!(v.is_finite());
|
||||
assert!(*v >= -1.0 && *v <= 1.0, "leadsine {} out of [-1,1]", v);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ht_trendmode_values() {
|
||||
let close = sine_wave(200, 20.0);
|
||||
let result = ht_trendmode(&close);
|
||||
assert_eq!(result.len(), close.len());
|
||||
// All values must be 0 or 1
|
||||
for v in &result {
|
||||
assert!(*v == 0 || *v == 1, "trend_mode {} not 0 or 1", v);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_short_input_all_nan() {
|
||||
let close = vec![100.0; HT_LOOKBACK]; // exactly HT_LOOKBACK, not enough
|
||||
let tl = ht_trendline(&close);
|
||||
assert!(tl.iter().all(|v| v.is_nan()));
|
||||
let dp = ht_dcperiod(&close);
|
||||
assert!(dp.iter().all(|v| v.is_nan()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_flat_prices_trendline_equals_price() {
|
||||
let close = flat_prices(200);
|
||||
let tl = ht_trendline(&close);
|
||||
// For a flat price, trendline after lookback should be very close to the price
|
||||
for v in &tl[HT_LOOKBACK..] {
|
||||
assert!(
|
||||
(v - 100.0).abs() < 1e-6,
|
||||
"trendline {} diverged from flat price",
|
||||
v
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,962 @@
|
||||
//! Extended indicators — pure Rust implementations (no PyO3, no numpy).
|
||||
//!
|
||||
//! These indicators are not part of TA-Lib and provide additional technical
|
||||
//! analysis capabilities. All functions operate on `&[f64]` slices and return
|
||||
//! `Vec<f64>` (or tuples thereof).
|
||||
|
||||
#![allow(clippy::too_many_arguments)]
|
||||
|
||||
use crate::math;
|
||||
use crate::overlap;
|
||||
// Note: we use a local compute_atr helper (seeds from bar 0) rather than
|
||||
// crate::volatility::atr (which seeds from bar 1, TA-Lib style).
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Internal helpers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Compute ATR array using Wilder smoothing (same algorithm as in the PyO3
|
||||
/// extended module — seeds from bar 0, not bar 1 like TA-Lib's `volatility::atr`).
|
||||
fn compute_atr(high: &[f64], low: &[f64], close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let n = high.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if n <= timeperiod {
|
||||
return result;
|
||||
}
|
||||
// Seed: SMA of first `timeperiod` true range values
|
||||
let mut seed_sum = high[0] - low[0]; // first TR has no prev_close
|
||||
for i in 1..timeperiod {
|
||||
let hl = high[i] - low[i];
|
||||
let hc = (high[i] - close[i - 1]).abs();
|
||||
let lc = (low[i] - close[i - 1]).abs();
|
||||
seed_sum += hl.max(hc).max(lc);
|
||||
}
|
||||
let mut atr = seed_sum / timeperiod as f64;
|
||||
result[timeperiod - 1] = atr;
|
||||
let pf = (timeperiod - 1) as f64;
|
||||
for i in timeperiod..n {
|
||||
let hl = high[i] - low[i];
|
||||
let hc = (high[i] - close[i - 1]).abs();
|
||||
let lc = (low[i] - close[i - 1]).abs();
|
||||
let tr = hl.max(hc).max(lc);
|
||||
atr = (atr * pf + tr) / timeperiod as f64;
|
||||
result[i] = atr;
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// VWAP
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Volume Weighted Average Price (cumulative or rolling).
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `high`, `low`, `close`, `volume` — equal-length price/volume slices.
|
||||
/// * `timeperiod` — 0 for cumulative VWAP from bar 0; >= 1 for a rolling window.
|
||||
///
|
||||
/// # Returns
|
||||
/// A `Vec<f64>` of VWAP values. For rolling mode the first `timeperiod - 1`
|
||||
/// entries are `NaN`.
|
||||
pub fn vwap(
|
||||
high: &[f64],
|
||||
low: &[f64],
|
||||
close: &[f64],
|
||||
volume: &[f64],
|
||||
timeperiod: usize,
|
||||
) -> Vec<f64> {
|
||||
let n = high.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
|
||||
if timeperiod == 0 {
|
||||
let mut cum_tpv = 0.0_f64;
|
||||
let mut cum_vol = 0.0_f64;
|
||||
for i in 0..n {
|
||||
let tp = (high[i] + low[i] + close[i]) / 3.0;
|
||||
cum_tpv += tp * volume[i];
|
||||
cum_vol += volume[i];
|
||||
result[i] = if cum_vol != 0.0 {
|
||||
cum_tpv / cum_vol
|
||||
} else {
|
||||
f64::NAN
|
||||
};
|
||||
}
|
||||
} else {
|
||||
// Pre-compute cumulative sums for O(n) rolling window
|
||||
let mut cum_tpv_arr = vec![0.0_f64; n];
|
||||
let mut cum_vol_arr = vec![0.0_f64; n];
|
||||
for i in 0..n {
|
||||
let tp = (high[i] + low[i] + close[i]) / 3.0;
|
||||
let tpv = tp * volume[i];
|
||||
cum_tpv_arr[i] = tpv + if i > 0 { cum_tpv_arr[i - 1] } else { 0.0 };
|
||||
cum_vol_arr[i] = volume[i] + if i > 0 { cum_vol_arr[i - 1] } else { 0.0 };
|
||||
}
|
||||
for i in (timeperiod - 1)..n {
|
||||
let prev_tpv = if i >= timeperiod {
|
||||
cum_tpv_arr[i - timeperiod]
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
let prev_vol = if i >= timeperiod {
|
||||
cum_vol_arr[i - timeperiod]
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
let w_tpv = cum_tpv_arr[i] - prev_tpv;
|
||||
let w_vol = cum_vol_arr[i] - prev_vol;
|
||||
result[i] = if w_vol != 0.0 {
|
||||
w_tpv / w_vol
|
||||
} else {
|
||||
f64::NAN
|
||||
};
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// VWMA
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Volume Weighted Moving Average.
|
||||
///
|
||||
/// `VWMA = sum(close * volume, n) / sum(volume, n)`
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `close` — price series.
|
||||
/// * `volume` — volume series (same length as `close`).
|
||||
/// * `timeperiod` — rolling window size (>= 1).
|
||||
///
|
||||
/// # Returns
|
||||
/// A `Vec<f64>` with `NaN` for the first `timeperiod - 1` entries.
|
||||
pub fn vwma(close: &[f64], volume: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let n = close.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if timeperiod < 1 || n < timeperiod {
|
||||
return result;
|
||||
}
|
||||
|
||||
let mut cum_cv = vec![0.0_f64; n];
|
||||
let mut cum_v = vec![0.0_f64; n];
|
||||
for i in 0..n {
|
||||
cum_cv[i] = close[i] * volume[i] + if i > 0 { cum_cv[i - 1] } else { 0.0 };
|
||||
cum_v[i] = volume[i] + if i > 0 { cum_v[i - 1] } else { 0.0 };
|
||||
}
|
||||
|
||||
for i in (timeperiod - 1)..n {
|
||||
let prev_cv = if i >= timeperiod {
|
||||
cum_cv[i - timeperiod]
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
let prev_v = if i >= timeperiod {
|
||||
cum_v[i - timeperiod]
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
let w_cv = cum_cv[i] - prev_cv;
|
||||
let w_v = cum_v[i] - prev_v;
|
||||
result[i] = if w_v != 0.0 { w_cv / w_v } else { f64::NAN };
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// SUPERTREND
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// ATR-based Supertrend indicator.
|
||||
///
|
||||
/// # Returns
|
||||
/// `(supertrend_line, direction)` where direction values are:
|
||||
/// * `1` = uptrend
|
||||
/// * `-1` = downtrend
|
||||
/// * `0` = warmup (first `timeperiod` bars)
|
||||
pub fn supertrend(
|
||||
high: &[f64],
|
||||
low: &[f64],
|
||||
close: &[f64],
|
||||
timeperiod: usize,
|
||||
multiplier: f64,
|
||||
) -> (Vec<f64>, Vec<i8>) {
|
||||
let n = high.len();
|
||||
let mut supertrend_out = vec![f64::NAN; n];
|
||||
let mut direction = vec![0_i8; n];
|
||||
|
||||
if timeperiod < 1 || n <= timeperiod {
|
||||
return (supertrend_out, direction);
|
||||
}
|
||||
|
||||
let atr = compute_atr(high, low, close, timeperiod);
|
||||
|
||||
let mut upper_band = vec![f64::NAN; n];
|
||||
let mut lower_band = vec![f64::NAN; n];
|
||||
|
||||
let first_valid = timeperiod - 1;
|
||||
if first_valid >= n || atr[first_valid].is_nan() {
|
||||
return (supertrend_out, direction);
|
||||
}
|
||||
|
||||
// Initialize band state at first valid ATR bar (compute basic bands inline)
|
||||
{
|
||||
let hl2 = (high[first_valid] + low[first_valid]) / 2.0;
|
||||
upper_band[first_valid] = hl2 + multiplier * atr[first_valid];
|
||||
lower_band[first_valid] = hl2 - multiplier * atr[first_valid];
|
||||
}
|
||||
|
||||
for i in (first_valid + 1)..n {
|
||||
if atr[i].is_nan() {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Compute basic bands as scalars — no Vec allocation needed
|
||||
let hl2 = (high[i] + low[i]) / 2.0;
|
||||
let upper_basic = hl2 + multiplier * atr[i];
|
||||
let lower_basic = hl2 - multiplier * atr[i];
|
||||
|
||||
// Adjust lower band
|
||||
lower_band[i] = if lower_basic > lower_band[i - 1] || close[i - 1] < lower_band[i - 1] {
|
||||
lower_basic
|
||||
} else {
|
||||
lower_band[i - 1]
|
||||
};
|
||||
|
||||
// Adjust upper band
|
||||
upper_band[i] = if upper_basic < upper_band[i - 1] || close[i - 1] > upper_band[i - 1] {
|
||||
upper_basic
|
||||
} else {
|
||||
upper_band[i - 1]
|
||||
};
|
||||
|
||||
// Direction and output only from index timeperiod (warmup = 0, NaN)
|
||||
if i >= timeperiod {
|
||||
let prev_dir = direction[i - 1];
|
||||
direction[i] = if prev_dir == 0 || prev_dir == -1 {
|
||||
if close[i] > upper_band[i] {
|
||||
1
|
||||
} else {
|
||||
-1
|
||||
}
|
||||
} else if close[i] < lower_band[i] {
|
||||
-1
|
||||
} else {
|
||||
1
|
||||
};
|
||||
supertrend_out[i] = if direction[i] == 1 {
|
||||
lower_band[i]
|
||||
} else {
|
||||
upper_band[i]
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
(supertrend_out, direction)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// DONCHIAN
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Donchian Channels — rolling highest high / lowest low.
|
||||
///
|
||||
/// # Returns
|
||||
/// `(upper, middle, lower)` arrays.
|
||||
pub fn donchian(high: &[f64], low: &[f64], timeperiod: usize) -> (Vec<f64>, Vec<f64>, Vec<f64>) {
|
||||
let n = high.len();
|
||||
let mut upper = vec![f64::NAN; n];
|
||||
let mut lower = vec![f64::NAN; n];
|
||||
let mut middle = vec![f64::NAN; n];
|
||||
|
||||
if timeperiod < 1 || n < timeperiod {
|
||||
return (upper, middle, lower);
|
||||
}
|
||||
|
||||
let hh = math::sliding_max(high, timeperiod);
|
||||
let ll = math::sliding_min(low, timeperiod);
|
||||
|
||||
for i in 0..n {
|
||||
if !hh[i].is_nan() {
|
||||
upper[i] = hh[i];
|
||||
lower[i] = ll[i];
|
||||
middle[i] = (upper[i] + lower[i]) / 2.0;
|
||||
}
|
||||
}
|
||||
|
||||
(upper, middle, lower)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// CHOPPINESS_INDEX
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Choppiness Index — measures market choppiness vs trending.
|
||||
///
|
||||
/// Values near 100 indicate a choppy market; near 0 indicates trending.
|
||||
/// The first `timeperiod` values are `NaN`.
|
||||
pub fn choppiness_index(high: &[f64], low: &[f64], close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let n = high.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if timeperiod < 1 || n <= timeperiod {
|
||||
return result;
|
||||
}
|
||||
|
||||
// ATR(1) = True Range per bar
|
||||
let mut tr = vec![0.0_f64; n];
|
||||
tr[0] = high[0] - low[0];
|
||||
for i in 1..n {
|
||||
let hl = high[i] - low[i];
|
||||
let hc = (high[i] - close[i - 1]).abs();
|
||||
let lc = (low[i] - close[i - 1]).abs();
|
||||
tr[i] = hl.max(hc).max(lc);
|
||||
}
|
||||
|
||||
// Cumulative TR for rolling sum
|
||||
let mut cum_tr = vec![0.0_f64; n];
|
||||
cum_tr[0] = tr[0];
|
||||
for i in 1..n {
|
||||
cum_tr[i] = cum_tr[i - 1] + tr[i];
|
||||
}
|
||||
|
||||
let log_n = (timeperiod as f64).log10();
|
||||
|
||||
let hh = math::sliding_max(high, timeperiod);
|
||||
let ll = math::sliding_min(low, timeperiod);
|
||||
|
||||
for i in (timeperiod)..n {
|
||||
let prev_cum = cum_tr[i - timeperiod];
|
||||
let sum_tr = cum_tr[i] - prev_cum;
|
||||
let hl_range = hh[i] - ll[i];
|
||||
if hl_range > 0.0 && log_n > 0.0 {
|
||||
result[i] = 100.0 * (sum_tr / hl_range).log10() / log_n;
|
||||
}
|
||||
}
|
||||
|
||||
result
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// KELTNER_CHANNELS
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Keltner Channels — EMA +/- (multiplier x ATR).
|
||||
///
|
||||
/// # Returns
|
||||
/// `(upper, middle, lower)` arrays.
|
||||
pub fn keltner_channels(
|
||||
high: &[f64],
|
||||
low: &[f64],
|
||||
close: &[f64],
|
||||
timeperiod: usize,
|
||||
atr_period: usize,
|
||||
multiplier: f64,
|
||||
) -> (Vec<f64>, Vec<f64>, Vec<f64>) {
|
||||
let n = high.len();
|
||||
if timeperiod < 1 || atr_period < 1 || n < timeperiod || n < atr_period {
|
||||
let nan = vec![f64::NAN; n];
|
||||
return (nan.clone(), nan.clone(), nan);
|
||||
}
|
||||
|
||||
let middle = overlap::ema(close, timeperiod);
|
||||
let atr = compute_atr(high, low, close, atr_period);
|
||||
|
||||
let mut upper = vec![f64::NAN; n];
|
||||
let mut lower = vec![f64::NAN; n];
|
||||
for i in 0..n {
|
||||
if !middle[i].is_nan() && !atr[i].is_nan() {
|
||||
let band = multiplier * atr[i];
|
||||
upper[i] = middle[i] + band;
|
||||
lower[i] = middle[i] - band;
|
||||
}
|
||||
}
|
||||
|
||||
(upper, middle, lower)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// HULL_MA
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Hull Moving Average (HMA).
|
||||
///
|
||||
/// `HMA(n) = WMA(2 * WMA(n/2) - WMA(n), sqrt(n))`
|
||||
pub fn hull_ma(close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let n = close.len();
|
||||
if timeperiod < 1 || n < timeperiod {
|
||||
return vec![f64::NAN; n];
|
||||
}
|
||||
|
||||
let half = (timeperiod / 2).max(1);
|
||||
let sqrt_p = ((timeperiod as f64).sqrt().round() as usize).max(1);
|
||||
|
||||
let wma_full = overlap::wma(close, timeperiod);
|
||||
let wma_half = overlap::wma(close, half);
|
||||
|
||||
// raw = 2 * wma_half - wma_full
|
||||
let mut raw = vec![f64::NAN; n];
|
||||
for i in 0..n {
|
||||
if !wma_full[i].is_nan() && !wma_half[i].is_nan() {
|
||||
raw[i] = 2.0 * wma_half[i] - wma_full[i];
|
||||
}
|
||||
}
|
||||
|
||||
// Find first valid index in raw
|
||||
let first_valid = raw.iter().position(|x| !x.is_nan()).unwrap_or(n);
|
||||
let mut hull = vec![f64::NAN; n];
|
||||
if first_valid < n {
|
||||
let raw_valid = &raw[first_valid..];
|
||||
let hma_slice = overlap::wma(raw_valid, sqrt_p);
|
||||
for (k, &v) in hma_slice.iter().enumerate() {
|
||||
hull[first_valid + k] = v;
|
||||
}
|
||||
}
|
||||
|
||||
hull
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// CHANDELIER_EXIT
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Chandelier Exit — ATR-based trailing stop levels.
|
||||
///
|
||||
/// # Returns
|
||||
/// `(long_exit, short_exit)` arrays.
|
||||
pub fn chandelier_exit(
|
||||
high: &[f64],
|
||||
low: &[f64],
|
||||
close: &[f64],
|
||||
timeperiod: usize,
|
||||
multiplier: f64,
|
||||
) -> (Vec<f64>, Vec<f64>) {
|
||||
let n = high.len();
|
||||
if timeperiod < 1 || n < timeperiod {
|
||||
return (vec![f64::NAN; n], vec![f64::NAN; n]);
|
||||
}
|
||||
|
||||
let atr = compute_atr(high, low, close, timeperiod);
|
||||
|
||||
let highest_high = math::sliding_max(high, timeperiod);
|
||||
let lowest_low = math::sliding_min(low, timeperiod);
|
||||
|
||||
let mut long_exit = vec![f64::NAN; n];
|
||||
let mut short_exit = vec![f64::NAN; n];
|
||||
for i in 0..n {
|
||||
if !highest_high[i].is_nan() && !atr[i].is_nan() {
|
||||
long_exit[i] = highest_high[i] - multiplier * atr[i];
|
||||
short_exit[i] = lowest_low[i] + multiplier * atr[i];
|
||||
}
|
||||
}
|
||||
|
||||
(long_exit, short_exit)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// ICHIMOKU
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Ichimoku Cloud (Ichimoku Kinko Hyo).
|
||||
///
|
||||
/// # Returns
|
||||
/// `(tenkan, kijun, senkou_a, senkou_b, chikou)` arrays.
|
||||
#[allow(clippy::type_complexity)]
|
||||
pub fn ichimoku(
|
||||
high: &[f64],
|
||||
low: &[f64],
|
||||
close: &[f64],
|
||||
tenkan_period: usize,
|
||||
kijun_period: usize,
|
||||
senkou_b_period: usize,
|
||||
displacement: usize,
|
||||
) -> (Vec<f64>, Vec<f64>, Vec<f64>, Vec<f64>, Vec<f64>) {
|
||||
let n = high.len();
|
||||
let nan = || vec![f64::NAN; n];
|
||||
|
||||
if tenkan_period < 1 || kijun_period < 1 || senkou_b_period < 1 {
|
||||
return (nan(), nan(), nan(), nan(), nan());
|
||||
}
|
||||
|
||||
// Helper: rolling (H+L)/2 via shared sliding_max / sliding_min
|
||||
let midpoint_rolling = |period: usize| -> Vec<f64> {
|
||||
let hh = math::sliding_max(high, period);
|
||||
let ll = math::sliding_min(low, period);
|
||||
let mut result = vec![f64::NAN; n];
|
||||
for i in 0..n {
|
||||
if !hh[i].is_nan() {
|
||||
result[i] = (hh[i] + ll[i]) / 2.0;
|
||||
}
|
||||
}
|
||||
result
|
||||
};
|
||||
|
||||
let tenkan = midpoint_rolling(tenkan_period);
|
||||
let kijun = midpoint_rolling(kijun_period);
|
||||
let raw_b = midpoint_rolling(senkou_b_period);
|
||||
|
||||
// Senkou A: (tenkan + kijun) / 2 shifted back `displacement` bars
|
||||
let mut senkou_a = vec![f64::NAN; n];
|
||||
if n > displacement {
|
||||
for i in displacement..n {
|
||||
if !tenkan[i].is_nan() && !kijun[i].is_nan() {
|
||||
senkou_a[i - displacement] = (tenkan[i] + kijun[i]) / 2.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Senkou B: raw_b shifted back `displacement` bars
|
||||
let mut senkou_b = vec![f64::NAN; n];
|
||||
if n > displacement {
|
||||
senkou_b[..n - displacement].copy_from_slice(&raw_b[displacement..]);
|
||||
}
|
||||
|
||||
// Chikou: close shifted forward `displacement` bars
|
||||
let mut chikou = vec![f64::NAN; n];
|
||||
if n > displacement {
|
||||
chikou[displacement..].copy_from_slice(&close[..n - displacement]);
|
||||
}
|
||||
|
||||
(tenkan, kijun, senkou_a, senkou_b, chikou)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// PIVOT_POINTS
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Pivot Points — support / resistance levels computed from the previous bar.
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `method` — `"classic"`, `"fibonacci"`, or `"camarilla"`. Returns all-NaN
|
||||
/// vectors for unknown methods.
|
||||
///
|
||||
/// # Returns
|
||||
/// `(pivot, r1, s1, r2, s2)` arrays. Index 0 is always `NaN` (no previous bar).
|
||||
#[allow(clippy::type_complexity)]
|
||||
pub fn pivot_points(
|
||||
high: &[f64],
|
||||
low: &[f64],
|
||||
close: &[f64],
|
||||
method: &str,
|
||||
) -> (Vec<f64>, Vec<f64>, Vec<f64>, Vec<f64>, Vec<f64>) {
|
||||
let n = high.len();
|
||||
let mut pivot = vec![f64::NAN; n];
|
||||
let mut r1 = vec![f64::NAN; n];
|
||||
let mut s1 = vec![f64::NAN; n];
|
||||
let mut r2 = vec![f64::NAN; n];
|
||||
let mut s2 = vec![f64::NAN; n];
|
||||
|
||||
let method_lower = method.to_lowercase();
|
||||
if !matches!(method_lower.as_str(), "classic" | "fibonacci" | "camarilla") {
|
||||
// Unknown method — return all NaN
|
||||
return (pivot, r1, s1, r2, s2);
|
||||
}
|
||||
|
||||
for i in 1..n {
|
||||
let ph = high[i - 1];
|
||||
let pl = low[i - 1];
|
||||
let pc = close[i - 1];
|
||||
let hl = ph - pl;
|
||||
let p = (ph + pl + pc) / 3.0;
|
||||
pivot[i] = p;
|
||||
match method_lower.as_str() {
|
||||
"classic" => {
|
||||
r1[i] = 2.0 * p - pl;
|
||||
s1[i] = 2.0 * p - ph;
|
||||
r2[i] = p + hl;
|
||||
s2[i] = p - hl;
|
||||
}
|
||||
"fibonacci" => {
|
||||
r1[i] = p + 0.382 * hl;
|
||||
s1[i] = p - 0.382 * hl;
|
||||
r2[i] = p + 0.618 * hl;
|
||||
s2[i] = p - 0.618 * hl;
|
||||
}
|
||||
"camarilla" => {
|
||||
r1[i] = pc + 1.1 * hl / 12.0;
|
||||
s1[i] = pc - 1.1 * hl / 12.0;
|
||||
r2[i] = pc + 1.1 * hl / 6.0;
|
||||
s2[i] = pc - 1.1 * hl / 6.0;
|
||||
}
|
||||
_ => unreachable!(),
|
||||
}
|
||||
}
|
||||
|
||||
(pivot, r1, s1, r2, s2)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
// Shared test data: 10-bar OHLCV
|
||||
fn sample_ohlcv() -> (Vec<f64>, Vec<f64>, Vec<f64>, Vec<f64>) {
|
||||
let high = vec![11.0, 12.0, 13.0, 14.0, 15.0, 14.5, 15.5, 16.0, 15.0, 14.0];
|
||||
let low = vec![9.0, 10.0, 11.0, 12.0, 13.0, 12.5, 13.5, 14.0, 13.0, 12.0];
|
||||
let close = vec![10.0, 11.0, 12.0, 13.0, 14.0, 13.5, 14.5, 15.0, 14.0, 13.0];
|
||||
let volume = vec![
|
||||
100.0, 150.0, 200.0, 250.0, 300.0, 200.0, 350.0, 400.0, 180.0, 220.0,
|
||||
];
|
||||
(high, low, close, volume)
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// VWAP tests
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn vwap_cumulative_basic() {
|
||||
let (h, l, c, v) = sample_ohlcv();
|
||||
let result = vwap(&h, &l, &c, &v, 0);
|
||||
assert_eq!(result.len(), h.len());
|
||||
// First bar: tp = (11+9+10)/3 = 10.0, tpv = 1000.0, vol = 100.0 => 10.0
|
||||
assert!((result[0] - 10.0).abs() < 1e-10);
|
||||
// All values should be non-NaN for cumulative
|
||||
for val in &result {
|
||||
assert!(!val.is_nan());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn vwap_empty_input() {
|
||||
let result = vwap(&[], &[], &[], &[], 0);
|
||||
assert!(result.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn vwap_rolling_basic() {
|
||||
let (h, l, c, v) = sample_ohlcv();
|
||||
let result = vwap(&h, &l, &c, &v, 3);
|
||||
assert_eq!(result.len(), h.len());
|
||||
// First 2 values should be NaN
|
||||
assert!(result[0].is_nan());
|
||||
assert!(result[1].is_nan());
|
||||
// From index 2 onward should be valid
|
||||
assert!(!result[2].is_nan());
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// VWMA tests
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn vwma_basic() {
|
||||
let (_, _, c, v) = sample_ohlcv();
|
||||
let result = vwma(&c, &v, 3);
|
||||
assert_eq!(result.len(), c.len());
|
||||
assert!(result[0].is_nan());
|
||||
assert!(result[1].is_nan());
|
||||
// Index 2: sum(c*v, 0..3) / sum(v, 0..3) = (1000+1650+2400)/(100+150+200) = 5050/450
|
||||
let expected = (10.0 * 100.0 + 11.0 * 150.0 + 12.0 * 200.0) / (100.0 + 150.0 + 200.0);
|
||||
assert!((result[2] - expected).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn vwma_empty_input() {
|
||||
let result = vwma(&[], &[], 3);
|
||||
assert!(result.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn vwma_period_larger_than_data() {
|
||||
let result = vwma(&[1.0, 2.0], &[100.0, 200.0], 5);
|
||||
assert_eq!(result.len(), 2);
|
||||
assert!(result.iter().all(|v| v.is_nan()));
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// SUPERTREND tests
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn supertrend_basic() {
|
||||
let (h, l, c, _) = sample_ohlcv();
|
||||
let (st, dir) = supertrend(&h, &l, &c, 3, 2.0);
|
||||
assert_eq!(st.len(), h.len());
|
||||
assert_eq!(dir.len(), h.len());
|
||||
// First 3 bars should be warmup (direction = 0, st = NaN)
|
||||
for i in 0..3 {
|
||||
assert_eq!(dir[i], 0);
|
||||
assert!(st[i].is_nan());
|
||||
}
|
||||
// From bar 3 onward, direction should be 1 or -1
|
||||
for i in 3..h.len() {
|
||||
assert!(dir[i] == 1 || dir[i] == -1);
|
||||
assert!(!st[i].is_nan());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn supertrend_empty_input() {
|
||||
let (st, dir) = supertrend(&[], &[], &[], 3, 2.0);
|
||||
assert!(st.is_empty());
|
||||
assert!(dir.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn supertrend_insufficient_data() {
|
||||
let (st, dir) = supertrend(&[1.0, 2.0], &[0.5, 1.5], &[1.5, 1.8], 5, 2.0);
|
||||
assert!(st.iter().all(|v| v.is_nan()));
|
||||
assert!(dir.iter().all(|&d| d == 0));
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// DONCHIAN tests
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn donchian_basic() {
|
||||
let (h, l, _, _) = sample_ohlcv();
|
||||
let (upper, middle, lower) = donchian(&h, &l, 3);
|
||||
assert_eq!(upper.len(), h.len());
|
||||
// First 2 are NaN
|
||||
assert!(upper[0].is_nan());
|
||||
assert!(upper[1].is_nan());
|
||||
// Index 2: max(11,12,13)=13, min(9,10,11)=9
|
||||
assert!((upper[2] - 13.0).abs() < 1e-10);
|
||||
assert!((lower[2] - 9.0).abs() < 1e-10);
|
||||
assert!((middle[2] - 11.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn donchian_empty_input() {
|
||||
let (u, m, l) = donchian(&[], &[], 3);
|
||||
assert!(u.is_empty());
|
||||
assert!(m.is_empty());
|
||||
assert!(l.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn donchian_period_1() {
|
||||
let h = vec![5.0, 3.0, 7.0];
|
||||
let l = vec![2.0, 1.0, 4.0];
|
||||
let (upper, middle, lower) = donchian(&h, &l, 1);
|
||||
// Every bar is its own window
|
||||
assert!((upper[0] - 5.0).abs() < 1e-10);
|
||||
assert!((lower[0] - 2.0).abs() < 1e-10);
|
||||
assert!((middle[0] - 3.5).abs() < 1e-10);
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// CHOPPINESS_INDEX tests
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn choppiness_index_basic() {
|
||||
let (h, l, c, _) = sample_ohlcv();
|
||||
let result = choppiness_index(&h, &l, &c, 3);
|
||||
assert_eq!(result.len(), h.len());
|
||||
// First 3 values should be NaN (timeperiod=3, i+1 > 3 starts at i=3)
|
||||
assert!(result[0].is_nan());
|
||||
assert!(result[1].is_nan());
|
||||
assert!(result[2].is_nan());
|
||||
// Index 3 should have a valid value (i+1=4 > 3)
|
||||
assert!(!result[3].is_nan());
|
||||
// CI should be between 0 and 100
|
||||
for val in result.iter().filter(|v| !v.is_nan()) {
|
||||
assert!(*val >= 0.0 && *val <= 100.0);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn choppiness_index_empty_input() {
|
||||
let result = choppiness_index(&[], &[], &[], 3);
|
||||
assert!(result.is_empty());
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// KELTNER_CHANNELS tests
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn keltner_channels_basic() {
|
||||
let (h, l, c, _) = sample_ohlcv();
|
||||
let (upper, middle, lower) = keltner_channels(&h, &l, &c, 3, 3, 1.5);
|
||||
assert_eq!(upper.len(), h.len());
|
||||
// Where both EMA and ATR are valid, upper > middle > lower
|
||||
for i in 0..h.len() {
|
||||
if !upper[i].is_nan() && !lower[i].is_nan() {
|
||||
assert!(upper[i] > middle[i]);
|
||||
assert!(lower[i] < middle[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn keltner_channels_empty_input() {
|
||||
let (u, m, l) = keltner_channels(&[], &[], &[], 3, 3, 1.5);
|
||||
assert!(u.is_empty());
|
||||
assert!(m.is_empty());
|
||||
assert!(l.is_empty());
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// HULL_MA tests
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn hull_ma_basic() {
|
||||
let prices: Vec<f64> = (1..=20).map(|i| i as f64).collect();
|
||||
let result = hull_ma(&prices, 4);
|
||||
assert_eq!(result.len(), prices.len());
|
||||
// Should have some NaN warmup, then valid values
|
||||
let valid_count = result.iter().filter(|v| !v.is_nan()).count();
|
||||
assert!(valid_count > 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hull_ma_empty_input() {
|
||||
let result = hull_ma(&[], 4);
|
||||
assert!(result.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hull_ma_period_larger_than_data() {
|
||||
let result = hull_ma(&[1.0, 2.0], 10);
|
||||
assert!(result.iter().all(|v| v.is_nan()));
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// CHANDELIER_EXIT tests
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn chandelier_exit_basic() {
|
||||
let (h, l, c, _) = sample_ohlcv();
|
||||
let (long_exit, short_exit) = chandelier_exit(&h, &l, &c, 3, 2.0);
|
||||
assert_eq!(long_exit.len(), h.len());
|
||||
assert_eq!(short_exit.len(), h.len());
|
||||
// Where valid, long_exit should be below highest high
|
||||
for i in 0..h.len() {
|
||||
if !long_exit[i].is_nan() {
|
||||
// long_exit = highest_high - multiplier * atr, should be < max high
|
||||
assert!(long_exit[i] < 20.0); // sanity
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chandelier_exit_empty_input() {
|
||||
let (le, se) = chandelier_exit(&[], &[], &[], 3, 2.0);
|
||||
assert!(le.is_empty());
|
||||
assert!(se.is_empty());
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// ICHIMOKU tests
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn ichimoku_basic() {
|
||||
// Use a larger dataset for ichimoku
|
||||
let n = 60;
|
||||
let high: Vec<f64> = (0..n).map(|i| 100.0 + i as f64 + 1.0).collect();
|
||||
let low: Vec<f64> = (0..n).map(|i| 100.0 + i as f64 - 1.0).collect();
|
||||
let close: Vec<f64> = (0..n).map(|i| 100.0 + i as f64).collect();
|
||||
|
||||
let (tenkan, kijun, senkou_a, senkou_b, chikou) =
|
||||
ichimoku(&high, &low, &close, 9, 26, 52, 26);
|
||||
|
||||
assert_eq!(tenkan.len(), n);
|
||||
assert_eq!(kijun.len(), n);
|
||||
assert_eq!(senkou_a.len(), n);
|
||||
assert_eq!(senkou_b.len(), n);
|
||||
assert_eq!(chikou.len(), n);
|
||||
|
||||
// Tenkan: period 9, first valid at index 8
|
||||
assert!(tenkan[7].is_nan());
|
||||
assert!(!tenkan[8].is_nan());
|
||||
|
||||
// Kijun: period 26, first valid at index 25
|
||||
assert!(kijun[24].is_nan());
|
||||
assert!(!kijun[25].is_nan());
|
||||
|
||||
// Chikou: close shifted forward by 26 bars
|
||||
assert!(chikou[25].is_nan());
|
||||
assert!(!chikou[26].is_nan());
|
||||
assert!((chikou[26] - close[0]).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ichimoku_empty_input() {
|
||||
let (t, k, sa, sb, ch) = ichimoku(&[], &[], &[], 9, 26, 52, 26);
|
||||
assert!(t.is_empty());
|
||||
assert!(k.is_empty());
|
||||
assert!(sa.is_empty());
|
||||
assert!(sb.is_empty());
|
||||
assert!(ch.is_empty());
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// PIVOT_POINTS tests
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn pivot_points_classic() {
|
||||
let h = vec![10.0, 12.0, 11.0];
|
||||
let l = vec![8.0, 9.0, 8.5];
|
||||
let c = vec![9.0, 11.0, 10.0];
|
||||
let (pivot, r1, s1, r2, s2) = pivot_points(&h, &l, &c, "classic");
|
||||
assert_eq!(pivot.len(), 3);
|
||||
// Index 0 is NaN
|
||||
assert!(pivot[0].is_nan());
|
||||
// Index 1: prev bar H=10, L=8, C=9 => P=(10+8+9)/3=9.0
|
||||
assert!((pivot[1] - 9.0).abs() < 1e-10);
|
||||
// R1 = 2*P - L = 18 - 8 = 10
|
||||
assert!((r1[1] - 10.0).abs() < 1e-10);
|
||||
// S1 = 2*P - H = 18 - 10 = 8
|
||||
assert!((s1[1] - 8.0).abs() < 1e-10);
|
||||
// R2 = P + (H-L) = 9 + 2 = 11
|
||||
assert!((r2[1] - 11.0).abs() < 1e-10);
|
||||
// S2 = P - (H-L) = 9 - 2 = 7
|
||||
assert!((s2[1] - 7.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pivot_points_fibonacci() {
|
||||
let h = vec![10.0, 12.0];
|
||||
let l = vec![8.0, 9.0];
|
||||
let c = vec![9.0, 11.0];
|
||||
let (pivot, r1, s1, _, _) = pivot_points(&h, &l, &c, "fibonacci");
|
||||
// Index 1: P = (10+8+9)/3 = 9.0, HL = 2
|
||||
assert!((pivot[1] - 9.0).abs() < 1e-10);
|
||||
assert!((r1[1] - (9.0 + 0.382 * 2.0)).abs() < 1e-10);
|
||||
assert!((s1[1] - (9.0 - 0.382 * 2.0)).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pivot_points_camarilla() {
|
||||
let h = vec![10.0, 12.0];
|
||||
let l = vec![8.0, 9.0];
|
||||
let c = vec![9.0, 11.0];
|
||||
let (pivot, r1, s1, _, _) = pivot_points(&h, &l, &c, "camarilla");
|
||||
assert!((pivot[1] - 9.0).abs() < 1e-10);
|
||||
// R1 = C + 1.1 * HL / 12 = 9 + 1.1*2/12
|
||||
assert!((r1[1] - (9.0 + 1.1 * 2.0 / 12.0)).abs() < 1e-10);
|
||||
assert!((s1[1] - (9.0 - 1.1 * 2.0 / 12.0)).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pivot_points_unknown_method() {
|
||||
let h = vec![10.0, 12.0];
|
||||
let l = vec![8.0, 9.0];
|
||||
let c = vec![9.0, 11.0];
|
||||
let (pivot, r1, s1, r2, s2) = pivot_points(&h, &l, &c, "unknown");
|
||||
assert!(pivot.iter().all(|v| v.is_nan()));
|
||||
assert!(r1.iter().all(|v| v.is_nan()));
|
||||
assert!(s1.iter().all(|v| v.is_nan()));
|
||||
assert!(r2.iter().all(|v| v.is_nan()));
|
||||
assert!(s2.iter().all(|v| v.is_nan()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pivot_points_empty_input() {
|
||||
let (p, r1, s1, r2, s2) = pivot_points(&[], &[], &[], "classic");
|
||||
assert!(p.is_empty());
|
||||
assert!(r1.is_empty());
|
||||
assert!(s1.is_empty());
|
||||
assert!(r2.is_empty());
|
||||
assert!(s2.is_empty());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
//! Basis and carry analytics.
|
||||
|
||||
/// Futures basis: futures - spot.
|
||||
pub fn basis(spot: f64, future: f64) -> f64 {
|
||||
if !spot.is_finite() || !future.is_finite() {
|
||||
f64::NAN
|
||||
} else {
|
||||
future - spot
|
||||
}
|
||||
}
|
||||
|
||||
/// Annualized simple basis return.
|
||||
pub fn annualized_basis(spot: f64, future: f64, time_to_expiry: f64) -> f64 {
|
||||
if !spot.is_finite()
|
||||
|| !future.is_finite()
|
||||
|| !time_to_expiry.is_finite()
|
||||
|| spot <= 0.0
|
||||
|| time_to_expiry <= 0.0
|
||||
{
|
||||
return f64::NAN;
|
||||
}
|
||||
(future / spot - 1.0) / time_to_expiry
|
||||
}
|
||||
|
||||
/// Implied continuously compounded carry rate.
|
||||
pub fn implied_carry_rate(spot: f64, future: f64, time_to_expiry: f64) -> f64 {
|
||||
if !spot.is_finite()
|
||||
|| !future.is_finite()
|
||||
|| !time_to_expiry.is_finite()
|
||||
|| spot <= 0.0
|
||||
|| future <= 0.0
|
||||
|| time_to_expiry <= 0.0
|
||||
{
|
||||
return f64::NAN;
|
||||
}
|
||||
(future / spot).ln() / time_to_expiry
|
||||
}
|
||||
|
||||
/// Carry spread relative to the risk-free rate.
|
||||
pub fn carry_spread(spot: f64, future: f64, rate: f64, time_to_expiry: f64) -> f64 {
|
||||
implied_carry_rate(spot, future, time_to_expiry) - rate
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{annualized_basis, basis, carry_spread, implied_carry_rate};
|
||||
|
||||
#[test]
|
||||
fn basis_helpers_work() {
|
||||
assert_eq!(basis(100.0, 103.0), 3.0);
|
||||
assert!(annualized_basis(100.0, 103.0, 0.25) > 0.0);
|
||||
assert!(implied_carry_rate(100.0, 103.0, 0.25) > 0.0);
|
||||
assert!(carry_spread(100.0, 103.0, 0.02, 0.25).is_finite());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,83 @@
|
||||
//! Futures curve and term-structure analytics.
|
||||
|
||||
use super::basis;
|
||||
|
||||
/// Curve summary metrics.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub struct CurveSummary {
|
||||
pub front_basis: f64,
|
||||
pub average_basis: f64,
|
||||
pub slope: f64,
|
||||
pub is_contango: bool,
|
||||
}
|
||||
|
||||
fn regression_slope(xs: &[f64], ys: &[f64]) -> f64 {
|
||||
if xs.len() != ys.len() || xs.len() < 2 {
|
||||
return f64::NAN;
|
||||
}
|
||||
let n = xs.len() as f64;
|
||||
let mean_x = xs.iter().sum::<f64>() / n;
|
||||
let mean_y = ys.iter().sum::<f64>() / n;
|
||||
let mut cov = 0.0;
|
||||
let mut var = 0.0;
|
||||
for (&x, &y) in xs.iter().zip(ys.iter()) {
|
||||
cov += (x - mean_x) * (y - mean_y);
|
||||
var += (x - mean_x) * (x - mean_x);
|
||||
}
|
||||
if var == 0.0 {
|
||||
f64::NAN
|
||||
} else {
|
||||
cov / var
|
||||
}
|
||||
}
|
||||
|
||||
/// Calendar spreads between adjacent contracts.
|
||||
pub fn calendar_spreads(futures_prices: &[f64]) -> Vec<f64> {
|
||||
futures_prices.windows(2).map(|w| w[1] - w[0]).collect()
|
||||
}
|
||||
|
||||
/// Curve slope across tenor buckets.
|
||||
pub fn curve_slope(tenors: &[f64], futures_prices: &[f64]) -> f64 {
|
||||
regression_slope(tenors, futures_prices)
|
||||
}
|
||||
|
||||
/// Summary statistics for a forward curve.
|
||||
pub fn curve_summary(spot: f64, tenors: &[f64], futures_prices: &[f64]) -> CurveSummary {
|
||||
if futures_prices.is_empty() || tenors.len() != futures_prices.len() {
|
||||
return CurveSummary {
|
||||
front_basis: f64::NAN,
|
||||
average_basis: f64::NAN,
|
||||
slope: f64::NAN,
|
||||
is_contango: false,
|
||||
};
|
||||
}
|
||||
let bases: Vec<f64> = futures_prices
|
||||
.iter()
|
||||
.map(|&price| basis::basis(spot, price))
|
||||
.collect();
|
||||
let average_basis = bases.iter().sum::<f64>() / bases.len() as f64;
|
||||
let is_contango = futures_prices.windows(2).all(|w| w[1] >= w[0]);
|
||||
CurveSummary {
|
||||
front_basis: basis::basis(spot, futures_prices[0]),
|
||||
average_basis,
|
||||
slope: curve_slope(tenors, futures_prices),
|
||||
is_contango,
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{calendar_spreads, curve_slope, curve_summary};
|
||||
|
||||
#[test]
|
||||
fn calendar_spreads_are_correct() {
|
||||
assert_eq!(calendar_spreads(&[100.0, 101.0, 103.0]), vec![1.0, 2.0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn curve_summary_detects_contango() {
|
||||
let summary = curve_summary(100.0, &[0.1, 0.5, 1.0], &[101.0, 102.0, 104.0]);
|
||||
assert!(summary.is_contango);
|
||||
assert!(curve_slope(&[0.1, 0.5, 1.0], &[101.0, 102.0, 104.0]) > 0.0);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
//! Futures analytics core.
|
||||
|
||||
pub mod basis;
|
||||
pub mod curve;
|
||||
pub mod roll;
|
||||
pub mod synthetic;
|
||||
@@ -0,0 +1,109 @@
|
||||
//! Continuous futures roll helpers.
|
||||
|
||||
/// Weighted stitching using next-contract weights in [0, 1].
|
||||
pub fn weighted_continuous(front: &[f64], next: &[f64], next_weights: &[f64]) -> Vec<f64> {
|
||||
if front.len() != next.len() || front.len() != next_weights.len() {
|
||||
return Vec::new();
|
||||
}
|
||||
front
|
||||
.iter()
|
||||
.zip(next.iter())
|
||||
.zip(next_weights.iter())
|
||||
.map(|((&f, &n), &w)| f * (1.0 - w) + n * w)
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn roll_index(weights: &[f64]) -> Option<usize> {
|
||||
if weights.is_empty() {
|
||||
return None;
|
||||
}
|
||||
weights
|
||||
.iter()
|
||||
.enumerate()
|
||||
.find(|(_, w)| **w >= 0.5)
|
||||
.map(|(idx, _)| idx)
|
||||
.or_else(|| weights.iter().position(|w| *w > 0.0))
|
||||
.or(Some(weights.len() - 1))
|
||||
}
|
||||
|
||||
/// Back-adjusted continuous series using the roll date implied by the weights.
|
||||
pub fn back_adjusted_continuous(front: &[f64], next: &[f64], next_weights: &[f64]) -> Vec<f64> {
|
||||
if front.len() != next.len() || front.len() != next_weights.len() || front.is_empty() {
|
||||
return Vec::new();
|
||||
}
|
||||
let idx = roll_index(next_weights).unwrap_or(front.len() - 1);
|
||||
let gap = next[idx] - front[idx];
|
||||
front
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(i, &value)| if i < idx { value + gap } else { next[i] })
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Ratio-adjusted continuous series using the roll date implied by the weights.
|
||||
pub fn ratio_adjusted_continuous(front: &[f64], next: &[f64], next_weights: &[f64]) -> Vec<f64> {
|
||||
if front.len() != next.len() || front.len() != next_weights.len() || front.is_empty() {
|
||||
return Vec::new();
|
||||
}
|
||||
let idx = roll_index(next_weights).unwrap_or(front.len() - 1);
|
||||
let ratio = if front[idx] == 0.0 {
|
||||
1.0
|
||||
} else {
|
||||
next[idx] / front[idx]
|
||||
};
|
||||
front
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(i, &value)| if i < idx { value * ratio } else { next[i] })
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Annualized roll yield from front and next prices.
|
||||
pub fn roll_yield(front_price: f64, next_price: f64, time_to_expiry: f64) -> f64 {
|
||||
if !front_price.is_finite()
|
||||
|| !next_price.is_finite()
|
||||
|| !time_to_expiry.is_finite()
|
||||
|| front_price <= 0.0
|
||||
|| time_to_expiry <= 0.0
|
||||
{
|
||||
return f64::NAN;
|
||||
}
|
||||
(next_price / front_price - 1.0) / time_to_expiry
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{
|
||||
back_adjusted_continuous, ratio_adjusted_continuous, roll_yield, weighted_continuous,
|
||||
};
|
||||
|
||||
#[test]
|
||||
fn weighted_roll_blends_contracts() {
|
||||
let out = weighted_continuous(&[100.0, 101.0], &[102.0, 103.0], &[0.0, 1.0]);
|
||||
assert_eq!(out, vec![100.0, 103.0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn adjusted_rolls_return_full_series() {
|
||||
let weights = [0.0, 0.25, 0.75, 1.0];
|
||||
assert_eq!(
|
||||
back_adjusted_continuous(
|
||||
&[100.0, 101.0, 102.0, 103.0],
|
||||
&[101.0, 102.0, 103.0, 104.0],
|
||||
&weights
|
||||
)
|
||||
.len(),
|
||||
4
|
||||
);
|
||||
assert_eq!(
|
||||
ratio_adjusted_continuous(
|
||||
&[100.0, 101.0, 102.0, 103.0],
|
||||
&[101.0, 102.0, 103.0, 104.0],
|
||||
&weights
|
||||
)
|
||||
.len(),
|
||||
4
|
||||
);
|
||||
assert!(roll_yield(100.0, 102.0, 30.0 / 365.0).is_finite());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
//! Synthetic futures helpers built from put-call parity.
|
||||
|
||||
/// Synthetic forward price from call/put parity.
|
||||
pub fn synthetic_forward(
|
||||
call_price: f64,
|
||||
put_price: f64,
|
||||
strike: f64,
|
||||
rate: f64,
|
||||
time_to_expiry: f64,
|
||||
) -> f64 {
|
||||
if !call_price.is_finite()
|
||||
|| !put_price.is_finite()
|
||||
|| !strike.is_finite()
|
||||
|| !rate.is_finite()
|
||||
|| !time_to_expiry.is_finite()
|
||||
|| strike <= 0.0
|
||||
|| time_to_expiry < 0.0
|
||||
{
|
||||
return f64::NAN;
|
||||
}
|
||||
(call_price - put_price) * (rate * time_to_expiry).exp() + strike
|
||||
}
|
||||
|
||||
/// Synthetic spot price implied by call/put parity with continuous carry.
|
||||
pub fn synthetic_spot(
|
||||
call_price: f64,
|
||||
put_price: f64,
|
||||
strike: f64,
|
||||
rate: f64,
|
||||
carry: f64,
|
||||
time_to_expiry: f64,
|
||||
) -> f64 {
|
||||
if !call_price.is_finite()
|
||||
|| !put_price.is_finite()
|
||||
|| !strike.is_finite()
|
||||
|| !rate.is_finite()
|
||||
|| !carry.is_finite()
|
||||
|| !time_to_expiry.is_finite()
|
||||
|| strike <= 0.0
|
||||
|| time_to_expiry < 0.0
|
||||
{
|
||||
return f64::NAN;
|
||||
}
|
||||
(call_price - put_price + strike * (-rate * time_to_expiry).exp())
|
||||
* (carry * time_to_expiry).exp()
|
||||
}
|
||||
|
||||
/// Put-call parity residual. Zero means the inputs are parity-consistent.
|
||||
pub fn parity_gap(
|
||||
call_price: f64,
|
||||
put_price: f64,
|
||||
spot: f64,
|
||||
strike: f64,
|
||||
rate: f64,
|
||||
carry: f64,
|
||||
time_to_expiry: f64,
|
||||
) -> f64 {
|
||||
call_price
|
||||
- put_price
|
||||
- (spot * (-carry * time_to_expiry).exp() - strike * (-rate * time_to_expiry).exp())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{parity_gap, synthetic_forward};
|
||||
|
||||
#[test]
|
||||
fn synthetic_forward_is_consistent() {
|
||||
let forward = synthetic_forward(8.0, 5.0, 100.0, 0.02, 0.5);
|
||||
assert!(forward > 100.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parity_gap_zero_when_consistent() {
|
||||
let gap = parity_gap(10.45, 5.57, 100.0, 100.0, 0.05, 0.0, 1.0);
|
||||
assert!(gap.abs() < 0.05);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
#![forbid(unsafe_code)]
|
||||
|
||||
/*!
|
||||
ferro_ta_core — Pure Rust indicator library.
|
||||
|
||||
This crate contains all indicator implementations as pure functions operating
|
||||
on `&[f64]` slices and returning `Vec<f64>`. It has **no dependency on PyO3
|
||||
or numpy** so it can be used from any Rust project, or compiled to WASM /
|
||||
Node.js via napi-rs without dragging in Python bindings.
|
||||
|
||||
The Python wheel (`ferro_ta` PyPI package) is built from a thin binding crate
|
||||
that calls into this core and converts NumPy arrays to/from Rust slices.
|
||||
|
||||
# Two-layer architecture
|
||||
|
||||
The root crate (`ferro_ta`) contains PyO3 `#[pyfunction]` wrappers that convert
|
||||
numpy arrays to `&[f64]` and delegate to this core crate.
|
||||
|
||||
# Usage (Rust)
|
||||
|
||||
```rust
|
||||
use ferro_ta_core::overlap;
|
||||
|
||||
let close = vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0];
|
||||
let sma = overlap::sma(&close, 3);
|
||||
assert!(sma[0].is_nan());
|
||||
assert!((sma[2] - 2.0).abs() < 1e-10);
|
||||
```
|
||||
*/
|
||||
|
||||
pub mod aggregation;
|
||||
pub mod alerts;
|
||||
pub mod attribution;
|
||||
pub mod backtest;
|
||||
pub mod batch;
|
||||
pub mod chunked;
|
||||
pub mod commission;
|
||||
pub mod crypto;
|
||||
pub mod currency;
|
||||
pub mod cycle;
|
||||
pub mod extended;
|
||||
pub mod futures;
|
||||
pub mod math;
|
||||
pub mod math_ops;
|
||||
pub mod momentum;
|
||||
pub mod options;
|
||||
pub mod overlap;
|
||||
pub mod pattern;
|
||||
pub mod portfolio;
|
||||
pub mod price_transform;
|
||||
pub mod regime;
|
||||
pub mod resampling;
|
||||
pub mod signals;
|
||||
/// Runtime-dispatched SIMD reduction primitives (internal).
|
||||
pub(crate) mod simd;
|
||||
pub mod statistic;
|
||||
pub mod streaming;
|
||||
pub mod volatility;
|
||||
pub mod volume;
|
||||
@@ -0,0 +1,217 @@
|
||||
//! Math utilities.
|
||||
|
||||
use std::collections::VecDeque;
|
||||
|
||||
/// Compute the rolling sum over `timeperiod` bars.
|
||||
///
|
||||
/// Returns a `Vec<f64>` of length `n`. The first `timeperiod - 1` values
|
||||
/// are `NaN`. Uses an incremental algorithm (add new, subtract old) for O(n).
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `real` - Input series.
|
||||
/// * `timeperiod` - Rolling window size (must be >= 1).
|
||||
pub fn sum(real: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let n = real.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if timeperiod < 1 || n < timeperiod {
|
||||
return result;
|
||||
}
|
||||
let mut win: f64 = real[..timeperiod].iter().sum();
|
||||
result[timeperiod - 1] = win;
|
||||
for i in timeperiod..n {
|
||||
win += real[i] - real[i - timeperiod];
|
||||
result[i] = win;
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// Compute the rolling maximum over `timeperiod` bars.
|
||||
///
|
||||
/// Delegates to [`sliding_max`] for O(n) performance via a monotonic deque.
|
||||
/// The first `timeperiod - 1` values are `NaN`.
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `real` - Input series.
|
||||
/// * `timeperiod` - Rolling window size (must be >= 1).
|
||||
pub fn max(real: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
sliding_max(real, timeperiod)
|
||||
}
|
||||
|
||||
/// Compute the rolling minimum over `timeperiod` bars.
|
||||
///
|
||||
/// Delegates to [`sliding_min`] for O(n) performance via a monotonic deque.
|
||||
/// The first `timeperiod - 1` values are `NaN`.
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `real` - Input series.
|
||||
/// * `timeperiod` - Rolling window size (must be >= 1).
|
||||
pub fn min(real: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
sliding_min(real, timeperiod)
|
||||
}
|
||||
|
||||
/// Compute the sliding maximum over `timeperiod` bars in O(n) time.
|
||||
///
|
||||
/// Uses a monotonic decreasing deque so each element is pushed/popped at
|
||||
/// most once. The first `timeperiod - 1` values are `NaN`.
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `real` - Input series.
|
||||
/// * `timeperiod` - Rolling window size (must be >= 1).
|
||||
pub fn sliding_max(real: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let n = real.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if timeperiod < 1 || n < timeperiod {
|
||||
return result;
|
||||
}
|
||||
let mut dq: VecDeque<usize> = VecDeque::new();
|
||||
for i in 0..n {
|
||||
// Remove indices outside the window
|
||||
while dq.front().map(|&j| j + timeperiod <= i).unwrap_or(false) {
|
||||
dq.pop_front();
|
||||
}
|
||||
// Maintain decreasing deque
|
||||
while dq.back().map(|&j| real[j] <= real[i]).unwrap_or(false) {
|
||||
dq.pop_back();
|
||||
}
|
||||
dq.push_back(i);
|
||||
if i + 1 >= timeperiod {
|
||||
result[i] = real[*dq.front().unwrap()];
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// Compute the sliding minimum over `timeperiod` bars in O(n) time.
|
||||
///
|
||||
/// Uses a monotonic increasing deque so each element is pushed/popped at
|
||||
/// most once. The first `timeperiod - 1` values are `NaN`.
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `real` - Input series.
|
||||
/// * `timeperiod` - Rolling window size (must be >= 1).
|
||||
pub fn sliding_min(real: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let n = real.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if timeperiod < 1 || n < timeperiod {
|
||||
return result;
|
||||
}
|
||||
let mut dq: VecDeque<usize> = VecDeque::new();
|
||||
for i in 0..n {
|
||||
// Remove indices outside the window
|
||||
while dq.front().map(|&j| j + timeperiod <= i).unwrap_or(false) {
|
||||
dq.pop_front();
|
||||
}
|
||||
// Maintain increasing deque
|
||||
while dq.back().map(|&j| real[j] >= real[i]).unwrap_or(false) {
|
||||
dq.pop_back();
|
||||
}
|
||||
dq.push_back(i);
|
||||
if i + 1 >= timeperiod {
|
||||
result[i] = real[*dq.front().unwrap()];
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Element-wise arithmetic operators
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Element-wise addition of two arrays.
|
||||
pub fn add(a: &[f64], b: &[f64]) -> Vec<f64> {
|
||||
a.iter().zip(b.iter()).map(|(&x, &y)| x + y).collect()
|
||||
}
|
||||
|
||||
/// Element-wise subtraction of two arrays.
|
||||
pub fn sub(a: &[f64], b: &[f64]) -> Vec<f64> {
|
||||
a.iter().zip(b.iter()).map(|(&x, &y)| x - y).collect()
|
||||
}
|
||||
|
||||
/// Element-wise multiplication of two arrays.
|
||||
pub fn mult(a: &[f64], b: &[f64]) -> Vec<f64> {
|
||||
a.iter().zip(b.iter()).map(|(&x, &y)| x * y).collect()
|
||||
}
|
||||
|
||||
/// Element-wise division of two arrays (NaN where b=0).
|
||||
pub fn div(a: &[f64], b: &[f64]) -> Vec<f64> {
|
||||
a.iter()
|
||||
.zip(b.iter())
|
||||
.map(|(&x, &y)| if y != 0.0 { x / y } else { f64::NAN })
|
||||
.collect()
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Element-wise math transforms
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
macro_rules! unary_transform {
|
||||
($name:ident, $method:ident) => {
|
||||
pub fn $name(real: &[f64]) -> Vec<f64> {
|
||||
real.iter().map(|&x| x.$method()).collect()
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
unary_transform!(math_acos, acos);
|
||||
unary_transform!(math_asin, asin);
|
||||
unary_transform!(math_atan, atan);
|
||||
unary_transform!(math_ceil, ceil);
|
||||
unary_transform!(math_cos, cos);
|
||||
unary_transform!(math_cosh, cosh);
|
||||
unary_transform!(math_exp, exp);
|
||||
unary_transform!(math_floor, floor);
|
||||
unary_transform!(math_ln, ln);
|
||||
unary_transform!(math_log10, log10);
|
||||
unary_transform!(math_sin, sin);
|
||||
unary_transform!(math_sinh, sinh);
|
||||
unary_transform!(math_sqrt, sqrt);
|
||||
unary_transform!(math_tan, tan);
|
||||
unary_transform!(math_tanh, tanh);
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn sum_basic() {
|
||||
let v = vec![1.0, 2.0, 3.0, 4.0, 5.0];
|
||||
let r = sum(&v, 3);
|
||||
assert!(r[0].is_nan());
|
||||
assert!((r[2] - 6.0).abs() < 1e-10);
|
||||
assert!((r[4] - 12.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn max_basic() {
|
||||
let v = vec![3.0, 1.0, 4.0, 1.0, 5.0];
|
||||
let r = max(&v, 3);
|
||||
assert!((r[2] - 4.0).abs() < 1e-10);
|
||||
assert!((r[4] - 5.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sliding_max_matches_naive() {
|
||||
let v = vec![3.0, 1.0, 4.0, 1.0, 5.0, 9.0, 2.0, 6.0];
|
||||
let naive = max(&v, 3);
|
||||
let fast = sliding_max(&v, 3);
|
||||
for i in 0..v.len() {
|
||||
assert_eq!(naive[i].is_nan(), fast[i].is_nan());
|
||||
if !naive[i].is_nan() {
|
||||
assert!((naive[i] - fast[i]).abs() < 1e-10);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sliding_min_matches_naive() {
|
||||
let v = vec![3.0, 1.0, 4.0, 1.0, 5.0, 9.0, 2.0, 6.0];
|
||||
let naive = min(&v, 3);
|
||||
let fast = sliding_min(&v, 3);
|
||||
for i in 0..v.len() {
|
||||
assert_eq!(naive[i].is_nan(), fast[i].is_nan());
|
||||
if !naive[i].is_nan() {
|
||||
assert!((naive[i] - fast[i]).abs() < 1e-10);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,154 @@
|
||||
//! Rolling math operators — O(n) sliding window implementations.
|
||||
//!
|
||||
//! - `rolling_sum` — rolling sum over `timeperiod` bars (prefix-sum based)
|
||||
//! - `rolling_max` — rolling maximum (O(n) monotonic deque)
|
||||
//! - `rolling_min` — rolling minimum (O(n) monotonic deque)
|
||||
//! - `rolling_maxindex` — index of rolling maximum
|
||||
//! - `rolling_minindex` — index of rolling minimum
|
||||
|
||||
use std::collections::VecDeque;
|
||||
|
||||
/// Rolling sum over `timeperiod` bars using a prefix-sum array.
|
||||
/// Leading `timeperiod - 1` values are NaN.
|
||||
pub fn rolling_sum(real: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let n = real.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if timeperiod == 0 || n < timeperiod {
|
||||
return result;
|
||||
}
|
||||
let mut cs = vec![0.0f64; n + 1];
|
||||
for i in 0..n {
|
||||
cs[i + 1] = cs[i] + real[i];
|
||||
}
|
||||
for i in (timeperiod - 1)..n {
|
||||
result[i] = cs[i + 1] - cs[i + 1 - timeperiod];
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// Rolling maximum over `timeperiod` bars (O(n) monotonic deque).
|
||||
/// Delegates to `math::sliding_max`.
|
||||
pub fn rolling_max(real: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
crate::math::sliding_max(real, timeperiod)
|
||||
}
|
||||
|
||||
/// Rolling minimum over `timeperiod` bars (O(n) monotonic deque).
|
||||
/// Delegates to `math::sliding_min`.
|
||||
pub fn rolling_min(real: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
crate::math::sliding_min(real, timeperiod)
|
||||
}
|
||||
|
||||
/// Index of rolling maximum over `timeperiod` bars.
|
||||
/// Returns 0-based index. During warmup the value is `-1`.
|
||||
pub fn rolling_maxindex(real: &[f64], timeperiod: usize) -> Vec<i64> {
|
||||
let n = real.len();
|
||||
let mut result = vec![-1i64; n];
|
||||
if timeperiod == 0 || n < timeperiod {
|
||||
return result;
|
||||
}
|
||||
let mut dq: VecDeque<usize> = VecDeque::new();
|
||||
for i in 0..n {
|
||||
while dq.front().map(|&j| j + timeperiod <= i).unwrap_or(false) {
|
||||
dq.pop_front();
|
||||
}
|
||||
while dq.back().map(|&j| real[j] <= real[i]).unwrap_or(false) {
|
||||
dq.pop_back();
|
||||
}
|
||||
dq.push_back(i);
|
||||
if i + 1 >= timeperiod {
|
||||
result[i] = *dq.front().unwrap() as i64;
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// Index of rolling minimum over `timeperiod` bars.
|
||||
/// Returns 0-based index. During warmup the value is `-1`.
|
||||
pub fn rolling_minindex(real: &[f64], timeperiod: usize) -> Vec<i64> {
|
||||
let n = real.len();
|
||||
let mut result = vec![-1i64; n];
|
||||
if timeperiod == 0 || n < timeperiod {
|
||||
return result;
|
||||
}
|
||||
let mut dq: VecDeque<usize> = VecDeque::new();
|
||||
for i in 0..n {
|
||||
while dq.front().map(|&j| j + timeperiod <= i).unwrap_or(false) {
|
||||
dq.pop_front();
|
||||
}
|
||||
while dq.back().map(|&j| real[j] >= real[i]).unwrap_or(false) {
|
||||
dq.pop_back();
|
||||
}
|
||||
dq.push_back(i);
|
||||
if i + 1 >= timeperiod {
|
||||
result[i] = *dq.front().unwrap() as i64;
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_rolling_sum() {
|
||||
let data = vec![1.0, 2.0, 3.0, 4.0, 5.0];
|
||||
let result = rolling_sum(&data, 3);
|
||||
assert!(result[0].is_nan());
|
||||
assert!(result[1].is_nan());
|
||||
assert!((result[2] - 6.0).abs() < 1e-10); // 1+2+3
|
||||
assert!((result[3] - 9.0).abs() < 1e-10); // 2+3+4
|
||||
assert!((result[4] - 12.0).abs() < 1e-10); // 3+4+5
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rolling_max() {
|
||||
let data = vec![1.0, 3.0, 2.0, 5.0, 4.0];
|
||||
let result = rolling_max(&data, 3);
|
||||
assert!(result[0].is_nan());
|
||||
assert!(result[1].is_nan());
|
||||
assert!((result[2] - 3.0).abs() < 1e-10);
|
||||
assert!((result[3] - 5.0).abs() < 1e-10);
|
||||
assert!((result[4] - 5.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rolling_min() {
|
||||
let data = vec![5.0, 3.0, 4.0, 1.0, 2.0];
|
||||
let result = rolling_min(&data, 3);
|
||||
assert!(result[0].is_nan());
|
||||
assert!(result[1].is_nan());
|
||||
assert!((result[2] - 3.0).abs() < 1e-10);
|
||||
assert!((result[3] - 1.0).abs() < 1e-10);
|
||||
assert!((result[4] - 1.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rolling_maxindex() {
|
||||
let data = vec![1.0, 3.0, 2.0, 5.0, 4.0];
|
||||
let result = rolling_maxindex(&data, 3);
|
||||
assert_eq!(result[0], -1);
|
||||
assert_eq!(result[1], -1);
|
||||
assert_eq!(result[2], 1); // max(1,3,2) at index 1
|
||||
assert_eq!(result[3], 3); // max(3,2,5) at index 3
|
||||
assert_eq!(result[4], 3); // max(2,5,4) at index 3
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rolling_minindex() {
|
||||
let data = vec![5.0, 3.0, 4.0, 1.0, 2.0];
|
||||
let result = rolling_minindex(&data, 3);
|
||||
assert_eq!(result[0], -1);
|
||||
assert_eq!(result[1], -1);
|
||||
assert_eq!(result[2], 1); // min(5,3,4) at index 1
|
||||
assert_eq!(result[3], 3); // min(3,4,1) at index 3
|
||||
assert_eq!(result[4], 3); // min(4,1,2) at index 3
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_short_input() {
|
||||
let data = vec![1.0, 2.0];
|
||||
let result = rolling_sum(&data, 5);
|
||||
assert!(result.iter().all(|v| v.is_nan()));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,925 @@
|
||||
//! Momentum indicators.
|
||||
|
||||
/// Compute the Relative Strength Index (RSI).
|
||||
///
|
||||
/// Returns values in the range `[0, 100]`. Uses Wilder's smoothing method
|
||||
/// (TA-Lib compatible), seeding avg_gain/avg_loss with the SMA of the first
|
||||
/// `timeperiod` price changes. The first `timeperiod` values are `NaN`.
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `close` - Price series.
|
||||
/// * `timeperiod` - Lookback period (typically 14).
|
||||
pub fn rsi(close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let n = close.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if n <= timeperiod || timeperiod < 1 {
|
||||
return result;
|
||||
}
|
||||
let mut avg_gain = 0.0_f64;
|
||||
let mut avg_loss = 0.0_f64;
|
||||
for i in 1..=timeperiod {
|
||||
let diff = close[i] - close[i - 1];
|
||||
let abs_diff = diff.abs();
|
||||
avg_gain += (diff + abs_diff) * 0.5;
|
||||
avg_loss += (abs_diff - diff) * 0.5;
|
||||
}
|
||||
avg_gain /= timeperiod as f64;
|
||||
avg_loss /= timeperiod as f64;
|
||||
let p = timeperiod as f64;
|
||||
let rs = if avg_loss == 0.0 {
|
||||
f64::MAX
|
||||
} else {
|
||||
avg_gain / avg_loss
|
||||
};
|
||||
result[timeperiod] = 100.0 - 100.0 / (1.0 + rs);
|
||||
for i in (timeperiod + 1)..n {
|
||||
let diff = close[i] - close[i - 1];
|
||||
let abs_diff = diff.abs();
|
||||
let gain = (diff + abs_diff) * 0.5;
|
||||
let loss = (abs_diff - diff) * 0.5;
|
||||
avg_gain = (avg_gain * (p - 1.0) + gain) / p;
|
||||
avg_loss = (avg_loss * (p - 1.0) + loss) / p;
|
||||
let rs = if avg_loss == 0.0 {
|
||||
f64::MAX
|
||||
} else {
|
||||
avg_gain / avg_loss
|
||||
};
|
||||
result[i] = 100.0 - 100.0 / (1.0 + rs);
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// Compute the Momentum indicator: `close[i] - close[i - timeperiod]`.
|
||||
///
|
||||
/// Returns a `Vec<f64>` of length `n`. The first `timeperiod` values are `NaN`.
|
||||
/// Positive values indicate upward price movement over the lookback window.
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `close` - Price series.
|
||||
/// * `timeperiod` - Number of bars to look back (must be >= 1).
|
||||
pub fn mom(close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let n = close.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if timeperiod < 1 {
|
||||
return result;
|
||||
}
|
||||
for i in timeperiod..n {
|
||||
result[i] = close[i] - close[i - timeperiod];
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// Compute the Stochastic Oscillator (TA-Lib compatible).
|
||||
///
|
||||
/// Returns `(slow_k, slow_d)`, both in the range `[0, 100]`.
|
||||
/// - Fast %K = 100 * (close - lowest low) / (highest high - lowest low)
|
||||
/// - Slow %K = SMA(fast %K, `slowk_period`)
|
||||
/// - Slow %D = SMA(slow %K, `slowd_period`)
|
||||
///
|
||||
/// Uses O(n) sliding max/min via monotonic deques. Both outputs are
|
||||
/// `NaN`-padded until slow %D becomes valid (TA-Lib convention).
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `high` / `low` / `close` - OHLC price series (same length).
|
||||
/// * `fastk_period` - Lookback for highest high / lowest low.
|
||||
/// * `slowk_period` - SMA period applied to fast %K.
|
||||
/// * `slowd_period` - SMA period applied to slow %K.
|
||||
pub fn stoch(
|
||||
high: &[f64],
|
||||
low: &[f64],
|
||||
close: &[f64],
|
||||
fastk_period: usize,
|
||||
slowk_period: usize,
|
||||
slowd_period: usize,
|
||||
) -> (Vec<f64>, Vec<f64>) {
|
||||
let n = high.len();
|
||||
let nan_pair = || (vec![f64::NAN; n], vec![f64::NAN; n]);
|
||||
if n == 0 || fastk_period < 1 || slowk_period < 1 || slowd_period < 1 {
|
||||
return nan_pair();
|
||||
}
|
||||
if n < fastk_period {
|
||||
return nan_pair();
|
||||
}
|
||||
|
||||
let mut slowk = vec![f64::NAN; n];
|
||||
let mut slowd = vec![f64::NAN; n];
|
||||
|
||||
// Fused pass: compute fast %K inline with sliding max/min.
|
||||
// For typical small windows (5-14), inline scan beats VecDeque overhead.
|
||||
let fastk_start = fastk_period - 1;
|
||||
let fk_len = n - fastk_start;
|
||||
let mut fastk_valid = vec![0.0_f64; fk_len];
|
||||
|
||||
for i in fastk_start..n {
|
||||
// Inline sliding max(high) and min(low) over [i - fastk_period + 1 .. i].
|
||||
let win_start = i + 1 - fastk_period;
|
||||
let mut hh = high[win_start];
|
||||
let mut ll = low[win_start];
|
||||
for j in (win_start + 1)..=i {
|
||||
let h = high[j];
|
||||
let l = low[j];
|
||||
if h > hh {
|
||||
hh = h;
|
||||
}
|
||||
if l < ll {
|
||||
ll = l;
|
||||
}
|
||||
}
|
||||
let range = hh - ll;
|
||||
fastk_valid[i - fastk_start] = if range != 0.0 {
|
||||
100.0 * (close[i] - ll) / range
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
}
|
||||
|
||||
// Slow %K = SMA(fastk_valid, slowk_period).
|
||||
crate::overlap::sma_into(&fastk_valid, slowk_period, &mut slowk, fastk_start);
|
||||
|
||||
// Slow %D = SMA(slowk, slowd_period).
|
||||
let slowk_valid_start = fastk_start + slowk_period - 1;
|
||||
let slowd_valid_start = slowk_valid_start + slowd_period - 1;
|
||||
|
||||
if slowk_valid_start < n {
|
||||
let slowk_valid_slice = &slowk[slowk_valid_start..];
|
||||
crate::overlap::sma_into(
|
||||
slowk_valid_slice,
|
||||
slowd_period,
|
||||
&mut slowd,
|
||||
slowk_valid_start,
|
||||
);
|
||||
}
|
||||
|
||||
// TA-Lib pads BOTH slowk and slowd with NaNs up to the point where both are valid.
|
||||
if slowd_valid_start < n {
|
||||
for v in slowk.iter_mut().take(slowd_valid_start) {
|
||||
*v = f64::NAN;
|
||||
}
|
||||
} else {
|
||||
for v in slowk.iter_mut().take(n) {
|
||||
*v = f64::NAN;
|
||||
}
|
||||
}
|
||||
|
||||
(slowk, slowd)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// ADX family
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Return type for ADX inner (pdm_s, mdm_s, plus_di, minus_di, dx, adx).
|
||||
type AdxInnerOutput = (Vec<f64>, Vec<f64>, Vec<f64>, Vec<f64>, Vec<f64>, Vec<f64>);
|
||||
|
||||
/// Fused inner function for ADX-family indicators.
|
||||
/// Returns a tuple of (pdm_s, mdm_s, plus_di, minus_di, dx, adx).
|
||||
fn adx_inner(high: &[f64], low: &[f64], close: &[f64], period: usize) -> AdxInnerOutput {
|
||||
let n = high.len();
|
||||
let mut b_pdm = vec![f64::NAN; n];
|
||||
let mut b_mdm = vec![f64::NAN; n];
|
||||
let mut b_pdi = vec![f64::NAN; n];
|
||||
let mut b_mdi = vec![f64::NAN; n];
|
||||
let mut b_dx = vec![f64::NAN; n];
|
||||
let mut b_adx = vec![f64::NAN; n];
|
||||
|
||||
if n < period || period < 1 || n < 2 {
|
||||
return (b_pdm, b_mdm, b_pdi, b_mdi, b_dx, b_adx);
|
||||
}
|
||||
|
||||
let m = n - 1;
|
||||
let mut tr = vec![0.0_f64; m];
|
||||
let mut pdm = vec![0.0_f64; m];
|
||||
let mut mdm = vec![0.0_f64; m];
|
||||
|
||||
for i in 0..m {
|
||||
let j = i + 1;
|
||||
let h_diff = high[j] - high[i];
|
||||
let l_diff = low[i] - low[j];
|
||||
let hl = high[j] - low[j];
|
||||
let hpc = (high[j] - close[i]).abs();
|
||||
let lpc = (low[j] - close[i]).abs();
|
||||
tr[i] = hl.max(hpc).max(lpc);
|
||||
pdm[i] = if h_diff > l_diff && h_diff > 0.0 {
|
||||
h_diff
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
mdm[i] = if l_diff > h_diff && l_diff > 0.0 {
|
||||
l_diff
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
}
|
||||
|
||||
if m < period {
|
||||
return (b_pdm, b_mdm, b_pdi, b_mdi, b_dx, b_adx);
|
||||
}
|
||||
|
||||
let mut tr_s = tr[..period].iter().sum::<f64>();
|
||||
let mut pdm_s = pdm[..period].iter().sum::<f64>();
|
||||
let mut mdm_s = mdm[..period].iter().sum::<f64>();
|
||||
|
||||
// Initial seeded values at index `period`
|
||||
b_pdm[period] = pdm_s;
|
||||
b_mdm[period] = mdm_s;
|
||||
if tr_s != 0.0 {
|
||||
b_pdi[period] = 100.0 * pdm_s / tr_s;
|
||||
b_mdi[period] = 100.0 * mdm_s / tr_s;
|
||||
let s = b_pdi[period] + b_mdi[period];
|
||||
b_dx[period] = if s != 0.0 {
|
||||
100.0 * (b_pdi[period] - b_mdi[period]).abs() / s
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
}
|
||||
|
||||
let decay = (period - 1) as f64 / period as f64;
|
||||
for i in period..m {
|
||||
tr_s = tr_s * decay + tr[i];
|
||||
pdm_s = pdm_s * decay + pdm[i];
|
||||
mdm_s = mdm_s * decay + mdm[i];
|
||||
|
||||
b_pdm[i + 1] = pdm_s;
|
||||
b_mdm[i + 1] = mdm_s;
|
||||
if tr_s != 0.0 {
|
||||
b_pdi[i + 1] = 100.0 * pdm_s / tr_s;
|
||||
b_mdi[i + 1] = 100.0 * mdm_s / tr_s;
|
||||
let s = b_pdi[i + 1] + b_mdi[i + 1];
|
||||
b_dx[i + 1] = if s != 0.0 {
|
||||
100.0 * (b_pdi[i + 1] - b_mdi[i + 1]).abs() / s
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// Wilder smooth DX to get ADX
|
||||
let adx_start = period + period - 1;
|
||||
if n > adx_start {
|
||||
let mut dx_sum = 0.0;
|
||||
let mut valid_dx = true;
|
||||
for v in b_dx.iter().skip(period).take(period) {
|
||||
if v.is_nan() {
|
||||
valid_dx = false;
|
||||
break;
|
||||
}
|
||||
dx_sum += v;
|
||||
}
|
||||
if valid_dx {
|
||||
let mut adx_s = dx_sum / period as f64;
|
||||
b_adx[adx_start] = adx_s;
|
||||
let alpha = 1.0 / period as f64;
|
||||
for i in adx_start + 1..n {
|
||||
adx_s = adx_s + alpha * (b_dx[i] - adx_s);
|
||||
b_adx[i] = adx_s;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
(b_pdm, b_mdm, b_pdi, b_mdi, b_dx, b_adx)
|
||||
}
|
||||
|
||||
/// Compute all six ADX-family outputs in a single pass.
|
||||
///
|
||||
/// Returns `(plus_dm, minus_dm, plus_di, minus_di, dx, adx)`.
|
||||
/// Use this when you need multiple ADX-family outputs to avoid redundant
|
||||
/// computation. All values are in `[0, 100]` except DM which is unbounded.
|
||||
/// Warmup: DI/DX valid from index `timeperiod`; ADX from `2 * timeperiod - 1`.
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `high` / `low` / `close` - OHLC price series (same length).
|
||||
/// * `timeperiod` - Wilder smoothing period (typically 14).
|
||||
pub fn adx_all(high: &[f64], low: &[f64], close: &[f64], timeperiod: usize) -> AdxInnerOutput {
|
||||
adx_inner(high, low, close, timeperiod)
|
||||
}
|
||||
|
||||
/// Internal helper for plus_dm and minus_dm that doesn't allocate dummy close prices.
|
||||
/// Returns (plus_dm, minus_dm) smoothed with Wilder's method.
|
||||
fn dm_only_inner(high: &[f64], low: &[f64], period: usize) -> (Vec<f64>, Vec<f64>) {
|
||||
let n = high.len();
|
||||
let mut b_pdm = vec![f64::NAN; n];
|
||||
let mut b_mdm = vec![f64::NAN; n];
|
||||
|
||||
if n < period || period < 1 || n < 2 {
|
||||
return (b_pdm, b_mdm);
|
||||
}
|
||||
|
||||
let m = n - 1;
|
||||
let mut pdm = vec![0.0_f64; m];
|
||||
let mut mdm = vec![0.0_f64; m];
|
||||
|
||||
for i in 0..m {
|
||||
let j = i + 1;
|
||||
let h_diff = high[j] - high[i];
|
||||
let l_diff = low[i] - low[j];
|
||||
pdm[i] = if h_diff > l_diff && h_diff > 0.0 {
|
||||
h_diff
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
mdm[i] = if l_diff > h_diff && l_diff > 0.0 {
|
||||
l_diff
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
}
|
||||
|
||||
if m < period {
|
||||
return (b_pdm, b_mdm);
|
||||
}
|
||||
|
||||
let mut pdm_s = pdm[..period].iter().sum::<f64>();
|
||||
let mut mdm_s = mdm[..period].iter().sum::<f64>();
|
||||
|
||||
b_pdm[period] = pdm_s;
|
||||
b_mdm[period] = mdm_s;
|
||||
|
||||
let decay = (period - 1) as f64 / period as f64;
|
||||
for i in period..m {
|
||||
pdm_s = pdm_s * decay + pdm[i];
|
||||
mdm_s = mdm_s * decay + mdm[i];
|
||||
b_pdm[i + 1] = pdm_s;
|
||||
b_mdm[i + 1] = mdm_s;
|
||||
}
|
||||
|
||||
(b_pdm, b_mdm)
|
||||
}
|
||||
|
||||
/// Compute the Plus Directional Movement (+DM), Wilder smoothed.
|
||||
///
|
||||
/// Measures upward price movement. Returns a `Vec<f64>` of length `n`;
|
||||
/// the first `timeperiod` values are `NaN`.
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `high` / `low` - High and low price series (same length).
|
||||
/// * `timeperiod` - Wilder smoothing period.
|
||||
pub fn plus_dm(high: &[f64], low: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let (pdm, _) = dm_only_inner(high, low, timeperiod);
|
||||
pdm
|
||||
}
|
||||
|
||||
/// Compute the Minus Directional Movement (-DM), Wilder smoothed.
|
||||
///
|
||||
/// Measures downward price movement. Returns a `Vec<f64>` of length `n`;
|
||||
/// the first `timeperiod` values are `NaN`.
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `high` / `low` - High and low price series (same length).
|
||||
/// * `timeperiod` - Wilder smoothing period.
|
||||
pub fn minus_dm(high: &[f64], low: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let (_, mdm) = dm_only_inner(high, low, timeperiod);
|
||||
mdm
|
||||
}
|
||||
|
||||
/// Compute the Plus Directional Indicator (+DI), Wilder smoothed.
|
||||
///
|
||||
/// `+DI = 100 * smoothed(+DM) / smoothed(TR)`. Returns values in `[0, 100]`.
|
||||
/// The first `timeperiod` values are `NaN`.
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `high` / `low` / `close` - OHLC price series (same length).
|
||||
/// * `timeperiod` - Wilder smoothing period.
|
||||
pub fn plus_di(high: &[f64], low: &[f64], close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let (_, _, pdi, _, _, _) = adx_inner(high, low, close, timeperiod);
|
||||
pdi
|
||||
}
|
||||
|
||||
/// Compute the Minus Directional Indicator (-DI), Wilder smoothed.
|
||||
///
|
||||
/// `-DI = 100 * smoothed(-DM) / smoothed(TR)`. Returns values in `[0, 100]`.
|
||||
/// The first `timeperiod` values are `NaN`.
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `high` / `low` / `close` - OHLC price series (same length).
|
||||
/// * `timeperiod` - Wilder smoothing period.
|
||||
pub fn minus_di(high: &[f64], low: &[f64], close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let (_, _, _, mdi, _, _) = adx_inner(high, low, close, timeperiod);
|
||||
mdi
|
||||
}
|
||||
|
||||
/// Compute the Directional Movement Index (DX).
|
||||
///
|
||||
/// `DX = 100 * |+DI - -DI| / (+DI + -DI)`. Returns values in `[0, 100]`.
|
||||
/// The first `timeperiod` values are `NaN`.
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `high` / `low` / `close` - OHLC price series (same length).
|
||||
/// * `timeperiod` - Wilder smoothing period.
|
||||
pub fn dx(high: &[f64], low: &[f64], close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let (_, _, _, _, dx_vals, _) = adx_inner(high, low, close, timeperiod);
|
||||
dx_vals
|
||||
}
|
||||
|
||||
/// Compute the Average Directional Movement Index (ADX).
|
||||
///
|
||||
/// ADX is Wilder's smoothing of DX, measuring trend strength regardless of
|
||||
/// direction. Returns values in `[0, 100]`. The first `2 * timeperiod - 1`
|
||||
/// values are `NaN` (DX warmup + ADX smoothing warmup).
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `high` / `low` / `close` - OHLC price series (same length).
|
||||
/// * `timeperiod` - Wilder smoothing period (typically 14).
|
||||
pub fn adx(high: &[f64], low: &[f64], close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let (_, _, _, _, _, adx_vals) = adx_inner(high, low, close, timeperiod);
|
||||
adx_vals
|
||||
}
|
||||
|
||||
/// Compute the ADX Rating (ADXR).
|
||||
///
|
||||
/// `ADXR[i] = (ADX[i] + ADX[i - timeperiod]) / 2`. Smooths ADX further
|
||||
/// by averaging current ADX with its value `timeperiod` bars ago.
|
||||
/// Returns values in `[0, 100]`.
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `high` / `low` / `close` - OHLC price series (same length).
|
||||
/// * `timeperiod` - Wilder smoothing period (typically 14).
|
||||
pub fn adxr(high: &[f64], low: &[f64], close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let n = high.len();
|
||||
// Reuse adx_all to compute ADX once, then derive ADXR from it
|
||||
let (_, _, _, _, _, adx_vals) = adx_inner(high, low, close, timeperiod);
|
||||
let mut result = vec![f64::NAN; n];
|
||||
for i in timeperiod..n {
|
||||
if !adx_vals[i].is_nan() && !adx_vals[i - timeperiod].is_nan() {
|
||||
result[i] = (adx_vals[i] + adx_vals[i - timeperiod]) / 2.0;
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Rate of Change variants
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Rate of Change: `(close[i] - close[i-p]) / close[i-p] * 100`.
|
||||
pub fn roc(close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let n = close.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if timeperiod == 0 {
|
||||
return result;
|
||||
}
|
||||
for i in timeperiod..n {
|
||||
let prev = close[i - timeperiod];
|
||||
if prev != 0.0 {
|
||||
result[i] = (close[i] - prev) / prev * 100.0;
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// Rate of Change Percentage: `(close[i] - close[i-p]) / close[i-p]`.
|
||||
pub fn rocp(close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let n = close.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if timeperiod == 0 {
|
||||
return result;
|
||||
}
|
||||
for i in timeperiod..n {
|
||||
let prev = close[i - timeperiod];
|
||||
if prev != 0.0 {
|
||||
result[i] = (close[i] - prev) / prev;
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// Rate of Change Ratio: `close[i] / close[i-p]`.
|
||||
pub fn rocr(close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let n = close.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if timeperiod == 0 {
|
||||
return result;
|
||||
}
|
||||
for i in timeperiod..n {
|
||||
let prev = close[i - timeperiod];
|
||||
if prev != 0.0 {
|
||||
result[i] = close[i] / prev;
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// Rate of Change Ratio x 100: `close[i] / close[i-p] * 100`.
|
||||
pub fn rocr100(close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let n = close.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if timeperiod == 0 {
|
||||
return result;
|
||||
}
|
||||
for i in timeperiod..n {
|
||||
let prev = close[i - timeperiod];
|
||||
if prev != 0.0 {
|
||||
result[i] = close[i] / prev * 100.0;
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Williams %R
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Williams %R: `-100 * (HH - close) / (HH - LL)` over the window.
|
||||
/// Returns values in `[-100, 0]`.
|
||||
pub fn willr(high: &[f64], low: &[f64], close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let n = high.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if timeperiod == 0 || n < timeperiod {
|
||||
return result;
|
||||
}
|
||||
for i in (timeperiod - 1)..n {
|
||||
let start = i + 1 - timeperiod;
|
||||
let mut highest = f64::NEG_INFINITY;
|
||||
let mut lowest = f64::INFINITY;
|
||||
for j in start..=i {
|
||||
if high[j] > highest {
|
||||
highest = high[j];
|
||||
}
|
||||
if low[j] < lowest {
|
||||
lowest = low[j];
|
||||
}
|
||||
}
|
||||
let range = highest - lowest;
|
||||
result[i] = if range != 0.0 {
|
||||
-100.0 * (highest - close[i]) / range
|
||||
} else {
|
||||
-50.0
|
||||
};
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Aroon
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Aroon indicator. Returns `(aroon_down, aroon_up)`.
|
||||
pub fn aroon(high: &[f64], low: &[f64], timeperiod: usize) -> (Vec<f64>, Vec<f64>) {
|
||||
let n = high.len();
|
||||
let mut aroon_down = vec![f64::NAN; n];
|
||||
let mut aroon_up = vec![f64::NAN; n];
|
||||
if timeperiod == 0 || n <= timeperiod {
|
||||
return (aroon_down, aroon_up);
|
||||
}
|
||||
let period_f = timeperiod as f64;
|
||||
let window_size = timeperiod + 1;
|
||||
for i in timeperiod..n {
|
||||
let start = i + 1 - window_size;
|
||||
let mut max_val = high[start];
|
||||
let mut min_val = low[start];
|
||||
let mut max_idx = 0usize;
|
||||
let mut min_idx = 0usize;
|
||||
for j in 0..window_size {
|
||||
if high[start + j] >= max_val {
|
||||
max_val = high[start + j];
|
||||
max_idx = j;
|
||||
}
|
||||
if low[start + j] <= min_val {
|
||||
min_val = low[start + j];
|
||||
min_idx = j;
|
||||
}
|
||||
}
|
||||
aroon_up[i] = 100.0 * (max_idx as f64) / period_f;
|
||||
aroon_down[i] = 100.0 * (min_idx as f64) / period_f;
|
||||
}
|
||||
(aroon_down, aroon_up)
|
||||
}
|
||||
|
||||
/// Aroon Oscillator: `aroon_up - aroon_down`.
|
||||
pub fn aroonosc(high: &[f64], low: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let (down, up) = aroon(high, low, timeperiod);
|
||||
up.iter()
|
||||
.zip(down.iter())
|
||||
.map(|(&u, &d)| {
|
||||
if u.is_nan() || d.is_nan() {
|
||||
f64::NAN
|
||||
} else {
|
||||
u - d
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// CCI
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Commodity Channel Index: `(tp - SMA(tp)) / (0.015 * MAD)`.
|
||||
pub fn cci(high: &[f64], low: &[f64], close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let n = high.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if timeperiod == 0 || n < timeperiod {
|
||||
return result;
|
||||
}
|
||||
let tp: Vec<f64> = high
|
||||
.iter()
|
||||
.zip(low.iter())
|
||||
.zip(close.iter())
|
||||
.map(|((&h, &l), &c)| (h + l + c) / 3.0)
|
||||
.collect();
|
||||
for i in (timeperiod - 1)..n {
|
||||
let window = &tp[(i + 1 - timeperiod)..=i];
|
||||
let mean: f64 = window.iter().sum::<f64>() / timeperiod as f64;
|
||||
let mad: f64 = window.iter().map(|&x| (x - mean).abs()).sum::<f64>() / timeperiod as f64;
|
||||
result[i] = if mad != 0.0 {
|
||||
(tp[i] - mean) / (0.015 * mad)
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// BOP
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Balance of Power: `(close - open) / (high - low)`.
|
||||
pub fn bop(open: &[f64], high: &[f64], low: &[f64], close: &[f64]) -> Vec<f64> {
|
||||
open.iter()
|
||||
.zip(high.iter())
|
||||
.zip(low.iter())
|
||||
.zip(close.iter())
|
||||
.map(|(((&o, &h), &l), &c)| {
|
||||
let range = h - l;
|
||||
if range != 0.0 {
|
||||
(c - o) / range
|
||||
} else {
|
||||
0.0
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Stochastic RSI
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Stochastic RSI. Returns `(fastk, fastd)`.
|
||||
pub fn stochrsi(
|
||||
close: &[f64],
|
||||
timeperiod: usize,
|
||||
fastk_period: usize,
|
||||
fastd_period: usize,
|
||||
) -> (Vec<f64>, Vec<f64>) {
|
||||
let n = close.len();
|
||||
let nan_pair = || (vec![f64::NAN; n], vec![f64::NAN; n]);
|
||||
if timeperiod == 0 || fastk_period == 0 || fastd_period == 0 {
|
||||
return nan_pair();
|
||||
}
|
||||
|
||||
let rsi_vals = rsi(close, timeperiod);
|
||||
let rsi_warmup = timeperiod;
|
||||
let k_warmup = rsi_warmup + fastk_period - 1;
|
||||
let d_warmup = k_warmup + fastd_period - 1;
|
||||
|
||||
let mut fastk = vec![f64::NAN; n];
|
||||
let mut fastd = vec![f64::NAN; n];
|
||||
|
||||
for i in k_warmup..n {
|
||||
if rsi_vals[i].is_nan() {
|
||||
continue;
|
||||
}
|
||||
let start = i + 1 - fastk_period;
|
||||
if (start..=i).any(|j| rsi_vals[j].is_nan()) {
|
||||
continue;
|
||||
}
|
||||
let mx = rsi_vals[start..=i]
|
||||
.iter()
|
||||
.cloned()
|
||||
.fold(f64::NEG_INFINITY, f64::max);
|
||||
let mn = rsi_vals[start..=i]
|
||||
.iter()
|
||||
.cloned()
|
||||
.fold(f64::INFINITY, f64::min);
|
||||
fastk[i] = if mx != mn {
|
||||
100.0 * (rsi_vals[i] - mn) / (mx - mn)
|
||||
} else {
|
||||
50.0
|
||||
};
|
||||
}
|
||||
|
||||
for i in d_warmup..n {
|
||||
let start = i + 1 - fastd_period;
|
||||
let window = &fastk[start..=i];
|
||||
if window.iter().all(|v| !v.is_nan()) {
|
||||
fastd[i] = window.iter().sum::<f64>() / fastd_period as f64;
|
||||
}
|
||||
}
|
||||
(fastk, fastd)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// APO / PPO
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Absolute Price Oscillator: `fast EMA - slow EMA`.
|
||||
pub fn apo(close: &[f64], fastperiod: usize, slowperiod: usize) -> Vec<f64> {
|
||||
let n = close.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if fastperiod == 0 || slowperiod == 0 || fastperiod >= slowperiod {
|
||||
return result;
|
||||
}
|
||||
let fast = crate::overlap::ema(close, fastperiod);
|
||||
let slow = crate::overlap::ema(close, slowperiod);
|
||||
let warmup = slowperiod - 1;
|
||||
for i in warmup..n {
|
||||
if !fast[i].is_nan() && !slow[i].is_nan() {
|
||||
result[i] = fast[i] - slow[i];
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// Percentage Price Oscillator: `(fast EMA - slow EMA) / slow EMA * 100`.
|
||||
/// Returns `(ppo_line, signal_line, histogram)`.
|
||||
pub fn ppo(
|
||||
close: &[f64],
|
||||
fastperiod: usize,
|
||||
slowperiod: usize,
|
||||
signalperiod: usize,
|
||||
) -> (Vec<f64>, Vec<f64>, Vec<f64>) {
|
||||
let n = close.len();
|
||||
let nan3 = || (vec![f64::NAN; n], vec![f64::NAN; n], vec![f64::NAN; n]);
|
||||
if fastperiod == 0 || slowperiod == 0 || signalperiod == 0 || fastperiod >= slowperiod {
|
||||
return nan3();
|
||||
}
|
||||
let fast = crate::overlap::ema(close, fastperiod);
|
||||
let slow = crate::overlap::ema(close, slowperiod);
|
||||
let warmup = slowperiod - 1;
|
||||
|
||||
let mut ppo_line = vec![f64::NAN; n];
|
||||
for i in warmup..n {
|
||||
if !fast[i].is_nan() && !slow[i].is_nan() && slow[i] != 0.0 {
|
||||
ppo_line[i] = (fast[i] - slow[i]) / slow[i] * 100.0;
|
||||
}
|
||||
}
|
||||
|
||||
// Signal line = EMA of PPO line (only over valid values)
|
||||
let signal = crate::overlap::ema(&ppo_line, signalperiod);
|
||||
let mut signal_line = vec![f64::NAN; n];
|
||||
let mut hist = vec![f64::NAN; n];
|
||||
let sig_warmup = warmup + signalperiod - 1;
|
||||
for i in sig_warmup..n {
|
||||
if !ppo_line[i].is_nan() && !signal[i].is_nan() {
|
||||
signal_line[i] = signal[i];
|
||||
hist[i] = ppo_line[i] - signal[i];
|
||||
}
|
||||
}
|
||||
(ppo_line, signal_line, hist)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// CMO
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Chande Momentum Oscillator: `100 * (sum_gains - sum_losses) / (sum_gains + sum_losses)`.
|
||||
pub fn cmo(close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let n = close.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if timeperiod == 0 || n < timeperiod + 1 {
|
||||
return result;
|
||||
}
|
||||
let changes: Vec<f64> = close.windows(2).map(|w| w[1] - w[0]).collect();
|
||||
for i in timeperiod..n {
|
||||
let mut ups = 0.0_f64;
|
||||
let mut downs = 0.0_f64;
|
||||
for ch in &changes[(i - timeperiod)..i] {
|
||||
if *ch > 0.0 {
|
||||
ups += ch;
|
||||
} else {
|
||||
downs -= ch;
|
||||
}
|
||||
}
|
||||
let denom = ups + downs;
|
||||
result[i] = if denom != 0.0 {
|
||||
100.0 * (ups - downs) / denom
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// TRIX
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// TRIX: 1-period rate of change of triple-smoothed EMA.
|
||||
pub fn trix(close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let n = close.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if timeperiod == 0 {
|
||||
return result;
|
||||
}
|
||||
let warmup = 3 * (timeperiod - 1);
|
||||
|
||||
// Triple EMA: EMA(EMA(EMA(close)))
|
||||
let ema1 = crate::overlap::ema(close, timeperiod);
|
||||
let ema2 = crate::overlap::ema(&ema1, timeperiod);
|
||||
let ema3 = crate::overlap::ema(&ema2, timeperiod);
|
||||
|
||||
for i in (warmup + 1)..n {
|
||||
let prev = ema3[i - 1];
|
||||
if !ema3[i].is_nan() && !prev.is_nan() && prev != 0.0 {
|
||||
result[i] = (ema3[i] - prev) / prev * 100.0;
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Ultimate Oscillator
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Ultimate Oscillator: weighted average of buying pressure over three periods.
|
||||
pub fn ultosc(
|
||||
high: &[f64],
|
||||
low: &[f64],
|
||||
close: &[f64],
|
||||
timeperiod1: usize,
|
||||
timeperiod2: usize,
|
||||
timeperiod3: usize,
|
||||
) -> Vec<f64> {
|
||||
let n = high.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if timeperiod1 == 0 || timeperiod2 == 0 || timeperiod3 == 0 || n < 2 {
|
||||
return result;
|
||||
}
|
||||
let max_period = timeperiod1.max(timeperiod2).max(timeperiod3);
|
||||
if n <= max_period {
|
||||
return result;
|
||||
}
|
||||
|
||||
let mut bp = vec![0.0_f64; n];
|
||||
let mut tr = vec![0.0_f64; n];
|
||||
for i in 1..n {
|
||||
let true_low = low[i].min(close[i - 1]);
|
||||
let true_high = high[i].max(close[i - 1]);
|
||||
bp[i] = close[i] - true_low;
|
||||
tr[i] = true_high - true_low;
|
||||
}
|
||||
|
||||
for i in max_period..n {
|
||||
let avg = |period: usize| -> f64 {
|
||||
let sum_bp: f64 = bp[(i + 1 - period)..=i].iter().sum();
|
||||
let sum_tr: f64 = tr[(i + 1 - period)..=i].iter().sum();
|
||||
if sum_tr != 0.0 {
|
||||
sum_bp / sum_tr
|
||||
} else {
|
||||
0.0
|
||||
}
|
||||
};
|
||||
result[i] =
|
||||
100.0 * (4.0 * avg(timeperiod1) + 2.0 * avg(timeperiod2) + avg(timeperiod3)) / 7.0;
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn rsi_range() {
|
||||
let prices: Vec<f64> = (1..=50).map(|i| i as f64).collect();
|
||||
let result = rsi(&prices, 14);
|
||||
for v in result.iter().filter(|v| !v.is_nan()) {
|
||||
assert!(*v >= 0.0 && *v <= 100.0);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mom_basic() {
|
||||
let prices = vec![1.0, 2.0, 3.0, 4.0, 5.0];
|
||||
let result = mom(&prices, 2);
|
||||
assert!(result[0].is_nan());
|
||||
assert!(result[1].is_nan());
|
||||
assert!((result[2] - 2.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stoch_basic() {
|
||||
let high = vec![10.0, 11.0, 12.0, 11.5, 13.0, 12.5, 14.0, 13.5];
|
||||
let low = vec![9.0, 10.0, 11.0, 10.5, 12.0, 11.5, 13.0, 12.5];
|
||||
let close = vec![9.5, 10.5, 11.5, 11.0, 12.5, 12.0, 13.5, 13.0];
|
||||
let (slowk, slowd) = stoch(&high, &low, &close, 3, 3, 3);
|
||||
// Check that valid values are in [0, 100]
|
||||
for v in slowk.iter().filter(|v| !v.is_nan()) {
|
||||
assert!(*v >= 0.0 && *v <= 100.0, "slowk out of range: {v}");
|
||||
}
|
||||
for v in slowd.iter().filter(|v| !v.is_nan()) {
|
||||
assert!(*v >= 0.0 && *v <= 100.0, "slowd out of range: {v}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn adx_nonnegative() {
|
||||
let h: Vec<f64> = (1..=50).map(|i| i as f64 + 1.0).collect();
|
||||
let l: Vec<f64> = (1..=50).map(|i| i as f64).collect();
|
||||
let c: Vec<f64> = (1..=50).map(|i| i as f64 + 0.5).collect();
|
||||
let result = adx(&h, &l, &c, 14);
|
||||
for v in result.iter().filter(|v| !v.is_nan()) {
|
||||
assert!(*v >= 0.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,410 @@
|
||||
//! American option pricing via the Barone-Adesi-Whaley (1987) quadratic approximation.
|
||||
|
||||
use super::normal::cdf;
|
||||
use super::pricing::black_scholes_price;
|
||||
use super::OptionKind;
|
||||
|
||||
fn invalid_inputs(spot: f64, strike: f64, time_to_expiry: f64, volatility: f64) -> bool {
|
||||
!spot.is_finite()
|
||||
|| !strike.is_finite()
|
||||
|| !time_to_expiry.is_finite()
|
||||
|| !volatility.is_finite()
|
||||
|| spot <= 0.0
|
||||
|| strike <= 0.0
|
||||
|| time_to_expiry < 0.0
|
||||
|| volatility < 0.0
|
||||
}
|
||||
|
||||
/// Compute d1 for BSM given spot S* (used inside the Newton-Raphson loop).
|
||||
fn d1_fn(s: f64, strike: f64, rate: f64, carry: f64, time_to_expiry: f64, volatility: f64) -> f64 {
|
||||
let sigma_sqrt_t = volatility * time_to_expiry.sqrt();
|
||||
((s / strike).ln() + (rate - carry + 0.5 * volatility * volatility) * time_to_expiry)
|
||||
/ sigma_sqrt_t
|
||||
}
|
||||
|
||||
/// Find the critical spot price S* for American call early exercise using Newton-Raphson.
|
||||
///
|
||||
/// S* satisfies: C(S*) - (S* - K) = (S*/q2) * (1 - e^{-q*T} * N(d1(S*)))
|
||||
/// Rearranged as F(S*) = 0:
|
||||
/// F(x) = C(x) - (x - K) - (x/q2) * (1 - carry_discount * N(d1(x))) = 0
|
||||
fn find_critical_call(
|
||||
strike: f64,
|
||||
rate: f64,
|
||||
carry: f64,
|
||||
time_to_expiry: f64,
|
||||
volatility: f64,
|
||||
q2: f64,
|
||||
) -> f64 {
|
||||
let carry_discount = (-carry * time_to_expiry).exp();
|
||||
|
||||
// Initial guess: S* ≈ K * q2 / (q2 - 1), clamped to be above strike
|
||||
let mut s = if q2 > 1.0 {
|
||||
strike * q2 / (q2 - 1.0)
|
||||
} else {
|
||||
// q2 <= 1 means the denominator is small/negative; fall back to a safe value
|
||||
strike * 2.0
|
||||
};
|
||||
// Ensure starting guess is positive
|
||||
if s <= 0.0 {
|
||||
s = strike * 1.5;
|
||||
}
|
||||
|
||||
for _ in 0..50 {
|
||||
let c = black_scholes_price(
|
||||
s,
|
||||
strike,
|
||||
rate,
|
||||
carry,
|
||||
time_to_expiry,
|
||||
volatility,
|
||||
OptionKind::Call,
|
||||
);
|
||||
let d1 = d1_fn(s, strike, rate, carry, time_to_expiry, volatility);
|
||||
let nd1 = cdf(d1);
|
||||
let lhs = c - (s - strike);
|
||||
let rhs = (s / q2) * (1.0 - carry_discount * nd1);
|
||||
let f = lhs - rhs;
|
||||
|
||||
// Derivative of F with respect to s:
|
||||
// dC/ds = e^{-q*T} * N(d1) (BSM delta for call)
|
||||
// d(s - K)/ds = 1
|
||||
// d(rhs)/ds = (1/q2) * (1 - carry_discount * N(d1))
|
||||
// + (s/q2) * (-carry_discount * phi(d1) / (s * vol * sqrt(T)))
|
||||
// = (1/q2) * (1 - carry_discount * N(d1)) - carry_discount * phi(d1) / (q2 * vol * sqrt(T))
|
||||
let sigma_sqrt_t = volatility * time_to_expiry.sqrt();
|
||||
let phi_d1 = super::normal::pdf(d1);
|
||||
let d_lhs_ds = carry_discount * nd1 - 1.0;
|
||||
let d_rhs_ds = (1.0 / q2) * (1.0 - carry_discount * nd1)
|
||||
- carry_discount * phi_d1 / (q2 * sigma_sqrt_t);
|
||||
let df = d_lhs_ds - d_rhs_ds;
|
||||
|
||||
if df.abs() < 1e-14 {
|
||||
break;
|
||||
}
|
||||
let step = f / df;
|
||||
s -= step;
|
||||
// Keep s positive
|
||||
if s <= 0.0 {
|
||||
s = strike * 0.1;
|
||||
}
|
||||
if step.abs() < 1e-8 {
|
||||
break;
|
||||
}
|
||||
}
|
||||
s
|
||||
}
|
||||
|
||||
/// Find the critical spot price S** for American put early exercise using Newton-Raphson.
|
||||
///
|
||||
/// S** satisfies: P(S**) - (K - S**) = -(S**/q1) * (1 - e^{-q*T} * N(-d1(S**)))
|
||||
/// F(x) = P(x) - (K - x) + (x/q1) * (1 - carry_discount * N(-d1(x))) = 0
|
||||
fn find_critical_put(
|
||||
strike: f64,
|
||||
rate: f64,
|
||||
carry: f64,
|
||||
time_to_expiry: f64,
|
||||
volatility: f64,
|
||||
q1: f64,
|
||||
) -> f64 {
|
||||
let carry_discount = (-carry * time_to_expiry).exp();
|
||||
|
||||
// Initial guess for put: S** ≈ K * q1 / (q1 - 1)
|
||||
// q1 is negative, so q1 - 1 < 0, and the guess should be below strike.
|
||||
let mut s = if (q1 - 1.0).abs() > 1e-10 {
|
||||
strike * q1 / (q1 - 1.0)
|
||||
} else {
|
||||
strike * 0.5
|
||||
};
|
||||
if s <= 0.0 || s >= strike {
|
||||
s = strike * 0.5;
|
||||
}
|
||||
|
||||
for _ in 0..50 {
|
||||
let p = black_scholes_price(
|
||||
s,
|
||||
strike,
|
||||
rate,
|
||||
carry,
|
||||
time_to_expiry,
|
||||
volatility,
|
||||
OptionKind::Put,
|
||||
);
|
||||
let d1 = d1_fn(s, strike, rate, carry, time_to_expiry, volatility);
|
||||
let n_neg_d1 = cdf(-d1);
|
||||
let lhs = p - (strike - s);
|
||||
// rhs = -(s/q1) * (1 - carry_discount * N(-d1))
|
||||
let rhs = -(s / q1) * (1.0 - carry_discount * n_neg_d1);
|
||||
let f = lhs - rhs;
|
||||
|
||||
// Derivative:
|
||||
// dP/ds = -e^{-q*T} * N(-d1) (BSM delta for put = e^{-q*T}*(N(d1)-1))
|
||||
// d(K - s)/ds = -1 so d(lhs)/ds = dP/ds - (-1) = dP/ds + 1
|
||||
// d(rhs)/ds = -(1/q1)*(1 - carry_discount*N(-d1))
|
||||
// + -(s/q1)*carry_discount*phi(d1)/(s*vol*sqrt(T)) [since d(N(-d1))/ds = -phi(d1)*dd1/ds]
|
||||
// = -(1/q1)*(1 - carry_discount*N(-d1))
|
||||
// - carry_discount*phi(d1)/(q1*vol*sqrt(T))
|
||||
let sigma_sqrt_t = volatility * time_to_expiry.sqrt();
|
||||
let phi_d1 = super::normal::pdf(d1);
|
||||
let d_lhs_ds = -carry_discount * n_neg_d1 + 1.0;
|
||||
let d_rhs_ds = -(1.0 / q1) * (1.0 - carry_discount * n_neg_d1)
|
||||
- carry_discount * phi_d1 / (q1 * sigma_sqrt_t);
|
||||
let df = d_lhs_ds - d_rhs_ds;
|
||||
|
||||
if df.abs() < 1e-14 {
|
||||
break;
|
||||
}
|
||||
let step = f / df;
|
||||
s -= step;
|
||||
if s <= 0.0 {
|
||||
s = strike * 0.01;
|
||||
}
|
||||
if s >= strike {
|
||||
s = strike * 0.99;
|
||||
}
|
||||
if step.abs() < 1e-8 {
|
||||
break;
|
||||
}
|
||||
}
|
||||
s
|
||||
}
|
||||
|
||||
/// American option price using the Barone-Adesi-Whaley (1987) quadratic approximation.
|
||||
///
|
||||
/// # Parameters
|
||||
/// - `spot`: current underlying price
|
||||
/// - `strike`: option strike price
|
||||
/// - `rate`: risk-free rate (annualized, decimal)
|
||||
/// - `carry`: continuous dividend yield / carry rate
|
||||
/// - `time_to_expiry`: time to expiry in years
|
||||
/// - `volatility`: implied vol (annualized, decimal)
|
||||
/// - `kind`: call or put
|
||||
pub fn american_price_baw(
|
||||
spot: f64,
|
||||
strike: f64,
|
||||
rate: f64,
|
||||
carry: f64,
|
||||
time_to_expiry: f64,
|
||||
volatility: f64,
|
||||
kind: OptionKind,
|
||||
) -> f64 {
|
||||
if invalid_inputs(spot, strike, time_to_expiry, volatility)
|
||||
|| !rate.is_finite()
|
||||
|| !carry.is_finite()
|
||||
{
|
||||
return f64::NAN;
|
||||
}
|
||||
|
||||
// At expiry: immediate exercise value
|
||||
if time_to_expiry == 0.0 {
|
||||
return match kind {
|
||||
OptionKind::Call => (spot - strike).max(0.0),
|
||||
OptionKind::Put => (strike - spot).max(0.0),
|
||||
};
|
||||
}
|
||||
|
||||
// At zero vol: deterministic — exercise if ITM
|
||||
if volatility == 0.0 {
|
||||
return match kind {
|
||||
OptionKind::Call => (spot - strike).max(0.0),
|
||||
OptionKind::Put => (strike - spot).max(0.0),
|
||||
};
|
||||
}
|
||||
|
||||
let european = black_scholes_price(spot, strike, rate, carry, time_to_expiry, volatility, kind);
|
||||
|
||||
match kind {
|
||||
OptionKind::Call => {
|
||||
// No early exercise premium when there are no dividends (carry == 0 means q==0
|
||||
// in BSM parameterisation where carry = q).
|
||||
if carry <= 0.0 {
|
||||
return european;
|
||||
}
|
||||
|
||||
let sigma2 = volatility * volatility;
|
||||
let m = 2.0 * rate / sigma2;
|
||||
let n = 2.0 * (rate - carry) / sigma2;
|
||||
let h = 1.0 - (-rate * time_to_expiry).exp();
|
||||
|
||||
if h.abs() < 1e-14 {
|
||||
return european;
|
||||
}
|
||||
|
||||
let discriminant = (n - 1.0) * (n - 1.0) + 4.0 * m / h;
|
||||
if discriminant < 0.0 {
|
||||
return european;
|
||||
}
|
||||
|
||||
let q2 = (-(n - 1.0) + discriminant.sqrt()) / 2.0;
|
||||
|
||||
// Find critical price S*
|
||||
let s_star = find_critical_call(strike, rate, carry, time_to_expiry, volatility, q2);
|
||||
|
||||
if s_star <= strike {
|
||||
// Degenerate critical price; fall back to European
|
||||
return european;
|
||||
}
|
||||
|
||||
// A2 = (S*/q2) * (1 - e^{-q*T} * N(d1(S*)))
|
||||
let carry_discount = (-carry * time_to_expiry).exp();
|
||||
let d1_star = d1_fn(s_star, strike, rate, carry, time_to_expiry, volatility);
|
||||
let a2 = (s_star / q2) * (1.0 - carry_discount * cdf(d1_star));
|
||||
|
||||
if spot >= s_star {
|
||||
// Immediate exercise is optimal
|
||||
(spot - strike).max(0.0)
|
||||
} else {
|
||||
(european + a2 * (spot / s_star).powf(q2)).max(european)
|
||||
}
|
||||
}
|
||||
|
||||
OptionKind::Put => {
|
||||
// No early exercise when rate == 0 (no time value of money)
|
||||
if rate <= 0.0 {
|
||||
return european;
|
||||
}
|
||||
|
||||
let sigma2 = volatility * volatility;
|
||||
let m = 2.0 * rate / sigma2;
|
||||
let n = 2.0 * (rate - carry) / sigma2;
|
||||
let h = 1.0 - (-rate * time_to_expiry).exp();
|
||||
|
||||
if h.abs() < 1e-14 {
|
||||
return european;
|
||||
}
|
||||
|
||||
let discriminant = (n - 1.0) * (n - 1.0) + 4.0 * m / h;
|
||||
if discriminant < 0.0 {
|
||||
return european;
|
||||
}
|
||||
|
||||
let q1 = (-(n - 1.0) - discriminant.sqrt()) / 2.0;
|
||||
|
||||
// Find critical price S**
|
||||
let s_star_star =
|
||||
find_critical_put(strike, rate, carry, time_to_expiry, volatility, q1);
|
||||
|
||||
if s_star_star <= 0.0 || s_star_star >= strike {
|
||||
return european;
|
||||
}
|
||||
|
||||
// A1 = -(S**/q1) * (1 - e^{-q*T} * N(-d1(S**)))
|
||||
let carry_discount = (-carry * time_to_expiry).exp();
|
||||
let d1_star = d1_fn(s_star_star, strike, rate, carry, time_to_expiry, volatility);
|
||||
let a1 = -(s_star_star / q1) * (1.0 - carry_discount * cdf(-d1_star));
|
||||
|
||||
if spot <= s_star_star {
|
||||
// Immediate exercise is optimal
|
||||
(strike - spot).max(0.0)
|
||||
} else {
|
||||
(european + a1 * (spot / s_star_star).powf(q1)).max(european)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Early exercise premium = american_price - european_bsm_price.
|
||||
///
|
||||
/// Always non-negative for valid inputs.
|
||||
pub fn early_exercise_premium(
|
||||
spot: f64,
|
||||
strike: f64,
|
||||
rate: f64,
|
||||
carry: f64,
|
||||
time_to_expiry: f64,
|
||||
volatility: f64,
|
||||
kind: OptionKind,
|
||||
) -> f64 {
|
||||
let american = american_price_baw(spot, strike, rate, carry, time_to_expiry, volatility, kind);
|
||||
let european = black_scholes_price(spot, strike, rate, carry, time_to_expiry, volatility, kind);
|
||||
if american.is_nan() || european.is_nan() {
|
||||
return f64::NAN;
|
||||
}
|
||||
(american - european).max(0.0)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::options::OptionKind;
|
||||
|
||||
#[test]
|
||||
fn american_call_gte_european_call() {
|
||||
let european = crate::options::pricing::black_scholes_price(
|
||||
100.0,
|
||||
100.0,
|
||||
0.05,
|
||||
0.03,
|
||||
1.0,
|
||||
0.2,
|
||||
OptionKind::Call,
|
||||
);
|
||||
let american = american_price_baw(100.0, 100.0, 0.05, 0.03, 1.0, 0.2, OptionKind::Call);
|
||||
assert!(american >= european - 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn american_put_gte_european_put() {
|
||||
let european = crate::options::pricing::black_scholes_price(
|
||||
100.0,
|
||||
100.0,
|
||||
0.05,
|
||||
0.0,
|
||||
1.0,
|
||||
0.2,
|
||||
OptionKind::Put,
|
||||
);
|
||||
let american = american_price_baw(100.0, 100.0, 0.05, 0.0, 1.0, 0.2, OptionKind::Put);
|
||||
assert!(american >= european - 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn early_exercise_premium_nonneg() {
|
||||
let prem = early_exercise_premium(100.0, 100.0, 0.05, 0.03, 1.0, 0.2, OptionKind::Call);
|
||||
assert!(prem >= 0.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn american_call_no_dividends_equals_european() {
|
||||
// With no dividends (carry == 0), no early exercise is optimal for calls
|
||||
let european = crate::options::pricing::black_scholes_price(
|
||||
100.0,
|
||||
100.0,
|
||||
0.05,
|
||||
0.0,
|
||||
1.0,
|
||||
0.2,
|
||||
OptionKind::Call,
|
||||
);
|
||||
let american = american_price_baw(100.0, 100.0, 0.05, 0.0, 1.0, 0.2, OptionKind::Call);
|
||||
assert!((american - european).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn american_price_returns_nan_for_invalid() {
|
||||
let price = american_price_baw(-1.0, 100.0, 0.05, 0.0, 1.0, 0.2, OptionKind::Call);
|
||||
assert!(price.is_nan());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn american_price_at_expiry_is_intrinsic() {
|
||||
let call = american_price_baw(110.0, 100.0, 0.05, 0.03, 0.0, 0.2, OptionKind::Call);
|
||||
assert!((call - 10.0).abs() < 1e-10);
|
||||
let put = american_price_baw(90.0, 100.0, 0.05, 0.0, 0.0, 0.2, OptionKind::Put);
|
||||
assert!((put - 10.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn american_put_itm_has_positive_premium() {
|
||||
// Deep ITM put with high rate should have meaningful early exercise premium
|
||||
let prem = early_exercise_premium(80.0, 100.0, 0.10, 0.0, 1.0, 0.2, OptionKind::Put);
|
||||
assert!(prem >= 0.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn american_prices_are_finite_for_valid_inputs() {
|
||||
let call = american_price_baw(100.0, 100.0, 0.05, 0.02, 1.0, 0.25, OptionKind::Call);
|
||||
let put = american_price_baw(100.0, 100.0, 0.05, 0.02, 1.0, 0.25, OptionKind::Put);
|
||||
assert!(call.is_finite());
|
||||
assert!(put.is_finite());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,162 @@
|
||||
//! Option chain analytics helpers.
|
||||
|
||||
use super::greeks::model_greeks;
|
||||
use super::{ChainGreeksContext, OptionContract, OptionEvaluation, OptionKind};
|
||||
|
||||
/// Return the index of the strike closest to the reference price.
|
||||
pub fn atm_index(strikes: &[f64], reference_price: f64) -> Option<usize> {
|
||||
if strikes.is_empty() || !reference_price.is_finite() {
|
||||
return None;
|
||||
}
|
||||
strikes
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter(|(_, strike)| strike.is_finite())
|
||||
.min_by(|(_, a), (_, b)| {
|
||||
(*a - reference_price)
|
||||
.abs()
|
||||
.partial_cmp(&(*b - reference_price).abs())
|
||||
.unwrap_or(std::cmp::Ordering::Equal)
|
||||
})
|
||||
.map(|(idx, _)| idx)
|
||||
}
|
||||
|
||||
/// Label strikes as ITM (1), ATM (0), or OTM (-1).
|
||||
pub fn label_moneyness(strikes: &[f64], reference_price: f64, kind: OptionKind) -> Vec<i8> {
|
||||
let mut labels = Vec::with_capacity(strikes.len());
|
||||
let atm_idx = atm_index(strikes, reference_price);
|
||||
for (idx, &strike) in strikes.iter().enumerate() {
|
||||
if Some(idx) == atm_idx {
|
||||
labels.push(0);
|
||||
continue;
|
||||
}
|
||||
let label = match kind {
|
||||
OptionKind::Call => {
|
||||
if strike < reference_price {
|
||||
1
|
||||
} else {
|
||||
-1
|
||||
}
|
||||
}
|
||||
OptionKind::Put => {
|
||||
if strike > reference_price {
|
||||
1
|
||||
} else {
|
||||
-1
|
||||
}
|
||||
}
|
||||
};
|
||||
labels.push(label);
|
||||
}
|
||||
labels
|
||||
}
|
||||
|
||||
/// Select a strike relative to the ATM strike by offset steps.
|
||||
pub fn select_strike_by_offset(
|
||||
strikes: &[f64],
|
||||
reference_price: f64,
|
||||
offset: isize,
|
||||
) -> Option<f64> {
|
||||
let idx = atm_index(strikes, reference_price)? as isize + offset;
|
||||
if idx < 0 || idx >= strikes.len() as isize {
|
||||
None
|
||||
} else {
|
||||
Some(strikes[idx as usize])
|
||||
}
|
||||
}
|
||||
|
||||
/// Select the strike whose delta is closest to the requested target.
|
||||
pub fn select_strike_by_delta(
|
||||
strikes: &[f64],
|
||||
vols: &[f64],
|
||||
context: ChainGreeksContext,
|
||||
target_delta: f64,
|
||||
) -> Option<f64> {
|
||||
if strikes.len() != vols.len() || strikes.is_empty() {
|
||||
return None;
|
||||
}
|
||||
strikes
|
||||
.iter()
|
||||
.zip(vols.iter())
|
||||
.filter(|(strike, vol)| strike.is_finite() && vol.is_finite())
|
||||
.min_by(|(strike_a, vol_a), (strike_b, vol_b)| {
|
||||
let delta_a = model_greeks(OptionEvaluation {
|
||||
contract: OptionContract {
|
||||
model: context.model,
|
||||
underlying: context.reference_price,
|
||||
strike: **strike_a,
|
||||
rate: context.rate,
|
||||
carry: context.carry,
|
||||
time_to_expiry: context.time_to_expiry,
|
||||
kind: context.kind,
|
||||
},
|
||||
volatility: **vol_a,
|
||||
})
|
||||
.delta;
|
||||
let delta_b = model_greeks(OptionEvaluation {
|
||||
contract: OptionContract {
|
||||
model: context.model,
|
||||
underlying: context.reference_price,
|
||||
strike: **strike_b,
|
||||
rate: context.rate,
|
||||
carry: context.carry,
|
||||
time_to_expiry: context.time_to_expiry,
|
||||
kind: context.kind,
|
||||
},
|
||||
volatility: **vol_b,
|
||||
})
|
||||
.delta;
|
||||
(delta_a - target_delta)
|
||||
.abs()
|
||||
.partial_cmp(&(delta_b - target_delta).abs())
|
||||
.unwrap_or(std::cmp::Ordering::Equal)
|
||||
})
|
||||
.map(|(strike, _)| *strike)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{atm_index, label_moneyness, select_strike_by_delta, select_strike_by_offset};
|
||||
use crate::options::{ChainGreeksContext, OptionKind, PricingModel};
|
||||
|
||||
#[test]
|
||||
fn atm_index_finds_nearest() {
|
||||
let strikes = [90.0, 100.0, 110.0];
|
||||
assert_eq!(atm_index(&strikes, 103.0), Some(1));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn moneyness_labels_calls() {
|
||||
let strikes = [90.0, 100.0, 110.0];
|
||||
assert_eq!(
|
||||
label_moneyness(&strikes, 100.0, OptionKind::Call),
|
||||
vec![1, 0, -1]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn offset_selects_expected_strike() {
|
||||
let strikes = [90.0, 100.0, 110.0];
|
||||
assert_eq!(select_strike_by_offset(&strikes, 101.0, 1), Some(110.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_selection_returns_a_strike() {
|
||||
let strikes = [80.0, 90.0, 100.0, 110.0, 120.0];
|
||||
let vols = [0.28, 0.24, 0.20, 0.22, 0.26];
|
||||
let strike = select_strike_by_delta(
|
||||
&strikes,
|
||||
&vols,
|
||||
ChainGreeksContext {
|
||||
model: PricingModel::BlackScholes,
|
||||
reference_price: 100.0,
|
||||
rate: 0.01,
|
||||
carry: 0.0,
|
||||
time_to_expiry: 0.5,
|
||||
kind: OptionKind::Call,
|
||||
},
|
||||
0.25,
|
||||
);
|
||||
assert!(strike.is_some());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,382 @@
|
||||
//! Digital (binary) option pricing.
|
||||
|
||||
use super::normal::cdf;
|
||||
use super::OptionKind;
|
||||
|
||||
/// Type of digital option payoff.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum DigitalKind {
|
||||
/// Pays 1 unit of cash if option expires in the money.
|
||||
CashOrNothing,
|
||||
/// Pays the underlying asset if option expires in the money.
|
||||
AssetOrNothing,
|
||||
}
|
||||
|
||||
fn invalid_inputs(spot: f64, strike: f64, time_to_expiry: f64, volatility: f64) -> bool {
|
||||
!spot.is_finite()
|
||||
|| !strike.is_finite()
|
||||
|| !time_to_expiry.is_finite()
|
||||
|| !volatility.is_finite()
|
||||
|| spot <= 0.0
|
||||
|| strike <= 0.0
|
||||
|| time_to_expiry < 0.0
|
||||
|| volatility < 0.0
|
||||
}
|
||||
|
||||
/// Price a digital (binary) option under BSM.
|
||||
///
|
||||
/// # Parameters
|
||||
/// - `spot`: current underlying price
|
||||
/// - `strike`: option strike price
|
||||
/// - `rate`: risk-free rate (annualized, decimal)
|
||||
/// - `carry`: continuous dividend yield / carry rate
|
||||
/// - `time_to_expiry`: time to expiry in years
|
||||
/// - `volatility`: implied vol (annualized, decimal)
|
||||
/// - `option_kind`: call or put
|
||||
/// - `digital_kind`: cash-or-nothing or asset-or-nothing
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn digital_price(
|
||||
spot: f64,
|
||||
strike: f64,
|
||||
rate: f64,
|
||||
carry: f64,
|
||||
time_to_expiry: f64,
|
||||
volatility: f64,
|
||||
option_kind: OptionKind,
|
||||
digital_kind: DigitalKind,
|
||||
) -> f64 {
|
||||
if invalid_inputs(spot, strike, time_to_expiry, volatility)
|
||||
|| !rate.is_finite()
|
||||
|| !carry.is_finite()
|
||||
{
|
||||
return f64::NAN;
|
||||
}
|
||||
|
||||
// At expiry: pay intrinsic based on ITM status
|
||||
if time_to_expiry == 0.0 {
|
||||
let itm = match option_kind {
|
||||
OptionKind::Call => spot > strike,
|
||||
OptionKind::Put => spot < strike,
|
||||
};
|
||||
return if itm {
|
||||
match digital_kind {
|
||||
DigitalKind::CashOrNothing => 1.0,
|
||||
DigitalKind::AssetOrNothing => spot,
|
||||
}
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
}
|
||||
|
||||
let discount = (-rate * time_to_expiry).exp();
|
||||
let carry_discount = (-carry * time_to_expiry).exp();
|
||||
|
||||
// At zero vol: deterministic payoff
|
||||
if volatility == 0.0 {
|
||||
let forward = spot * (carry_discount / discount); // S * e^{(r-q)*T} equivalent: S*e^{-q*T}/e^{-r*T}
|
||||
// forward = S * e^{(r-q)*T}; ITM if forward > K for call
|
||||
let itm = match option_kind {
|
||||
OptionKind::Call => spot * carry_discount > strike * discount,
|
||||
OptionKind::Put => spot * carry_discount < strike * discount,
|
||||
};
|
||||
let _ = forward; // suppress unused warning
|
||||
return if itm {
|
||||
match digital_kind {
|
||||
DigitalKind::CashOrNothing => discount,
|
||||
DigitalKind::AssetOrNothing => spot * carry_discount,
|
||||
}
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
}
|
||||
|
||||
let sqrt_t = time_to_expiry.sqrt();
|
||||
let sigma_sqrt_t = volatility * sqrt_t;
|
||||
let d1 = ((spot / strike).ln()
|
||||
+ (rate - carry + 0.5 * volatility * volatility) * time_to_expiry)
|
||||
/ sigma_sqrt_t;
|
||||
let d2 = d1 - sigma_sqrt_t;
|
||||
|
||||
match digital_kind {
|
||||
DigitalKind::CashOrNothing => match option_kind {
|
||||
OptionKind::Call => discount * cdf(d2),
|
||||
OptionKind::Put => discount * cdf(-d2),
|
||||
},
|
||||
DigitalKind::AssetOrNothing => match option_kind {
|
||||
OptionKind::Call => spot * carry_discount * cdf(d1),
|
||||
OptionKind::Put => spot * carry_discount * cdf(-d1),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
/// Compute numerical delta, gamma, and vega for a digital option.
|
||||
///
|
||||
/// Uses central finite differences:
|
||||
/// - delta/gamma: bump spot by ε = spot * 1e-3
|
||||
/// - vega: bump volatility by 1e-3
|
||||
///
|
||||
/// Returns `(delta, gamma, vega)`.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn digital_greeks(
|
||||
spot: f64,
|
||||
strike: f64,
|
||||
rate: f64,
|
||||
carry: f64,
|
||||
time_to_expiry: f64,
|
||||
volatility: f64,
|
||||
option_kind: OptionKind,
|
||||
digital_kind: DigitalKind,
|
||||
) -> (f64, f64, f64) {
|
||||
let eps = spot * 1e-3;
|
||||
if eps <= 0.0 {
|
||||
return (f64::NAN, f64::NAN, f64::NAN);
|
||||
}
|
||||
|
||||
let price_mid = digital_price(
|
||||
spot,
|
||||
strike,
|
||||
rate,
|
||||
carry,
|
||||
time_to_expiry,
|
||||
volatility,
|
||||
option_kind,
|
||||
digital_kind,
|
||||
);
|
||||
let price_up = digital_price(
|
||||
spot + eps,
|
||||
strike,
|
||||
rate,
|
||||
carry,
|
||||
time_to_expiry,
|
||||
volatility,
|
||||
option_kind,
|
||||
digital_kind,
|
||||
);
|
||||
let price_dn = digital_price(
|
||||
spot - eps,
|
||||
strike,
|
||||
rate,
|
||||
carry,
|
||||
time_to_expiry,
|
||||
volatility,
|
||||
option_kind,
|
||||
digital_kind,
|
||||
);
|
||||
|
||||
let delta = (price_up - price_dn) / (2.0 * eps);
|
||||
let gamma = (price_up - 2.0 * price_mid + price_dn) / (eps * eps);
|
||||
|
||||
let vol_bump = 1e-3;
|
||||
let vega = if volatility + vol_bump > 0.0 && volatility - vol_bump > 0.0 {
|
||||
let price_vup = digital_price(
|
||||
spot,
|
||||
strike,
|
||||
rate,
|
||||
carry,
|
||||
time_to_expiry,
|
||||
volatility + vol_bump,
|
||||
option_kind,
|
||||
digital_kind,
|
||||
);
|
||||
let price_vdn = digital_price(
|
||||
spot,
|
||||
strike,
|
||||
rate,
|
||||
carry,
|
||||
time_to_expiry,
|
||||
volatility - vol_bump,
|
||||
option_kind,
|
||||
digital_kind,
|
||||
);
|
||||
(price_vup - price_vdn) / (2.0 * vol_bump)
|
||||
} else {
|
||||
// vol too close to zero; one-sided bump
|
||||
let price_vup = digital_price(
|
||||
spot,
|
||||
strike,
|
||||
rate,
|
||||
carry,
|
||||
time_to_expiry,
|
||||
volatility + vol_bump,
|
||||
option_kind,
|
||||
digital_kind,
|
||||
);
|
||||
(price_vup - price_mid) / vol_bump
|
||||
};
|
||||
|
||||
(delta, gamma, vega)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::options::OptionKind;
|
||||
|
||||
#[test]
|
||||
fn cash_or_nothing_call_atm() {
|
||||
// ATM cash-or-nothing call: price = e^{-rT} * N(d2)
|
||||
// At S=K=100, r=0.05, q=0, T=1, σ=0.2:
|
||||
// d1 = (0 + 0.07) / 0.2 = 0.35, d2 = 0.15 → N(0.15) ≈ 0.5596
|
||||
// price ≈ e^{-0.05} * 0.5596 ≈ 0.532
|
||||
let price = digital_price(
|
||||
100.0,
|
||||
100.0,
|
||||
0.05,
|
||||
0.0,
|
||||
1.0,
|
||||
0.2,
|
||||
OptionKind::Call,
|
||||
DigitalKind::CashOrNothing,
|
||||
);
|
||||
assert!(
|
||||
price > 0.0 && price < 1.0,
|
||||
"price should be between 0 and 1"
|
||||
);
|
||||
assert!((price - 0.532).abs() < 0.01, "price ≈ 0.532, got {price}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn asset_or_nothing_call_at_zero_vol() {
|
||||
// At zero vol, ITM asset-or-nothing call should equal S * e^{-q*T}
|
||||
let price = digital_price(
|
||||
110.0,
|
||||
100.0,
|
||||
0.05,
|
||||
0.0,
|
||||
1.0,
|
||||
0.0,
|
||||
OptionKind::Call,
|
||||
DigitalKind::AssetOrNothing,
|
||||
);
|
||||
assert!((price - 110.0).abs() < 1e-6);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn digital_price_returns_nan_for_invalid() {
|
||||
let price = digital_price(
|
||||
-1.0,
|
||||
100.0,
|
||||
0.05,
|
||||
0.0,
|
||||
1.0,
|
||||
0.2,
|
||||
OptionKind::Call,
|
||||
DigitalKind::CashOrNothing,
|
||||
);
|
||||
assert!(price.is_nan());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cash_or_nothing_put_call_parity() {
|
||||
// Cash-or-nothing call + cash-or-nothing put = e^{-rT}
|
||||
let call = digital_price(
|
||||
100.0,
|
||||
100.0,
|
||||
0.05,
|
||||
0.02,
|
||||
1.0,
|
||||
0.25,
|
||||
OptionKind::Call,
|
||||
DigitalKind::CashOrNothing,
|
||||
);
|
||||
let put = digital_price(
|
||||
100.0,
|
||||
100.0,
|
||||
0.05,
|
||||
0.02,
|
||||
1.0,
|
||||
0.25,
|
||||
OptionKind::Put,
|
||||
DigitalKind::CashOrNothing,
|
||||
);
|
||||
let discount = (-0.05_f64).exp();
|
||||
assert!((call + put - discount).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn asset_or_nothing_put_call_parity() {
|
||||
// Asset-or-nothing call + asset-or-nothing put = S * e^{-q*T}
|
||||
let s = 100.0_f64;
|
||||
let q = 0.02_f64;
|
||||
let call = digital_price(
|
||||
s,
|
||||
100.0,
|
||||
0.05,
|
||||
q,
|
||||
1.0,
|
||||
0.25,
|
||||
OptionKind::Call,
|
||||
DigitalKind::AssetOrNothing,
|
||||
);
|
||||
let put = digital_price(
|
||||
s,
|
||||
100.0,
|
||||
0.05,
|
||||
q,
|
||||
1.0,
|
||||
0.25,
|
||||
OptionKind::Put,
|
||||
DigitalKind::AssetOrNothing,
|
||||
);
|
||||
let expected = s * (-q).exp();
|
||||
assert!((call + put - expected).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn digital_greeks_are_finite_for_valid_inputs() {
|
||||
let (delta, gamma, vega) = digital_greeks(
|
||||
100.0,
|
||||
100.0,
|
||||
0.05,
|
||||
0.0,
|
||||
1.0,
|
||||
0.2,
|
||||
OptionKind::Call,
|
||||
DigitalKind::CashOrNothing,
|
||||
);
|
||||
assert!(delta.is_finite());
|
||||
assert!(gamma.is_finite());
|
||||
assert!(vega.is_finite());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn digital_at_expiry_itm_returns_intrinsic() {
|
||||
let price = digital_price(
|
||||
110.0,
|
||||
100.0,
|
||||
0.05,
|
||||
0.0,
|
||||
0.0,
|
||||
0.2,
|
||||
OptionKind::Call,
|
||||
DigitalKind::CashOrNothing,
|
||||
);
|
||||
assert!((price - 1.0).abs() < 1e-10);
|
||||
let price2 = digital_price(
|
||||
110.0,
|
||||
100.0,
|
||||
0.05,
|
||||
0.0,
|
||||
0.0,
|
||||
0.2,
|
||||
OptionKind::Call,
|
||||
DigitalKind::AssetOrNothing,
|
||||
);
|
||||
assert!((price2 - 110.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn digital_at_expiry_otm_returns_zero() {
|
||||
let price = digital_price(
|
||||
90.0,
|
||||
100.0,
|
||||
0.05,
|
||||
0.0,
|
||||
0.0,
|
||||
0.2,
|
||||
OptionKind::Call,
|
||||
DigitalKind::CashOrNothing,
|
||||
);
|
||||
assert!((price - 0.0).abs() < 1e-10);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,327 @@
|
||||
//! Option Greeks.
|
||||
|
||||
use super::normal::{cdf, pdf};
|
||||
use super::pricing::{black_76_price, black_scholes_price};
|
||||
use super::{ExtendedGreeks, Greeks, OptionEvaluation, OptionKind, PricingModel};
|
||||
|
||||
fn bs_inputs_valid(
|
||||
underlying: f64,
|
||||
strike: f64,
|
||||
rate: f64,
|
||||
carry: f64,
|
||||
time_to_expiry: f64,
|
||||
volatility: f64,
|
||||
) -> bool {
|
||||
underlying.is_finite()
|
||||
&& strike.is_finite()
|
||||
&& rate.is_finite()
|
||||
&& carry.is_finite()
|
||||
&& time_to_expiry.is_finite()
|
||||
&& volatility.is_finite()
|
||||
&& underlying > 0.0
|
||||
&& strike > 0.0
|
||||
&& time_to_expiry > 0.0
|
||||
&& volatility > 0.0
|
||||
}
|
||||
|
||||
fn numerical_theta<F>(time_to_expiry: f64, price_fn: F) -> f64
|
||||
where
|
||||
F: Fn(f64) -> f64,
|
||||
{
|
||||
if time_to_expiry <= 0.0 {
|
||||
return 0.0;
|
||||
}
|
||||
let h = time_to_expiry.clamp(1e-6, 1.0 / 365.0);
|
||||
let t_minus = (time_to_expiry - h).max(1e-8);
|
||||
let t_plus = time_to_expiry + h;
|
||||
let price_minus = price_fn(t_minus);
|
||||
let price_plus = price_fn(t_plus);
|
||||
(price_minus - price_plus) / (t_plus - t_minus)
|
||||
}
|
||||
|
||||
/// Black-Scholes-Merton Greeks.
|
||||
pub fn black_scholes_greeks(
|
||||
spot: f64,
|
||||
strike: f64,
|
||||
rate: f64,
|
||||
dividend_yield: f64,
|
||||
time_to_expiry: f64,
|
||||
volatility: f64,
|
||||
kind: OptionKind,
|
||||
) -> Greeks {
|
||||
if !bs_inputs_valid(
|
||||
spot,
|
||||
strike,
|
||||
rate,
|
||||
dividend_yield,
|
||||
time_to_expiry,
|
||||
volatility,
|
||||
) {
|
||||
return Greeks {
|
||||
delta: f64::NAN,
|
||||
gamma: f64::NAN,
|
||||
vega: f64::NAN,
|
||||
theta: f64::NAN,
|
||||
rho: f64::NAN,
|
||||
};
|
||||
}
|
||||
|
||||
let sqrt_t = time_to_expiry.sqrt();
|
||||
let sigma_sqrt_t = volatility * sqrt_t;
|
||||
let discount = (-rate * time_to_expiry).exp();
|
||||
let carry_discount = (-dividend_yield * time_to_expiry).exp();
|
||||
let d1 = ((spot / strike).ln()
|
||||
+ (rate - dividend_yield + 0.5 * volatility * volatility) * time_to_expiry)
|
||||
/ sigma_sqrt_t;
|
||||
let d2 = d1 - sigma_sqrt_t;
|
||||
let pdf_d1 = pdf(d1);
|
||||
|
||||
let delta = match kind {
|
||||
OptionKind::Call => carry_discount * cdf(d1),
|
||||
OptionKind::Put => carry_discount * (cdf(d1) - 1.0),
|
||||
};
|
||||
let gamma = carry_discount * pdf_d1 / (spot * sigma_sqrt_t);
|
||||
let vega = spot * carry_discount * pdf_d1 * sqrt_t;
|
||||
let theta = match kind {
|
||||
OptionKind::Call => {
|
||||
-(spot * carry_discount * pdf_d1 * volatility) / (2.0 * sqrt_t)
|
||||
- rate * strike * discount * cdf(d2)
|
||||
+ dividend_yield * spot * carry_discount * cdf(d1)
|
||||
}
|
||||
OptionKind::Put => {
|
||||
-(spot * carry_discount * pdf_d1 * volatility) / (2.0 * sqrt_t)
|
||||
+ rate * strike * discount * cdf(-d2)
|
||||
- dividend_yield * spot * carry_discount * cdf(-d1)
|
||||
}
|
||||
};
|
||||
let rho = match kind {
|
||||
OptionKind::Call => strike * time_to_expiry * discount * cdf(d2),
|
||||
OptionKind::Put => -strike * time_to_expiry * discount * cdf(-d2),
|
||||
};
|
||||
|
||||
Greeks {
|
||||
delta,
|
||||
gamma,
|
||||
vega,
|
||||
theta,
|
||||
rho,
|
||||
}
|
||||
}
|
||||
|
||||
/// Black-76 Greeks with respect to the forward.
|
||||
pub fn black_76_greeks(
|
||||
forward: f64,
|
||||
strike: f64,
|
||||
rate: f64,
|
||||
time_to_expiry: f64,
|
||||
volatility: f64,
|
||||
kind: OptionKind,
|
||||
) -> Greeks {
|
||||
if !bs_inputs_valid(forward, strike, rate, 0.0, time_to_expiry, volatility) {
|
||||
return Greeks {
|
||||
delta: f64::NAN,
|
||||
gamma: f64::NAN,
|
||||
vega: f64::NAN,
|
||||
theta: f64::NAN,
|
||||
rho: f64::NAN,
|
||||
};
|
||||
}
|
||||
|
||||
let sqrt_t = time_to_expiry.sqrt();
|
||||
let sigma_sqrt_t = volatility * sqrt_t;
|
||||
let discount = (-rate * time_to_expiry).exp();
|
||||
let d1 =
|
||||
((forward / strike).ln() + 0.5 * volatility * volatility * time_to_expiry) / sigma_sqrt_t;
|
||||
let pdf_d1 = pdf(d1);
|
||||
|
||||
let delta = match kind {
|
||||
OptionKind::Call => discount * cdf(d1),
|
||||
OptionKind::Put => -discount * cdf(-d1),
|
||||
};
|
||||
let gamma = discount * pdf_d1 / (forward * sigma_sqrt_t);
|
||||
let vega = discount * forward * pdf_d1 * sqrt_t;
|
||||
let theta = numerical_theta(time_to_expiry, |t| {
|
||||
black_76_price(forward, strike, rate, t, volatility, kind)
|
||||
});
|
||||
let rho =
|
||||
-time_to_expiry * black_76_price(forward, strike, rate, time_to_expiry, volatility, kind);
|
||||
|
||||
Greeks {
|
||||
delta,
|
||||
gamma,
|
||||
vega,
|
||||
theta,
|
||||
rho,
|
||||
}
|
||||
}
|
||||
|
||||
/// Model-dispatched Greeks.
|
||||
pub fn model_greeks(input: OptionEvaluation) -> Greeks {
|
||||
let contract = input.contract;
|
||||
match contract.model {
|
||||
PricingModel::BlackScholes => black_scholes_greeks(
|
||||
contract.underlying,
|
||||
contract.strike,
|
||||
contract.rate,
|
||||
contract.carry,
|
||||
contract.time_to_expiry,
|
||||
input.volatility,
|
||||
contract.kind,
|
||||
),
|
||||
PricingModel::Black76 => black_76_greeks(
|
||||
contract.underlying,
|
||||
contract.strike,
|
||||
contract.rate,
|
||||
contract.time_to_expiry,
|
||||
input.volatility,
|
||||
contract.kind,
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
/// Price derivative with respect to calendar time using the selected model.
|
||||
pub fn model_theta(input: OptionEvaluation) -> f64 {
|
||||
let contract = input.contract;
|
||||
numerical_theta(contract.time_to_expiry, |t| match contract.model {
|
||||
PricingModel::BlackScholes => black_scholes_price(
|
||||
contract.underlying,
|
||||
contract.strike,
|
||||
contract.rate,
|
||||
contract.carry,
|
||||
t,
|
||||
input.volatility,
|
||||
contract.kind,
|
||||
),
|
||||
PricingModel::Black76 => black_76_price(
|
||||
contract.underlying,
|
||||
contract.strike,
|
||||
contract.rate,
|
||||
t,
|
||||
input.volatility,
|
||||
contract.kind,
|
||||
),
|
||||
})
|
||||
}
|
||||
|
||||
/// Extended Greeks under Black-Scholes-Merton (closed-form).
|
||||
///
|
||||
/// All inputs must be positive finite; returns NaN fields for invalid inputs.
|
||||
pub fn black_scholes_extended_greeks(
|
||||
spot: f64,
|
||||
strike: f64,
|
||||
rate: f64,
|
||||
dividend_yield: f64,
|
||||
time_to_expiry: f64,
|
||||
volatility: f64,
|
||||
_kind: OptionKind,
|
||||
) -> ExtendedGreeks {
|
||||
if !bs_inputs_valid(
|
||||
spot,
|
||||
strike,
|
||||
rate,
|
||||
dividend_yield,
|
||||
time_to_expiry,
|
||||
volatility,
|
||||
) {
|
||||
return ExtendedGreeks {
|
||||
vanna: f64::NAN,
|
||||
volga: f64::NAN,
|
||||
charm: f64::NAN,
|
||||
speed: f64::NAN,
|
||||
color: f64::NAN,
|
||||
};
|
||||
}
|
||||
|
||||
let sqrt_t = time_to_expiry.sqrt();
|
||||
let sigma_sqrt_t = volatility * sqrt_t;
|
||||
let carry_discount = (-dividend_yield * time_to_expiry).exp();
|
||||
let d1 = ((spot / strike).ln()
|
||||
+ (rate - dividend_yield + 0.5 * volatility * volatility) * time_to_expiry)
|
||||
/ sigma_sqrt_t;
|
||||
let d2 = d1 - sigma_sqrt_t;
|
||||
let pdf_d1 = pdf(d1);
|
||||
|
||||
let gamma = carry_discount * pdf_d1 / (spot * sigma_sqrt_t);
|
||||
|
||||
let vanna = -carry_discount * pdf_d1 * d2 / volatility;
|
||||
let volga = spot * carry_discount * pdf_d1 * sqrt_t * d1 * d2 / volatility;
|
||||
let charm = -carry_discount
|
||||
* pdf_d1
|
||||
* (2.0 * (rate - dividend_yield) * time_to_expiry - d2 * sigma_sqrt_t)
|
||||
/ (2.0 * time_to_expiry * sigma_sqrt_t);
|
||||
let speed = -gamma / spot * (d1 / sigma_sqrt_t + 1.0);
|
||||
let color = -carry_discount * pdf_d1 / (2.0 * spot * time_to_expiry * sigma_sqrt_t)
|
||||
* (2.0 * (rate - dividend_yield) * time_to_expiry + 1.0
|
||||
- d1 * (2.0 * (rate - dividend_yield) * time_to_expiry - d2 * sigma_sqrt_t)
|
||||
/ sigma_sqrt_t);
|
||||
|
||||
ExtendedGreeks {
|
||||
vanna,
|
||||
volga,
|
||||
charm,
|
||||
speed,
|
||||
color,
|
||||
}
|
||||
}
|
||||
|
||||
/// Model-dispatched extended Greeks.
|
||||
/// Only BSM is supported with closed-form; Black-76 is not yet supported (returns NaN).
|
||||
pub fn model_extended_greeks(input: OptionEvaluation) -> ExtendedGreeks {
|
||||
let contract = input.contract;
|
||||
match contract.model {
|
||||
PricingModel::BlackScholes => black_scholes_extended_greeks(
|
||||
contract.underlying,
|
||||
contract.strike,
|
||||
contract.rate,
|
||||
contract.carry,
|
||||
contract.time_to_expiry,
|
||||
input.volatility,
|
||||
contract.kind,
|
||||
),
|
||||
PricingModel::Black76 => ExtendedGreeks {
|
||||
vanna: f64::NAN,
|
||||
volga: f64::NAN,
|
||||
charm: f64::NAN,
|
||||
speed: f64::NAN,
|
||||
color: f64::NAN,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{black_76_greeks, black_scholes_extended_greeks, black_scholes_greeks};
|
||||
use crate::options::OptionKind;
|
||||
|
||||
#[test]
|
||||
fn bsm_greeks_are_finite() {
|
||||
let g = black_scholes_greeks(100.0, 100.0, 0.05, 0.0, 1.0, 0.2, OptionKind::Call);
|
||||
assert!(g.delta.is_finite());
|
||||
assert!(g.gamma.is_finite());
|
||||
assert!(g.vega.is_finite());
|
||||
assert!(g.theta.is_finite());
|
||||
assert!(g.rho.is_finite());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn black_76_greeks_are_finite() {
|
||||
let g = black_76_greeks(100.0, 100.0, 0.03, 1.0, 0.2, OptionKind::Put);
|
||||
assert!(g.delta.is_finite());
|
||||
assert!(g.gamma.is_finite());
|
||||
assert!(g.vega.is_finite());
|
||||
assert!(g.theta.is_finite());
|
||||
assert!(g.rho.is_finite());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn extended_greeks_finite_for_valid_inputs() {
|
||||
let eg = black_scholes_extended_greeks(100.0, 100.0, 0.05, 0.0, 1.0, 0.2, OptionKind::Call);
|
||||
assert!(eg.vanna.is_finite());
|
||||
assert!(eg.volga.is_finite());
|
||||
assert!(eg.charm.is_finite());
|
||||
assert!(eg.speed.is_finite());
|
||||
assert!(eg.color.is_finite());
|
||||
// Volga must be positive (convex in vol)
|
||||
assert!(eg.volga >= 0.0);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,241 @@
|
||||
//! Implied volatility inversion and IV-series helpers.
|
||||
|
||||
use super::greeks::model_greeks;
|
||||
use super::pricing::{model_price, price_lower_bound, price_upper_bound};
|
||||
use super::{IvSolverConfig, OptionContract, OptionEvaluation};
|
||||
|
||||
/// Solve implied volatility with guarded Newton iterations and bisection fallback.
|
||||
pub fn implied_volatility(
|
||||
contract: OptionContract,
|
||||
target_price: f64,
|
||||
config: IvSolverConfig,
|
||||
) -> f64 {
|
||||
if !target_price.is_finite()
|
||||
|| !contract.underlying.is_finite()
|
||||
|| !contract.strike.is_finite()
|
||||
|| !contract.rate.is_finite()
|
||||
|| !contract.carry.is_finite()
|
||||
|| !contract.time_to_expiry.is_finite()
|
||||
|| target_price < 0.0
|
||||
|| contract.underlying <= 0.0
|
||||
|| contract.strike <= 0.0
|
||||
|| contract.time_to_expiry < 0.0
|
||||
{
|
||||
return f64::NAN;
|
||||
}
|
||||
if contract.time_to_expiry == 0.0 {
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
let lower = price_lower_bound(contract);
|
||||
let upper = price_upper_bound(contract);
|
||||
if target_price < lower - config.tolerance || target_price > upper + config.tolerance {
|
||||
return f64::NAN;
|
||||
}
|
||||
if (target_price - lower).abs() <= config.tolerance {
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
let mut low_vol = 1e-9;
|
||||
let mut high_vol = config.initial_guess.max(0.25).max(low_vol * 10.0);
|
||||
let mut high_price = model_price(OptionEvaluation {
|
||||
contract,
|
||||
volatility: high_vol,
|
||||
});
|
||||
while high_price < target_price && high_vol < 10.0 {
|
||||
high_vol *= 2.0;
|
||||
high_price = model_price(OptionEvaluation {
|
||||
contract,
|
||||
volatility: high_vol,
|
||||
});
|
||||
}
|
||||
if high_price < target_price {
|
||||
return f64::NAN;
|
||||
}
|
||||
|
||||
let mut vol = config.initial_guess.clamp(low_vol, high_vol).max(1e-4);
|
||||
for _ in 0..config.max_iterations.max(1) {
|
||||
let price = model_price(OptionEvaluation {
|
||||
contract,
|
||||
volatility: vol,
|
||||
});
|
||||
let diff = price - target_price;
|
||||
if diff.abs() <= config.tolerance {
|
||||
return vol;
|
||||
}
|
||||
|
||||
if diff > 0.0 {
|
||||
high_vol = high_vol.min(vol);
|
||||
} else {
|
||||
low_vol = low_vol.max(vol);
|
||||
}
|
||||
|
||||
let vega = model_greeks(OptionEvaluation {
|
||||
contract,
|
||||
volatility: vol,
|
||||
})
|
||||
.vega;
|
||||
|
||||
let next = if vega.is_finite() && vega.abs() > 1e-10 {
|
||||
let candidate = vol - diff / vega;
|
||||
if candidate > low_vol && candidate < high_vol {
|
||||
candidate
|
||||
} else {
|
||||
0.5 * (low_vol + high_vol)
|
||||
}
|
||||
} else {
|
||||
0.5 * (low_vol + high_vol)
|
||||
};
|
||||
vol = next;
|
||||
}
|
||||
|
||||
let final_price = model_price(OptionEvaluation {
|
||||
contract,
|
||||
volatility: vol,
|
||||
});
|
||||
if (final_price - target_price).abs() <= config.tolerance * 10.0 {
|
||||
vol
|
||||
} else {
|
||||
f64::NAN
|
||||
}
|
||||
}
|
||||
|
||||
fn validate_window(window: usize) -> bool {
|
||||
window >= 1
|
||||
}
|
||||
|
||||
/// Rolling IV rank.
|
||||
pub fn iv_rank(iv_series: &[f64], window: usize) -> Vec<f64> {
|
||||
let n = iv_series.len();
|
||||
let mut out = vec![f64::NAN; n];
|
||||
if !validate_window(window) || n < window {
|
||||
return out;
|
||||
}
|
||||
|
||||
for end in (window - 1)..n {
|
||||
let start = end + 1 - window;
|
||||
let mut min_v = f64::INFINITY;
|
||||
let mut max_v = f64::NEG_INFINITY;
|
||||
for &v in &iv_series[start..=end] {
|
||||
if v.is_finite() {
|
||||
min_v = min_v.min(v);
|
||||
max_v = max_v.max(v);
|
||||
}
|
||||
}
|
||||
let current = iv_series[end];
|
||||
if !current.is_finite() || !min_v.is_finite() || !max_v.is_finite() {
|
||||
out[end] = f64::NAN;
|
||||
continue;
|
||||
}
|
||||
let spread = max_v - min_v;
|
||||
out[end] = if spread == 0.0 {
|
||||
0.0
|
||||
} else {
|
||||
(current - min_v) / spread
|
||||
};
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Rolling IV percentile.
|
||||
pub fn iv_percentile(iv_series: &[f64], window: usize) -> Vec<f64> {
|
||||
let n = iv_series.len();
|
||||
let mut out = vec![f64::NAN; n];
|
||||
if !validate_window(window) || n < window {
|
||||
return out;
|
||||
}
|
||||
|
||||
for end in (window - 1)..n {
|
||||
let start = end + 1 - window;
|
||||
let current = iv_series[end];
|
||||
let count = iv_series[start..=end]
|
||||
.iter()
|
||||
.filter(|&&v| v <= current)
|
||||
.count();
|
||||
out[end] = count as f64 / window as f64;
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Rolling IV z-score.
|
||||
pub fn iv_zscore(iv_series: &[f64], window: usize) -> Vec<f64> {
|
||||
let n = iv_series.len();
|
||||
let mut out = vec![f64::NAN; n];
|
||||
if !validate_window(window) || n < window {
|
||||
return out;
|
||||
}
|
||||
|
||||
for end in (window - 1)..n {
|
||||
let start = end + 1 - window;
|
||||
let mut count = 0usize;
|
||||
let mut sum = 0.0;
|
||||
for &v in &iv_series[start..=end] {
|
||||
if v.is_finite() {
|
||||
count += 1;
|
||||
sum += v;
|
||||
}
|
||||
}
|
||||
if count == 0 {
|
||||
out[end] = f64::NAN;
|
||||
continue;
|
||||
}
|
||||
let mean = sum / count as f64;
|
||||
let mut var = 0.0;
|
||||
for &v in &iv_series[start..=end] {
|
||||
if v.is_finite() {
|
||||
let d = v - mean;
|
||||
var += d * d;
|
||||
}
|
||||
}
|
||||
let std = (var / count as f64).sqrt();
|
||||
let current = iv_series[end];
|
||||
out[end] = if !current.is_finite() || std == 0.0 {
|
||||
f64::NAN
|
||||
} else {
|
||||
(current - mean) / std
|
||||
};
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{implied_volatility, iv_percentile, iv_rank, iv_zscore};
|
||||
use crate::options::pricing::black_scholes_price;
|
||||
use crate::options::{IvSolverConfig, OptionContract, OptionKind, PricingModel};
|
||||
|
||||
#[test]
|
||||
fn solver_recovers_input_vol() {
|
||||
let price = black_scholes_price(100.0, 100.0, 0.05, 0.0, 1.0, 0.2, OptionKind::Call);
|
||||
let iv = implied_volatility(
|
||||
OptionContract {
|
||||
model: PricingModel::BlackScholes,
|
||||
underlying: 100.0,
|
||||
strike: 100.0,
|
||||
rate: 0.05,
|
||||
carry: 0.0,
|
||||
time_to_expiry: 1.0,
|
||||
kind: OptionKind::Call,
|
||||
},
|
||||
price,
|
||||
IvSolverConfig {
|
||||
initial_guess: 0.3,
|
||||
tolerance: 1e-8,
|
||||
max_iterations: 100,
|
||||
},
|
||||
);
|
||||
assert!((iv - 0.2).abs() < 1e-6);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn iv_helpers_match_expected_values() {
|
||||
let iv = [10.0, 20.0, 30.0, 15.0, 22.0];
|
||||
let rank = iv_rank(&iv, 3);
|
||||
let pct = iv_percentile(&iv, 3);
|
||||
let z = iv_zscore(&iv, 3);
|
||||
assert!(rank[0].is_nan() && rank[1].is_nan());
|
||||
assert!((rank[2] - 1.0).abs() < 1e-12);
|
||||
assert!((pct[3] - (1.0 / 3.0)).abs() < 1e-12);
|
||||
assert!((z[2] - 1.224_744_871).abs() < 1e-6);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,102 @@
|
||||
//! Options analytics core.
|
||||
//!
|
||||
//! This module contains pricing, Greeks, implied volatility inversion,
|
||||
//! IV-series helpers, and smile/chain utilities. The public API is scalar-first
|
||||
//! and is used by the PyO3 bridge to build vectorized batch functions.
|
||||
|
||||
pub mod american;
|
||||
pub mod chain;
|
||||
pub mod digital;
|
||||
pub mod greeks;
|
||||
pub mod iv;
|
||||
pub mod normal;
|
||||
pub mod payoff;
|
||||
pub mod pricing;
|
||||
pub mod realized_vol;
|
||||
pub mod surface;
|
||||
|
||||
/// Option side.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum OptionKind {
|
||||
/// Call option.
|
||||
Call,
|
||||
/// Put option.
|
||||
Put,
|
||||
}
|
||||
|
||||
impl OptionKind {
|
||||
/// Returns +1 for calls and -1 for puts.
|
||||
pub fn sign(self) -> f64 {
|
||||
match self {
|
||||
Self::Call => 1.0,
|
||||
Self::Put => -1.0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Supported pricing models.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum PricingModel {
|
||||
/// Black-Scholes-Merton with continuous carry/dividend yield.
|
||||
BlackScholes,
|
||||
/// Black-76 using the forward price as the underlying input.
|
||||
Black76,
|
||||
}
|
||||
|
||||
/// Primary first-order Greeks returned by the pricing engine.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub struct Greeks {
|
||||
pub delta: f64,
|
||||
pub gamma: f64,
|
||||
pub vega: f64,
|
||||
pub theta: f64,
|
||||
pub rho: f64,
|
||||
}
|
||||
|
||||
/// Second-order and cross Greeks.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub struct ExtendedGreeks {
|
||||
pub vanna: f64, // ∂Δ/∂σ
|
||||
pub volga: f64, // ∂²V/∂σ² (vomma)
|
||||
pub charm: f64, // ∂Δ/∂t
|
||||
pub speed: f64, // ∂Γ/∂S
|
||||
pub color: f64, // ∂Γ/∂t
|
||||
}
|
||||
|
||||
/// Shared contract fields for model-based option analytics.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub struct OptionContract {
|
||||
pub model: PricingModel,
|
||||
pub underlying: f64,
|
||||
pub strike: f64,
|
||||
pub rate: f64,
|
||||
pub carry: f64,
|
||||
pub time_to_expiry: f64,
|
||||
pub kind: OptionKind,
|
||||
}
|
||||
|
||||
/// Contract plus volatility for pricing and Greeks.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub struct OptionEvaluation {
|
||||
pub contract: OptionContract,
|
||||
pub volatility: f64,
|
||||
}
|
||||
|
||||
/// Solver configuration for implied volatility inversion.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub struct IvSolverConfig {
|
||||
pub initial_guess: f64,
|
||||
pub tolerance: f64,
|
||||
pub max_iterations: usize,
|
||||
}
|
||||
|
||||
/// Shared context for strike selection and smile analytics.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub struct ChainGreeksContext {
|
||||
pub model: PricingModel,
|
||||
pub reference_price: f64,
|
||||
pub rate: f64,
|
||||
pub carry: f64,
|
||||
pub time_to_expiry: f64,
|
||||
pub kind: OptionKind,
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
//! Normal distribution helpers.
|
||||
|
||||
const INV_SQRT_2PI: f64 = 0.398_942_280_401_432_7;
|
||||
|
||||
/// Standard normal probability density function.
|
||||
pub fn pdf(x: f64) -> f64 {
|
||||
INV_SQRT_2PI * (-0.5 * x * x).exp()
|
||||
}
|
||||
|
||||
/// Standard normal cumulative distribution function.
|
||||
///
|
||||
/// Uses a common Abramowitz-Stegun style approximation that is fast and
|
||||
/// sufficiently accurate for option pricing work.
|
||||
pub fn cdf(x: f64) -> f64 {
|
||||
let ax = x.abs();
|
||||
let t = 1.0 / (1.0 + 0.231_641_9 * ax);
|
||||
let poly = (((((1.330_274_429 * t - 1.821_255_978) * t) + 1.781_477_937) * t - 0.356_563_782)
|
||||
* t
|
||||
+ 0.319_381_530)
|
||||
* t;
|
||||
let approx = 1.0 - pdf(ax) * poly;
|
||||
if x >= 0.0 {
|
||||
approx
|
||||
} else {
|
||||
1.0 - approx
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{cdf, pdf};
|
||||
|
||||
#[test]
|
||||
fn cdf_is_reasonable() {
|
||||
assert!((cdf(0.0) - 0.5).abs() < 1e-7);
|
||||
assert!((cdf(1.0) - 0.841_344_746).abs() < 5e-5);
|
||||
assert!((cdf(-1.0) - 0.158_655_254).abs() < 5e-5);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pdf_is_reasonable() {
|
||||
assert!((pdf(0.0) - 0.398_942_280_4).abs() < 1e-10);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,392 @@
|
||||
//! Pure-Rust (no PyO3, no numpy) strategy payoff and value functions.
|
||||
//!
|
||||
//! NOTE: `crates/ferro_ta_core/src/options/mod.rs` must declare `pub mod payoff;`
|
||||
//! for this module to be reachable from the rest of the crate and from the PyO3 bridge.
|
||||
|
||||
use super::pricing::black_scholes_price;
|
||||
use super::OptionKind;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Internal helpers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Instrument codes: 0=option, 1=future, 2=stock.
|
||||
const INSTRUMENT_OPTION: i64 = 0;
|
||||
const INSTRUMENT_FUTURE: i64 = 1;
|
||||
const INSTRUMENT_STOCK: i64 = 2;
|
||||
|
||||
/// Side sign from encoded value: 1=long (+1.0), -1=short (-1.0).
|
||||
#[inline]
|
||||
fn side_sign(v: i64) -> f64 {
|
||||
if v == 1 {
|
||||
1.0
|
||||
} else if v == -1 {
|
||||
-1.0
|
||||
} else {
|
||||
f64::NAN
|
||||
}
|
||||
}
|
||||
|
||||
/// Option kind from encoded value: 1=call, -1=put.
|
||||
#[inline]
|
||||
fn option_kind(v: i64) -> Option<OptionKind> {
|
||||
match v {
|
||||
1 => Some(OptionKind::Call),
|
||||
-1 => Some(OptionKind::Put),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// strategy_payoff_dense
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Aggregate strategy payoff over a spot grid.
|
||||
///
|
||||
/// Parameters (all slices of length n_legs):
|
||||
/// - `instruments`: 0=option, 1=future, 2=stock
|
||||
/// - `sides`: 1=long, -1=short
|
||||
/// - `option_types`: 1=call, -1=put (ignored for futures/stocks)
|
||||
/// - `strikes`: strike for options
|
||||
/// - `premiums`: premium for options
|
||||
/// - `entry_prices`: entry price for futures/stocks
|
||||
/// - `quantities`, `multipliers`: applied to all instruments
|
||||
///
|
||||
/// Returns a Vec<f64> of length spot_grid.len() with aggregate P&L per spot point.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn strategy_payoff_dense(
|
||||
spot_grid: &[f64],
|
||||
instruments: &[i64],
|
||||
sides: &[i64],
|
||||
option_types: &[i64],
|
||||
strikes: &[f64],
|
||||
premiums: &[f64],
|
||||
entry_prices: &[f64],
|
||||
quantities: &[f64],
|
||||
multipliers: &[f64],
|
||||
) -> Vec<f64> {
|
||||
let n_legs = instruments.len();
|
||||
// Validate that all leg slices are the same length; return zeros if not.
|
||||
if sides.len() != n_legs
|
||||
|| option_types.len() != n_legs
|
||||
|| strikes.len() != n_legs
|
||||
|| premiums.len() != n_legs
|
||||
|| entry_prices.len() != n_legs
|
||||
|| quantities.len() != n_legs
|
||||
|| multipliers.len() != n_legs
|
||||
{
|
||||
return vec![0.0; spot_grid.len()];
|
||||
}
|
||||
|
||||
let mut total = vec![0.0_f64; spot_grid.len()];
|
||||
|
||||
for leg_idx in 0..n_legs {
|
||||
let inst = instruments[leg_idx];
|
||||
let sign = side_sign(sides[leg_idx]);
|
||||
if sign.is_nan() {
|
||||
// Invalid side — skip leg (treat as zero contribution).
|
||||
continue;
|
||||
}
|
||||
let leg_scale = sign * quantities[leg_idx] * multipliers[leg_idx];
|
||||
|
||||
match inst {
|
||||
INSTRUMENT_OPTION => {
|
||||
let kind = match option_kind(option_types[leg_idx]) {
|
||||
Some(k) => k,
|
||||
None => continue, // Invalid option type — skip.
|
||||
};
|
||||
let k = strikes[leg_idx];
|
||||
let p = premiums[leg_idx];
|
||||
for (i, &s) in spot_grid.iter().enumerate() {
|
||||
let intrinsic = match kind {
|
||||
OptionKind::Call => (s - k).max(0.0),
|
||||
OptionKind::Put => (k - s).max(0.0),
|
||||
};
|
||||
total[i] += leg_scale * (intrinsic - p);
|
||||
}
|
||||
}
|
||||
INSTRUMENT_FUTURE | INSTRUMENT_STOCK => {
|
||||
let e = entry_prices[leg_idx];
|
||||
for (i, &s) in spot_grid.iter().enumerate() {
|
||||
total[i] += leg_scale * (s - e);
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
// Unknown instrument code — skip leg (NaN would propagate; zeros are safer).
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
total
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// strategy_value_dense / strategy_value_grid
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Current BSM value of a strategy at a single spot (pre-expiry).
|
||||
///
|
||||
/// Unlike `strategy_payoff_dense`, this uses BSM pricing for option legs rather
|
||||
/// than intrinsic value.
|
||||
///
|
||||
/// Parameters: same as `strategy_payoff_dense` plus per-leg BSM inputs:
|
||||
/// - `time_to_expiries`: TTE for each option leg (ignored for futures/stocks)
|
||||
/// - `volatilities`: vol for each option leg (ignored for futures/stocks)
|
||||
/// - `rates`: risk-free rate for each leg
|
||||
/// - `carries`: carry/dividend yield for each option leg
|
||||
///
|
||||
/// Returns a scalar f64 (strategy P&L at the given spot).
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn strategy_value_dense(
|
||||
spot: f64,
|
||||
instruments: &[i64],
|
||||
sides: &[i64],
|
||||
option_types: &[i64],
|
||||
strikes: &[f64],
|
||||
premiums: &[f64],
|
||||
entry_prices: &[f64],
|
||||
quantities: &[f64],
|
||||
multipliers: &[f64],
|
||||
time_to_expiries: &[f64],
|
||||
volatilities: &[f64],
|
||||
rates: &[f64],
|
||||
carries: &[f64],
|
||||
) -> f64 {
|
||||
let n_legs = instruments.len();
|
||||
// Validate that all leg slices are the same length; return NaN if not.
|
||||
if sides.len() != n_legs
|
||||
|| option_types.len() != n_legs
|
||||
|| strikes.len() != n_legs
|
||||
|| premiums.len() != n_legs
|
||||
|| entry_prices.len() != n_legs
|
||||
|| quantities.len() != n_legs
|
||||
|| multipliers.len() != n_legs
|
||||
|| time_to_expiries.len() != n_legs
|
||||
|| volatilities.len() != n_legs
|
||||
|| rates.len() != n_legs
|
||||
|| carries.len() != n_legs
|
||||
{
|
||||
return f64::NAN;
|
||||
}
|
||||
|
||||
let mut total = 0.0_f64;
|
||||
|
||||
for leg_idx in 0..n_legs {
|
||||
let inst = instruments[leg_idx];
|
||||
let sign = side_sign(sides[leg_idx]);
|
||||
if sign.is_nan() {
|
||||
continue;
|
||||
}
|
||||
let leg_scale = sign * quantities[leg_idx] * multipliers[leg_idx];
|
||||
|
||||
match inst {
|
||||
INSTRUMENT_OPTION => {
|
||||
let kind = match option_kind(option_types[leg_idx]) {
|
||||
Some(k) => k,
|
||||
None => continue,
|
||||
};
|
||||
let bsm = black_scholes_price(
|
||||
spot,
|
||||
strikes[leg_idx],
|
||||
rates[leg_idx],
|
||||
carries[leg_idx],
|
||||
time_to_expiries[leg_idx],
|
||||
volatilities[leg_idx],
|
||||
kind,
|
||||
);
|
||||
total += leg_scale * (bsm - premiums[leg_idx]);
|
||||
}
|
||||
INSTRUMENT_FUTURE | INSTRUMENT_STOCK => {
|
||||
total += leg_scale * (spot - entry_prices[leg_idx]);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
total
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// aggregate_greeks_dense
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Aggregate BSM Greeks for a multi-leg strategy at a single spot.
|
||||
///
|
||||
/// Parameters (all slices of length n_legs):
|
||||
/// - `instruments`: 0=option, 1=future, 2=stock
|
||||
/// - `sides`: 1=long, -1=short
|
||||
/// - `option_types`: 1=call, -1=put (ignored for futures/stocks)
|
||||
/// - `strikes`: strike price for option legs
|
||||
/// - `volatilities`: implied vol for option legs
|
||||
/// - `time_to_expiries`: TTE in years for option legs
|
||||
/// - `rates`: risk-free rate for each leg
|
||||
/// - `carries`: carry/dividend yield for option legs
|
||||
/// - `quantities`, `multipliers`: applied to all instruments
|
||||
///
|
||||
/// Returns `(delta, gamma, vega, theta, rho)` aggregate across all legs.
|
||||
/// Future/stock legs contribute `leg_scale` to delta only (all other Greeks = 0).
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn aggregate_greeks_dense(
|
||||
spot: f64,
|
||||
instruments: &[i64],
|
||||
sides: &[i64],
|
||||
option_types: &[i64],
|
||||
strikes: &[f64],
|
||||
volatilities: &[f64],
|
||||
time_to_expiries: &[f64],
|
||||
rates: &[f64],
|
||||
carries: &[f64],
|
||||
quantities: &[f64],
|
||||
multipliers: &[f64],
|
||||
) -> (f64, f64, f64, f64, f64) {
|
||||
use super::greeks::model_greeks;
|
||||
use super::{OptionContract, OptionEvaluation, PricingModel};
|
||||
|
||||
let n_legs = instruments.len();
|
||||
if sides.len() != n_legs
|
||||
|| option_types.len() != n_legs
|
||||
|| strikes.len() != n_legs
|
||||
|| volatilities.len() != n_legs
|
||||
|| time_to_expiries.len() != n_legs
|
||||
|| rates.len() != n_legs
|
||||
|| carries.len() != n_legs
|
||||
|| quantities.len() != n_legs
|
||||
|| multipliers.len() != n_legs
|
||||
{
|
||||
return (f64::NAN, f64::NAN, f64::NAN, f64::NAN, f64::NAN);
|
||||
}
|
||||
|
||||
let mut delta = 0.0_f64;
|
||||
let mut gamma = 0.0_f64;
|
||||
let mut vega = 0.0_f64;
|
||||
let mut theta = 0.0_f64;
|
||||
let mut rho = 0.0_f64;
|
||||
|
||||
for i in 0..n_legs {
|
||||
let sign = side_sign(sides[i]);
|
||||
if sign.is_nan() {
|
||||
continue;
|
||||
}
|
||||
let leg_scale = sign * quantities[i] * multipliers[i];
|
||||
|
||||
match instruments[i] {
|
||||
INSTRUMENT_FUTURE | INSTRUMENT_STOCK => {
|
||||
delta += leg_scale;
|
||||
}
|
||||
INSTRUMENT_OPTION => {
|
||||
let kind = match option_kind(option_types[i]) {
|
||||
Some(k) => k,
|
||||
None => continue,
|
||||
};
|
||||
let greeks = model_greeks(OptionEvaluation {
|
||||
contract: OptionContract {
|
||||
model: PricingModel::BlackScholes,
|
||||
underlying: spot,
|
||||
strike: strikes[i],
|
||||
rate: rates[i],
|
||||
carry: carries[i],
|
||||
time_to_expiry: time_to_expiries[i],
|
||||
kind,
|
||||
},
|
||||
volatility: volatilities[i],
|
||||
});
|
||||
delta += leg_scale * greeks.delta;
|
||||
gamma += leg_scale * greeks.gamma;
|
||||
vega += leg_scale * greeks.vega;
|
||||
theta += leg_scale * greeks.theta;
|
||||
rho += leg_scale * greeks.rho;
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
(delta, gamma, vega, theta, rho)
|
||||
}
|
||||
|
||||
/// Evaluate `strategy_value_dense` for each point in `spot_grid`.
|
||||
///
|
||||
/// Returns a `Vec<f64>` of length `spot_grid.len()`.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn strategy_value_grid(
|
||||
spot_grid: &[f64],
|
||||
instruments: &[i64],
|
||||
sides: &[i64],
|
||||
option_types: &[i64],
|
||||
strikes: &[f64],
|
||||
premiums: &[f64],
|
||||
entry_prices: &[f64],
|
||||
quantities: &[f64],
|
||||
multipliers: &[f64],
|
||||
time_to_expiries: &[f64],
|
||||
volatilities: &[f64],
|
||||
rates: &[f64],
|
||||
carries: &[f64],
|
||||
) -> Vec<f64> {
|
||||
spot_grid
|
||||
.iter()
|
||||
.map(|&s| {
|
||||
strategy_value_dense(
|
||||
s,
|
||||
instruments,
|
||||
sides,
|
||||
option_types,
|
||||
strikes,
|
||||
premiums,
|
||||
entry_prices,
|
||||
quantities,
|
||||
multipliers,
|
||||
time_to_expiries,
|
||||
volatilities,
|
||||
rates,
|
||||
carries,
|
||||
)
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn payoff_single_call() {
|
||||
let grid = vec![90.0, 100.0, 110.0, 120.0];
|
||||
let out = strategy_payoff_dense(
|
||||
&grid,
|
||||
&[0],
|
||||
&[1],
|
||||
&[1],
|
||||
&[100.0],
|
||||
&[5.0],
|
||||
&[0.0],
|
||||
&[1.0],
|
||||
&[1.0],
|
||||
);
|
||||
assert!(out[0] < 0.0); // below strike, loss = premium
|
||||
assert!((out[0] - (-5.0)).abs() < 1e-10);
|
||||
assert!((out[2] - 5.0).abs() < 1e-10); // at 110, intrinsic=10, net=10-5=5
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stock_leg_linear() {
|
||||
let grid = vec![90.0, 100.0, 110.0];
|
||||
let out = strategy_payoff_dense(
|
||||
&grid,
|
||||
&[2],
|
||||
&[1],
|
||||
&[0],
|
||||
&[0.0],
|
||||
&[0.0],
|
||||
&[100.0],
|
||||
&[1.0],
|
||||
&[1.0],
|
||||
);
|
||||
assert!((out[0] - (-10.0)).abs() < 1e-10);
|
||||
assert!((out[1] - 0.0).abs() < 1e-10);
|
||||
assert!((out[2] - 10.0).abs() < 1e-10);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,218 @@
|
||||
//! Option pricing models.
|
||||
|
||||
use super::normal::cdf;
|
||||
use super::{OptionContract, OptionEvaluation, OptionKind, PricingModel};
|
||||
|
||||
fn invalid_inputs(underlying: f64, strike: f64, time_to_expiry: f64, volatility: f64) -> bool {
|
||||
!underlying.is_finite()
|
||||
|| !strike.is_finite()
|
||||
|| !time_to_expiry.is_finite()
|
||||
|| !volatility.is_finite()
|
||||
|| underlying <= 0.0
|
||||
|| strike <= 0.0
|
||||
|| time_to_expiry < 0.0
|
||||
|| volatility < 0.0
|
||||
}
|
||||
|
||||
/// Black-Scholes-Merton price with continuous carry/dividend yield.
|
||||
pub fn black_scholes_price(
|
||||
spot: f64,
|
||||
strike: f64,
|
||||
rate: f64,
|
||||
dividend_yield: f64,
|
||||
time_to_expiry: f64,
|
||||
volatility: f64,
|
||||
kind: OptionKind,
|
||||
) -> f64 {
|
||||
if invalid_inputs(spot, strike, time_to_expiry, volatility) || !rate.is_finite() {
|
||||
return f64::NAN;
|
||||
}
|
||||
if time_to_expiry == 0.0 {
|
||||
return match kind {
|
||||
OptionKind::Call => (spot - strike).max(0.0),
|
||||
OptionKind::Put => (strike - spot).max(0.0),
|
||||
};
|
||||
}
|
||||
|
||||
let discount = (-rate * time_to_expiry).exp();
|
||||
let carry_discount = (-dividend_yield * time_to_expiry).exp();
|
||||
if volatility == 0.0 {
|
||||
return match kind {
|
||||
OptionKind::Call => (spot * carry_discount - strike * discount).max(0.0),
|
||||
OptionKind::Put => (strike * discount - spot * carry_discount).max(0.0),
|
||||
};
|
||||
}
|
||||
|
||||
let sqrt_t = time_to_expiry.sqrt();
|
||||
let sigma_sqrt_t = volatility * sqrt_t;
|
||||
let d1 = ((spot / strike).ln()
|
||||
+ (rate - dividend_yield + 0.5 * volatility * volatility) * time_to_expiry)
|
||||
/ sigma_sqrt_t;
|
||||
let d2 = d1 - sigma_sqrt_t;
|
||||
|
||||
match kind {
|
||||
OptionKind::Call => spot * carry_discount * cdf(d1) - strike * discount * cdf(d2),
|
||||
OptionKind::Put => strike * discount * cdf(-d2) - spot * carry_discount * cdf(-d1),
|
||||
}
|
||||
}
|
||||
|
||||
/// Black-76 price using the forward price as the underlying input.
|
||||
pub fn black_76_price(
|
||||
forward: f64,
|
||||
strike: f64,
|
||||
rate: f64,
|
||||
time_to_expiry: f64,
|
||||
volatility: f64,
|
||||
kind: OptionKind,
|
||||
) -> f64 {
|
||||
if invalid_inputs(forward, strike, time_to_expiry, volatility) || !rate.is_finite() {
|
||||
return f64::NAN;
|
||||
}
|
||||
let discount = (-rate * time_to_expiry).exp();
|
||||
if time_to_expiry == 0.0 {
|
||||
return discount
|
||||
* match kind {
|
||||
OptionKind::Call => (forward - strike).max(0.0),
|
||||
OptionKind::Put => (strike - forward).max(0.0),
|
||||
};
|
||||
}
|
||||
if volatility == 0.0 {
|
||||
return discount
|
||||
* match kind {
|
||||
OptionKind::Call => (forward - strike).max(0.0),
|
||||
OptionKind::Put => (strike - forward).max(0.0),
|
||||
};
|
||||
}
|
||||
|
||||
let sqrt_t = time_to_expiry.sqrt();
|
||||
let sigma_sqrt_t = volatility * sqrt_t;
|
||||
let d1 =
|
||||
((forward / strike).ln() + 0.5 * volatility * volatility * time_to_expiry) / sigma_sqrt_t;
|
||||
let d2 = d1 - sigma_sqrt_t;
|
||||
|
||||
let signed = kind.sign();
|
||||
discount * signed * (forward * cdf(signed * d1) - strike * cdf(signed * d2))
|
||||
}
|
||||
|
||||
/// Model-dispatched option price.
|
||||
pub fn model_price(input: OptionEvaluation) -> f64 {
|
||||
let contract = input.contract;
|
||||
match contract.model {
|
||||
PricingModel::BlackScholes => black_scholes_price(
|
||||
contract.underlying,
|
||||
contract.strike,
|
||||
contract.rate,
|
||||
contract.carry,
|
||||
contract.time_to_expiry,
|
||||
input.volatility,
|
||||
contract.kind,
|
||||
),
|
||||
PricingModel::Black76 => black_76_price(
|
||||
contract.underlying,
|
||||
contract.strike,
|
||||
contract.rate,
|
||||
contract.time_to_expiry,
|
||||
input.volatility,
|
||||
contract.kind,
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
/// Put-call parity deviation: `C - P - (S·e^{-q·T} - K·e^{-r·T})`.
|
||||
///
|
||||
/// Returns 0.0 when no arbitrage exists. A non-zero value indicates the
|
||||
/// magnitude of mispricing or data error.
|
||||
pub fn put_call_parity_deviation(
|
||||
call_price: f64,
|
||||
put_price: f64,
|
||||
spot: f64,
|
||||
strike: f64,
|
||||
rate: f64,
|
||||
carry: f64,
|
||||
time_to_expiry: f64,
|
||||
) -> f64 {
|
||||
if !call_price.is_finite()
|
||||
|| !put_price.is_finite()
|
||||
|| !spot.is_finite()
|
||||
|| !strike.is_finite()
|
||||
|| !rate.is_finite()
|
||||
|| !carry.is_finite()
|
||||
|| !time_to_expiry.is_finite()
|
||||
|| spot <= 0.0
|
||||
|| strike <= 0.0
|
||||
|| time_to_expiry < 0.0
|
||||
{
|
||||
return f64::NAN;
|
||||
}
|
||||
let pv_forward = spot * (-carry * time_to_expiry).exp();
|
||||
let pv_strike = strike * (-rate * time_to_expiry).exp();
|
||||
call_price - put_price - (pv_forward - pv_strike)
|
||||
}
|
||||
|
||||
/// Lower no-arbitrage bound for the option price.
|
||||
pub fn price_lower_bound(contract: OptionContract) -> f64 {
|
||||
match contract.model {
|
||||
PricingModel::BlackScholes => {
|
||||
let discount = (-contract.rate * contract.time_to_expiry).exp();
|
||||
let carry_discount = (-contract.carry * contract.time_to_expiry).exp();
|
||||
match contract.kind {
|
||||
OptionKind::Call => {
|
||||
(contract.underlying * carry_discount - contract.strike * discount).max(0.0)
|
||||
}
|
||||
OptionKind::Put => {
|
||||
(contract.strike * discount - contract.underlying * carry_discount).max(0.0)
|
||||
}
|
||||
}
|
||||
}
|
||||
PricingModel::Black76 => {
|
||||
let discount = (-contract.rate * contract.time_to_expiry).exp();
|
||||
discount
|
||||
* match contract.kind {
|
||||
OptionKind::Call => (contract.underlying - contract.strike).max(0.0),
|
||||
OptionKind::Put => (contract.strike - contract.underlying).max(0.0),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Upper no-arbitrage bound for the option price.
|
||||
pub fn price_upper_bound(contract: OptionContract) -> f64 {
|
||||
match contract.model {
|
||||
PricingModel::BlackScholes => match contract.kind {
|
||||
OptionKind::Call => {
|
||||
contract.underlying * (-contract.carry * contract.time_to_expiry).exp()
|
||||
}
|
||||
OptionKind::Put => contract.strike * (-contract.rate * contract.time_to_expiry).exp(),
|
||||
},
|
||||
PricingModel::Black76 => {
|
||||
let discount = (-contract.rate * contract.time_to_expiry).exp();
|
||||
discount
|
||||
* match contract.kind {
|
||||
OptionKind::Call => contract.underlying,
|
||||
OptionKind::Put => contract.strike,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{black_76_price, black_scholes_price};
|
||||
use crate::options::OptionKind;
|
||||
|
||||
#[test]
|
||||
fn black_scholes_prices_are_reasonable() {
|
||||
let call = black_scholes_price(100.0, 100.0, 0.05, 0.0, 1.0, 0.2, OptionKind::Call);
|
||||
let put = black_scholes_price(100.0, 100.0, 0.05, 0.0, 1.0, 0.2, OptionKind::Put);
|
||||
assert!((call - 10.4506).abs() < 1e-3);
|
||||
assert!((put - 5.5735).abs() < 1e-3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn black_76_prices_are_reasonable() {
|
||||
let call = black_76_price(100.0, 100.0, 0.03, 1.0, 0.2, OptionKind::Call);
|
||||
let put = black_76_price(100.0, 100.0, 0.03, 1.0, 0.2, OptionKind::Put);
|
||||
assert!((call - 7.730_148).abs() < 1e-3);
|
||||
assert!((put - 7.730_148).abs() < 1e-3);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,445 @@
|
||||
//! Historical (realized) volatility estimators and volatility cone.
|
||||
|
||||
/// Rolling close-to-close realized volatility.
|
||||
///
|
||||
/// Returns a `Vec<f64>` of the same length as `close`. The first `window` values
|
||||
/// are NaN (we need `window` log-returns, which require `window+1` prices, so the
|
||||
/// first valid output sits at index `window`).
|
||||
///
|
||||
/// Annualization: `sqrt(sum(r²) / window * trading_days)`.
|
||||
pub fn close_to_close_vol(close: &[f64], window: usize, trading_days: f64) -> Vec<f64> {
|
||||
let n = close.len();
|
||||
let mut out = vec![f64::NAN; n];
|
||||
if window == 0 || n <= window {
|
||||
return out;
|
||||
}
|
||||
|
||||
// Precompute log-returns; returns[i] = ln(close[i+1] / close[i])
|
||||
let mut returns = vec![f64::NAN; n - 1];
|
||||
for i in 0..(n - 1) {
|
||||
if close[i] > 0.0 && close[i + 1] > 0.0 {
|
||||
returns[i] = (close[i + 1] / close[i]).ln();
|
||||
}
|
||||
}
|
||||
|
||||
// Rolling sum of squared returns over `window` bars.
|
||||
// The output at position `end` (in the original close array) uses
|
||||
// returns[end-window .. end-1], i.e. `window` returns.
|
||||
for end in window..n {
|
||||
let slice = &returns[(end - window)..end];
|
||||
let sum_sq: f64 = slice.iter().map(|&r| r * r).sum();
|
||||
let var = sum_sq / window as f64 * trading_days;
|
||||
out[end] = if var >= 0.0 { var.sqrt() } else { f64::NAN };
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Rolling Parkinson high-low realized volatility estimator.
|
||||
///
|
||||
/// Returns a `Vec<f64>` of the same length as `high`. The first `window-1` values
|
||||
/// are NaN.
|
||||
#[allow(clippy::needless_range_loop)]
|
||||
pub fn parkinson_vol(high: &[f64], low: &[f64], window: usize, trading_days: f64) -> Vec<f64> {
|
||||
let n = high.len();
|
||||
let mut out = vec![f64::NAN; n];
|
||||
if window == 0 || n < window || low.len() != n {
|
||||
return out;
|
||||
}
|
||||
|
||||
let factor = 1.0 / (4.0 * 2_f64.ln());
|
||||
|
||||
for end in (window - 1)..n {
|
||||
let start = end + 1 - window;
|
||||
let mut sum_sq = 0.0;
|
||||
let mut valid = true;
|
||||
for i in start..=end {
|
||||
if high[i] <= 0.0 || low[i] <= 0.0 || !high[i].is_finite() || !low[i].is_finite() {
|
||||
valid = false;
|
||||
break;
|
||||
}
|
||||
let u = (high[i] / low[i]).ln();
|
||||
sum_sq += u * u;
|
||||
}
|
||||
if valid {
|
||||
let var = factor * sum_sq / window as f64 * trading_days;
|
||||
out[end] = if var >= 0.0 { var.sqrt() } else { f64::NAN };
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Rolling Garman-Klass OHLC realized volatility estimator.
|
||||
///
|
||||
/// Returns a `Vec<f64>` of the same length as the inputs. The first `window-1`
|
||||
/// values are NaN. All four slices must have the same length.
|
||||
pub fn garman_klass_vol(
|
||||
open: &[f64],
|
||||
high: &[f64],
|
||||
low: &[f64],
|
||||
close: &[f64],
|
||||
window: usize,
|
||||
trading_days: f64,
|
||||
) -> Vec<f64> {
|
||||
let n = open.len();
|
||||
let mut out = vec![f64::NAN; n];
|
||||
if window == 0 || n < window || high.len() != n || low.len() != n || close.len() != n {
|
||||
return out;
|
||||
}
|
||||
|
||||
let ln2 = 2_f64.ln();
|
||||
|
||||
// Precompute per-bar GK contributions.
|
||||
let mut gk = vec![f64::NAN; n];
|
||||
for i in 0..n {
|
||||
let o = open[i];
|
||||
let h = high[i];
|
||||
let l = low[i];
|
||||
let c = close[i];
|
||||
if o > 0.0
|
||||
&& h > 0.0
|
||||
&& l > 0.0
|
||||
&& c > 0.0
|
||||
&& o.is_finite()
|
||||
&& h.is_finite()
|
||||
&& l.is_finite()
|
||||
&& c.is_finite()
|
||||
{
|
||||
let u = (h / o).ln();
|
||||
let d = (l / o).ln();
|
||||
let ci = (c / o).ln();
|
||||
gk[i] = 0.5 * (u - d).powi(2) - (2.0 * ln2 - 1.0) * ci * ci;
|
||||
}
|
||||
}
|
||||
|
||||
for end in (window - 1)..n {
|
||||
let start = end + 1 - window;
|
||||
let slice = &gk[start..=end];
|
||||
if slice.iter().all(|v| v.is_finite()) {
|
||||
let sum: f64 = slice.iter().sum();
|
||||
let var = sum / window as f64 * trading_days;
|
||||
out[end] = if var >= 0.0 { var.sqrt() } else { f64::NAN };
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Compute the Rogers-Satchell per-bar variance contribution.
|
||||
fn rs_bar(open: f64, high: f64, low: f64, close: f64) -> f64 {
|
||||
let u = (high / close).ln();
|
||||
let d = (low / close).ln();
|
||||
let uo = (high / open).ln();
|
||||
let do_ = (low / open).ln();
|
||||
u * uo + d * do_
|
||||
}
|
||||
|
||||
/// Rolling Rogers-Satchell OHLC realized volatility estimator.
|
||||
///
|
||||
/// Returns a `Vec<f64>` of the same length as the inputs. The first `window-1`
|
||||
/// values are NaN. All four slices must have the same length.
|
||||
pub fn rogers_satchell_vol(
|
||||
open: &[f64],
|
||||
high: &[f64],
|
||||
low: &[f64],
|
||||
close: &[f64],
|
||||
window: usize,
|
||||
trading_days: f64,
|
||||
) -> Vec<f64> {
|
||||
let n = open.len();
|
||||
let mut out = vec![f64::NAN; n];
|
||||
if window == 0 || n < window || high.len() != n || low.len() != n || close.len() != n {
|
||||
return out;
|
||||
}
|
||||
|
||||
// Precompute per-bar RS contributions.
|
||||
let mut rs = vec![f64::NAN; n];
|
||||
for i in 0..n {
|
||||
let o = open[i];
|
||||
let h = high[i];
|
||||
let l = low[i];
|
||||
let c = close[i];
|
||||
if o > 0.0
|
||||
&& h > 0.0
|
||||
&& l > 0.0
|
||||
&& c > 0.0
|
||||
&& o.is_finite()
|
||||
&& h.is_finite()
|
||||
&& l.is_finite()
|
||||
&& c.is_finite()
|
||||
{
|
||||
rs[i] = rs_bar(o, h, l, c);
|
||||
}
|
||||
}
|
||||
|
||||
for end in (window - 1)..n {
|
||||
let start = end + 1 - window;
|
||||
let slice = &rs[start..=end];
|
||||
if slice.iter().all(|v| v.is_finite()) {
|
||||
let sum: f64 = slice.iter().sum();
|
||||
let var = sum / window as f64 * trading_days;
|
||||
out[end] = if var >= 0.0 { var.sqrt() } else { f64::NAN };
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Rolling Yang-Zhang OHLC realized volatility estimator.
|
||||
///
|
||||
/// Handles overnight gaps. Returns a `Vec<f64>` of the same length as the inputs.
|
||||
/// The first `window` values are NaN (we need `window` bars plus the prior close
|
||||
/// for overnight returns, so valid output starts at index `window`).
|
||||
/// All four slices must have the same length.
|
||||
pub fn yang_zhang_vol(
|
||||
open: &[f64],
|
||||
high: &[f64],
|
||||
low: &[f64],
|
||||
close: &[f64],
|
||||
window: usize,
|
||||
trading_days: f64,
|
||||
) -> Vec<f64> {
|
||||
let n = open.len();
|
||||
let mut out = vec![f64::NAN; n];
|
||||
if window == 0 || n <= window || high.len() != n || low.len() != n || close.len() != n {
|
||||
return out;
|
||||
}
|
||||
|
||||
let k = 0.34 / (1.34 + (window as f64 + 1.0) / (window as f64 - 1.0).max(1e-10));
|
||||
|
||||
// Precompute per-bar components; index 0 has no overnight return.
|
||||
// overnight[i] = ln(O_i / C_{i-1}), valid for i >= 1
|
||||
// openclose[i] = ln(C_i / O_i)
|
||||
// rs[i] = Rogers-Satchell for bar i
|
||||
let mut overnight = vec![f64::NAN; n];
|
||||
let mut openclose = vec![f64::NAN; n];
|
||||
let mut rs = vec![f64::NAN; n];
|
||||
|
||||
for i in 0..n {
|
||||
let o = open[i];
|
||||
let h = high[i];
|
||||
let l = low[i];
|
||||
let c = close[i];
|
||||
if o > 0.0
|
||||
&& h > 0.0
|
||||
&& l > 0.0
|
||||
&& c > 0.0
|
||||
&& o.is_finite()
|
||||
&& h.is_finite()
|
||||
&& l.is_finite()
|
||||
&& c.is_finite()
|
||||
{
|
||||
openclose[i] = (c / o).ln();
|
||||
rs[i] = rs_bar(o, h, l, c);
|
||||
|
||||
if i > 0 {
|
||||
let prev_c = close[i - 1];
|
||||
if prev_c > 0.0 && prev_c.is_finite() {
|
||||
overnight[i] = (o / prev_c).ln();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Valid windows start at index `window` (using bars [end-window+1 .. end],
|
||||
// all of which have valid overnight returns since they start at index >= 1).
|
||||
for end in window..n {
|
||||
let start = end + 1 - window; // start >= 1 because end >= window
|
||||
|
||||
let o_slice = &overnight[start..=end];
|
||||
let c_slice = &openclose[start..=end];
|
||||
let r_slice = &rs[start..=end];
|
||||
|
||||
if !o_slice.iter().all(|v| v.is_finite())
|
||||
|| !c_slice.iter().all(|v| v.is_finite())
|
||||
|| !r_slice.iter().all(|v| v.is_finite())
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
let w = window as f64;
|
||||
|
||||
let o_sum: f64 = o_slice.iter().sum();
|
||||
let o_sum_sq: f64 = o_slice.iter().map(|&x| x * x).sum();
|
||||
let overnight_var = o_sum_sq / (w - 1.0) - (o_sum / w).powi(2) * w / (w - 1.0);
|
||||
|
||||
let c_sum: f64 = c_slice.iter().sum();
|
||||
let c_sum_sq: f64 = c_slice.iter().map(|&x| x * x).sum();
|
||||
let openclose_var = c_sum_sq / (w - 1.0) - (c_sum / w).powi(2) * w / (w - 1.0);
|
||||
|
||||
let rs_sum: f64 = r_slice.iter().sum();
|
||||
let rs_var = rs_sum / w;
|
||||
|
||||
let yz_var = overnight_var + k * openclose_var + (1.0 - k) * rs_var;
|
||||
let annualized = yz_var * trading_days;
|
||||
out[end] = if annualized >= 0.0 {
|
||||
annualized.sqrt()
|
||||
} else {
|
||||
f64::NAN
|
||||
};
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Summary statistics of realized vol distribution for one window length.
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct VolConeSlice {
|
||||
pub window: usize,
|
||||
pub min: f64,
|
||||
pub p25: f64,
|
||||
pub median: f64,
|
||||
pub p75: f64,
|
||||
pub max: f64,
|
||||
}
|
||||
|
||||
/// Compute a percentile via linear interpolation on a sorted slice.
|
||||
///
|
||||
/// `sorted` must be non-empty and already sorted ascending.
|
||||
fn percentile_sorted(sorted: &[f64], p: f64) -> f64 {
|
||||
let n = sorted.len();
|
||||
if n == 1 {
|
||||
return sorted[0];
|
||||
}
|
||||
let idx = (n - 1) as f64 * p;
|
||||
let lo = idx.floor() as usize;
|
||||
let hi = idx.ceil() as usize;
|
||||
let frac = idx - lo as f64;
|
||||
sorted[lo] + frac * (sorted[hi] - sorted[lo])
|
||||
}
|
||||
|
||||
/// Compute vol cone: distribution of realized vols across multiple window lengths.
|
||||
///
|
||||
/// For each window in `windows`, the close-to-close rolling vol is computed,
|
||||
/// NaN values are filtered out, and the distribution statistics (min, p25,
|
||||
/// median, p75, max) are derived via linear interpolation.
|
||||
pub fn vol_cone(close: &[f64], windows: &[usize], trading_days: f64) -> Vec<VolConeSlice> {
|
||||
windows
|
||||
.iter()
|
||||
.map(|&w| {
|
||||
let vols = close_to_close_vol(close, w, trading_days);
|
||||
let mut valid: Vec<f64> = vols.into_iter().filter(|v| v.is_finite()).collect();
|
||||
valid.sort_by(|a, b| a.partial_cmp(b).unwrap());
|
||||
|
||||
if valid.is_empty() {
|
||||
return VolConeSlice {
|
||||
window: w,
|
||||
min: f64::NAN,
|
||||
p25: f64::NAN,
|
||||
median: f64::NAN,
|
||||
p75: f64::NAN,
|
||||
max: f64::NAN,
|
||||
};
|
||||
}
|
||||
|
||||
VolConeSlice {
|
||||
window: w,
|
||||
min: valid[0],
|
||||
p25: percentile_sorted(&valid, 0.25),
|
||||
median: percentile_sorted(&valid, 0.5),
|
||||
p75: percentile_sorted(&valid, 0.75),
|
||||
max: *valid.last().unwrap(),
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn fake_prices(n: usize) -> Vec<f64> {
|
||||
// simple synthetic price series
|
||||
let mut prices = vec![100.0_f64; n];
|
||||
for i in 1..n {
|
||||
prices[i] = prices[i - 1] * (1.0 + 0.01 * (i as f64 % 7_f64 - 3.0) * 0.01);
|
||||
}
|
||||
prices
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn close_to_close_returns_nans_for_warmup() {
|
||||
let close = fake_prices(100);
|
||||
let result = close_to_close_vol(&close, 20, 252.0);
|
||||
assert_eq!(result.len(), 100);
|
||||
// first 20 values should be NaN (window-1 of returns warmup + 1 for diff)
|
||||
for i in 0..20 {
|
||||
assert!(result[i].is_nan(), "result[{i}] should be NaN");
|
||||
}
|
||||
assert!(result[20].is_finite());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parkinson_vol_is_positive() {
|
||||
let close = fake_prices(100);
|
||||
let high: Vec<f64> = close.iter().map(|&c| c * 1.01).collect();
|
||||
let low: Vec<f64> = close.iter().map(|&c| c * 0.99).collect();
|
||||
let result = parkinson_vol(&high, &low, 20, 252.0);
|
||||
for v in result.iter().skip(19) {
|
||||
assert!(v.is_finite() && *v >= 0.0);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn vol_cone_is_ordered() {
|
||||
let close = fake_prices(300);
|
||||
let cones = vol_cone(&close, &[20, 60], 252.0);
|
||||
assert_eq!(cones.len(), 2);
|
||||
for cone in &cones {
|
||||
assert!(cone.min <= cone.p25);
|
||||
assert!(cone.p25 <= cone.median);
|
||||
assert!(cone.median <= cone.p75);
|
||||
assert!(cone.p75 <= cone.max);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn garman_klass_returns_nans_for_warmup() {
|
||||
let close = fake_prices(50);
|
||||
let high: Vec<f64> = close.iter().map(|&c| c * 1.01).collect();
|
||||
let low: Vec<f64> = close.iter().map(|&c| c * 0.99).collect();
|
||||
let result = garman_klass_vol(&close, &high, &low, &close, 10, 252.0);
|
||||
assert_eq!(result.len(), 50);
|
||||
for i in 0..9 {
|
||||
assert!(result[i].is_nan(), "result[{i}] should be NaN");
|
||||
}
|
||||
assert!(result[9].is_finite());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rogers_satchell_returns_nans_for_warmup() {
|
||||
let close = fake_prices(50);
|
||||
let high: Vec<f64> = close.iter().map(|&c| c * 1.01).collect();
|
||||
let low: Vec<f64> = close.iter().map(|&c| c * 0.99).collect();
|
||||
let result = rogers_satchell_vol(&close, &high, &low, &close, 10, 252.0);
|
||||
assert_eq!(result.len(), 50);
|
||||
for i in 0..9 {
|
||||
assert!(result[i].is_nan(), "result[{i}] should be NaN");
|
||||
}
|
||||
assert!(result[9].is_finite());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn yang_zhang_returns_nans_for_warmup() {
|
||||
let close = fake_prices(50);
|
||||
let high: Vec<f64> = close.iter().map(|&c| c * 1.01).collect();
|
||||
let low: Vec<f64> = close.iter().map(|&c| c * 0.99).collect();
|
||||
let result = yang_zhang_vol(&close, &high, &low, &close, 10, 252.0);
|
||||
assert_eq!(result.len(), 50);
|
||||
for i in 0..10 {
|
||||
assert!(result[i].is_nan(), "result[{i}] should be NaN");
|
||||
}
|
||||
assert!(result[10].is_finite());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mismatched_lengths_return_all_nan() {
|
||||
let a = vec![100.0_f64; 20];
|
||||
let b = vec![101.0_f64; 15]; // wrong length
|
||||
let result = parkinson_vol(&a, &b, 5, 252.0);
|
||||
assert!(result.iter().all(|v| v.is_nan()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn window_larger_than_data_returns_all_nan() {
|
||||
let close = fake_prices(10);
|
||||
let result = close_to_close_vol(&close, 20, 252.0);
|
||||
assert!(result.iter().all(|v| v.is_nan()));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,269 @@
|
||||
//! Smile and surface analytics helpers.
|
||||
|
||||
use super::chain::atm_index;
|
||||
use super::greeks::model_greeks;
|
||||
use super::{ChainGreeksContext, OptionContract, OptionEvaluation, OptionKind, PricingModel};
|
||||
|
||||
/// Smile summary metrics.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub struct SmileMetrics {
|
||||
pub atm_iv: f64,
|
||||
pub risk_reversal_25d: f64,
|
||||
pub butterfly_25d: f64,
|
||||
pub skew_slope: f64,
|
||||
pub convexity: f64,
|
||||
}
|
||||
|
||||
/// Linear interpolation helper.
|
||||
pub fn linear_interpolate(xs: &[f64], ys: &[f64], target: f64) -> f64 {
|
||||
if xs.len() != ys.len() || xs.is_empty() {
|
||||
return f64::NAN;
|
||||
}
|
||||
if target <= xs[0] {
|
||||
return ys[0];
|
||||
}
|
||||
for i in 1..xs.len() {
|
||||
if target <= xs[i] {
|
||||
let x0 = xs[i - 1];
|
||||
let x1 = xs[i];
|
||||
let y0 = ys[i - 1];
|
||||
let y1 = ys[i];
|
||||
let w = if x1 == x0 {
|
||||
0.0
|
||||
} else {
|
||||
(target - x0) / (x1 - x0)
|
||||
};
|
||||
return y0 + w * (y1 - y0);
|
||||
}
|
||||
}
|
||||
ys[ys.len() - 1]
|
||||
}
|
||||
|
||||
/// ATM implied volatility by nearest strike.
|
||||
pub fn atm_iv(strikes: &[f64], vols: &[f64], reference_price: f64) -> f64 {
|
||||
if strikes.len() != vols.len() || strikes.is_empty() || !reference_price.is_finite() {
|
||||
return f64::NAN;
|
||||
}
|
||||
atm_index(strikes, reference_price)
|
||||
.and_then(|idx| vols.get(idx).copied())
|
||||
.unwrap_or(f64::NAN)
|
||||
}
|
||||
|
||||
fn regression_slope(xs: &[f64], ys: &[f64]) -> f64 {
|
||||
if xs.len() != ys.len() || xs.len() < 2 {
|
||||
return f64::NAN;
|
||||
}
|
||||
let n = xs.len() as f64;
|
||||
let mean_x = xs.iter().sum::<f64>() / n;
|
||||
let mean_y = ys.iter().sum::<f64>() / n;
|
||||
let mut cov = 0.0;
|
||||
let mut var = 0.0;
|
||||
for (&x, &y) in xs.iter().zip(ys.iter()) {
|
||||
cov += (x - mean_x) * (y - mean_y);
|
||||
var += (x - mean_x) * (x - mean_x);
|
||||
}
|
||||
if var == 0.0 {
|
||||
f64::NAN
|
||||
} else {
|
||||
cov / var
|
||||
}
|
||||
}
|
||||
|
||||
fn closest_delta_iv(
|
||||
strikes: &[f64],
|
||||
vols: &[f64],
|
||||
context: ChainGreeksContext,
|
||||
target_delta: f64,
|
||||
) -> f64 {
|
||||
let mut best_iv = f64::NAN;
|
||||
let mut best_distance = f64::INFINITY;
|
||||
for (&strike, &vol) in strikes.iter().zip(vols.iter()) {
|
||||
if !strike.is_finite() || !vol.is_finite() {
|
||||
continue;
|
||||
}
|
||||
let delta = model_greeks(OptionEvaluation {
|
||||
contract: OptionContract {
|
||||
model: context.model,
|
||||
underlying: context.reference_price,
|
||||
strike,
|
||||
rate: context.rate,
|
||||
carry: context.carry,
|
||||
time_to_expiry: context.time_to_expiry,
|
||||
kind: context.kind,
|
||||
},
|
||||
volatility: vol,
|
||||
})
|
||||
.delta;
|
||||
if !delta.is_finite() {
|
||||
continue;
|
||||
}
|
||||
let distance = (delta - target_delta).abs();
|
||||
if distance < best_distance {
|
||||
best_distance = distance;
|
||||
best_iv = vol;
|
||||
}
|
||||
}
|
||||
best_iv
|
||||
}
|
||||
|
||||
/// Smile metrics from a single expiry slice.
|
||||
pub fn smile_metrics(
|
||||
strikes: &[f64],
|
||||
vols: &[f64],
|
||||
reference_price: f64,
|
||||
rate: f64,
|
||||
carry: f64,
|
||||
time_to_expiry: f64,
|
||||
model: PricingModel,
|
||||
) -> SmileMetrics {
|
||||
if strikes.len() != vols.len() || strikes.len() < 3 || reference_price <= 0.0 {
|
||||
return SmileMetrics {
|
||||
atm_iv: f64::NAN,
|
||||
risk_reversal_25d: f64::NAN,
|
||||
butterfly_25d: f64::NAN,
|
||||
skew_slope: f64::NAN,
|
||||
convexity: f64::NAN,
|
||||
};
|
||||
}
|
||||
|
||||
let atm_idx = match atm_index(strikes, reference_price) {
|
||||
Some(idx) => idx,
|
||||
None => {
|
||||
return SmileMetrics {
|
||||
atm_iv: f64::NAN,
|
||||
risk_reversal_25d: f64::NAN,
|
||||
butterfly_25d: f64::NAN,
|
||||
skew_slope: f64::NAN,
|
||||
convexity: f64::NAN,
|
||||
}
|
||||
}
|
||||
};
|
||||
let atm_iv = vols[atm_idx];
|
||||
|
||||
let call_25 = closest_delta_iv(
|
||||
strikes,
|
||||
vols,
|
||||
ChainGreeksContext {
|
||||
model,
|
||||
reference_price,
|
||||
rate,
|
||||
carry,
|
||||
time_to_expiry,
|
||||
kind: OptionKind::Call,
|
||||
},
|
||||
0.25,
|
||||
);
|
||||
let put_25 = closest_delta_iv(
|
||||
strikes,
|
||||
vols,
|
||||
ChainGreeksContext {
|
||||
model,
|
||||
reference_price,
|
||||
rate,
|
||||
carry,
|
||||
time_to_expiry,
|
||||
kind: OptionKind::Put,
|
||||
},
|
||||
-0.25,
|
||||
);
|
||||
let risk_reversal_25d = call_25 - put_25;
|
||||
let butterfly_25d = 0.5 * (call_25 + put_25) - atm_iv;
|
||||
|
||||
let log_moneyness: Vec<f64> = strikes
|
||||
.iter()
|
||||
.map(|&k| (k / reference_price).ln())
|
||||
.collect();
|
||||
let skew_slope = regression_slope(&log_moneyness, vols);
|
||||
let convexity = if atm_idx > 0 && atm_idx + 1 < strikes.len() {
|
||||
let x0 = log_moneyness[atm_idx - 1];
|
||||
let x1 = log_moneyness[atm_idx];
|
||||
let x2 = log_moneyness[atm_idx + 1];
|
||||
let y0 = vols[atm_idx - 1];
|
||||
let y1 = vols[atm_idx];
|
||||
let y2 = vols[atm_idx + 1];
|
||||
let left = if x1 == x0 { 0.0 } else { (y1 - y0) / (x1 - x0) };
|
||||
let right = if x2 == x1 { 0.0 } else { (y2 - y1) / (x2 - x1) };
|
||||
right - left
|
||||
} else {
|
||||
f64::NAN
|
||||
};
|
||||
|
||||
SmileMetrics {
|
||||
atm_iv,
|
||||
risk_reversal_25d,
|
||||
butterfly_25d,
|
||||
skew_slope,
|
||||
convexity,
|
||||
}
|
||||
}
|
||||
|
||||
/// Term-structure slope from (tenor, atm_iv) points.
|
||||
pub fn term_structure_slope(tenors: &[f64], atm_ivs: &[f64]) -> f64 {
|
||||
regression_slope(tenors, atm_ivs)
|
||||
}
|
||||
|
||||
/// Expected ±1σ move over `days_to_expiry` calendar days.
|
||||
///
|
||||
/// Returns `(lower_move, upper_move)` as absolute changes from `spot`.
|
||||
/// Example: if spot=100 and upper_move=5.0 then the 1σ upper bound is 105.
|
||||
///
|
||||
/// Uses the log-normal approximation: `spot × e^{±σ√(days/trading_days)} − spot`.
|
||||
pub fn expected_move(
|
||||
spot: f64,
|
||||
iv: f64,
|
||||
days_to_expiry: f64,
|
||||
trading_days_per_year: f64,
|
||||
) -> (f64, f64) {
|
||||
if !spot.is_finite()
|
||||
|| !iv.is_finite()
|
||||
|| !days_to_expiry.is_finite()
|
||||
|| !trading_days_per_year.is_finite()
|
||||
|| spot <= 0.0
|
||||
|| iv < 0.0
|
||||
|| days_to_expiry < 0.0
|
||||
|| trading_days_per_year <= 0.0
|
||||
{
|
||||
return (f64::NAN, f64::NAN);
|
||||
}
|
||||
let sigma_sqrt_t = iv * (days_to_expiry / trading_days_per_year).sqrt();
|
||||
let upper = spot * sigma_sqrt_t.exp() - spot;
|
||||
let lower = spot * (-sigma_sqrt_t).exp() - spot;
|
||||
(lower, upper)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{atm_iv, smile_metrics, term_structure_slope};
|
||||
use crate::options::PricingModel;
|
||||
|
||||
#[test]
|
||||
fn atm_selection_works() {
|
||||
let strikes = [90.0, 100.0, 110.0];
|
||||
let vols = [0.24, 0.20, 0.22];
|
||||
assert!((atm_iv(&strikes, &vols, 102.0) - 0.20).abs() < 1e-12);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn smile_metrics_are_finite() {
|
||||
let strikes = [80.0, 90.0, 100.0, 110.0, 120.0];
|
||||
let vols = [0.30, 0.25, 0.20, 0.22, 0.27];
|
||||
let metrics = smile_metrics(
|
||||
&strikes,
|
||||
&vols,
|
||||
100.0,
|
||||
0.02,
|
||||
0.0,
|
||||
0.5,
|
||||
PricingModel::BlackScholes,
|
||||
);
|
||||
assert!(metrics.atm_iv.is_finite());
|
||||
assert!(metrics.skew_slope.is_finite());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn term_slope_is_reasonable() {
|
||||
let tenors = [0.1, 0.5, 1.0];
|
||||
let vols = [0.18, 0.20, 0.22];
|
||||
assert!(term_structure_slope(&tenors, &vols) > 0.0);
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,631 @@
|
||||
//! Pure Rust portfolio analytics — no PyO3, no numpy, no ndarray.
|
||||
//!
|
||||
//! Functions:
|
||||
//! - `portfolio_volatility` — sqrt(w' Σ w)
|
||||
//! - `beta_full` — Cov/Var OLS beta
|
||||
//! - `rolling_beta` — rolling beta with NaN warmup
|
||||
//! - `drawdown_series` — per-bar drawdown + max drawdown
|
||||
//! - `correlation_matrix` — pairwise Pearson correlation
|
||||
//! - `relative_strength` — cumulative return ratio
|
||||
//! - `spread` — A - hedge * B
|
||||
//! - `ratio` — A / B (NaN for zero)
|
||||
//! - `zscore_series` — rolling z-score, NaN warmup
|
||||
//! - `compose_weighted` — weighted sum per row
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// portfolio_volatility
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Compute portfolio volatility: sqrt(w' Σ w).
|
||||
///
|
||||
/// `cov_matrix` is an n×n covariance matrix stored as a slice of row-Vecs.
|
||||
/// `weights` has length n.
|
||||
///
|
||||
/// Panics if dimensions are inconsistent.
|
||||
pub fn portfolio_volatility(cov_matrix: &[Vec<f64>], weights: &[f64]) -> f64 {
|
||||
let n = weights.len();
|
||||
assert!(
|
||||
cov_matrix.len() == n,
|
||||
"cov_matrix must have {} rows, got {}",
|
||||
n,
|
||||
cov_matrix.len()
|
||||
);
|
||||
let mut variance = 0.0_f64;
|
||||
for i in 0..n {
|
||||
assert!(
|
||||
cov_matrix[i].len() == n,
|
||||
"cov_matrix row {} must have length {}, got {}",
|
||||
i,
|
||||
n,
|
||||
cov_matrix[i].len()
|
||||
);
|
||||
let mut row_sum = 0.0_f64;
|
||||
for j in 0..n {
|
||||
row_sum += weights[j] * cov_matrix[i][j];
|
||||
}
|
||||
variance += weights[i] * row_sum;
|
||||
}
|
||||
variance.max(0.0).sqrt()
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// beta_full
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Compute the full-sample OLS beta of `asset_returns` vs `benchmark_returns`.
|
||||
///
|
||||
/// Beta = Cov(asset, bench) / Var(bench).
|
||||
///
|
||||
/// Panics if lengths differ or are < 2, or if benchmark has zero variance.
|
||||
pub fn beta_full(asset_returns: &[f64], benchmark_returns: &[f64]) -> f64 {
|
||||
let n = asset_returns.len();
|
||||
assert!(
|
||||
n >= 2 && benchmark_returns.len() == n,
|
||||
"asset_returns and benchmark_returns must have equal length >= 2"
|
||||
);
|
||||
let mean_a: f64 = asset_returns.iter().sum::<f64>() / n as f64;
|
||||
let mean_b: f64 = benchmark_returns.iter().sum::<f64>() / n as f64;
|
||||
let mut cov = 0.0_f64;
|
||||
let mut var_b = 0.0_f64;
|
||||
for i in 0..n {
|
||||
let da = asset_returns[i] - mean_a;
|
||||
let db = benchmark_returns[i] - mean_b;
|
||||
cov += da * db;
|
||||
var_b += db * db;
|
||||
}
|
||||
assert!(
|
||||
var_b != 0.0,
|
||||
"benchmark_returns has zero variance; cannot compute beta"
|
||||
);
|
||||
cov / var_b
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// rolling_beta
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Compute rolling beta of `asset` vs `benchmark` over a sliding `window`.
|
||||
///
|
||||
/// Returns a Vec of the same length as the inputs. The first `window - 1`
|
||||
/// entries are NaN (warmup period). `window` must be >= 2.
|
||||
pub fn rolling_beta(asset: &[f64], benchmark: &[f64], window: usize) -> Vec<f64> {
|
||||
assert!(window >= 2, "window must be >= 2");
|
||||
let n = asset.len();
|
||||
assert!(
|
||||
n > 0 && benchmark.len() == n,
|
||||
"asset and benchmark must be non-empty and equal length"
|
||||
);
|
||||
let mut result = vec![f64::NAN; n];
|
||||
for i in (window - 1)..n {
|
||||
let start = i + 1 - window;
|
||||
let a_win = &asset[start..=i];
|
||||
let b_win = &benchmark[start..=i];
|
||||
let mean_a: f64 = a_win.iter().sum::<f64>() / window as f64;
|
||||
let mean_b: f64 = b_win.iter().sum::<f64>() / window as f64;
|
||||
let mut cov = 0.0_f64;
|
||||
let mut var_b = 0.0_f64;
|
||||
for k in 0..window {
|
||||
let da = a_win[k] - mean_a;
|
||||
let db = b_win[k] - mean_b;
|
||||
cov += da * db;
|
||||
var_b += db * db;
|
||||
}
|
||||
result[i] = if var_b == 0.0 { f64::NAN } else { cov / var_b };
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// drawdown_series
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Compute the drawdown series and maximum drawdown for an equity/price series.
|
||||
///
|
||||
/// Drawdown at bar i = (equity[i] - running_max) / running_max (always <= 0).
|
||||
///
|
||||
/// Returns `(dd_array, max_dd)` where `max_dd` is the most negative drawdown.
|
||||
///
|
||||
/// Panics if `equity` is empty.
|
||||
pub fn drawdown_series(equity: &[f64]) -> (Vec<f64>, f64) {
|
||||
let n = equity.len();
|
||||
assert!(n > 0, "equity must be non-empty");
|
||||
let mut dd = vec![0.0_f64; n];
|
||||
let mut peak = equity[0];
|
||||
let mut max_dd = 0.0_f64;
|
||||
for i in 0..n {
|
||||
if equity[i] > peak {
|
||||
peak = equity[i];
|
||||
}
|
||||
let d = if peak == 0.0 {
|
||||
0.0
|
||||
} else {
|
||||
(equity[i] - peak) / peak
|
||||
};
|
||||
dd[i] = d;
|
||||
if d < max_dd {
|
||||
max_dd = d;
|
||||
}
|
||||
}
|
||||
(dd, max_dd)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// correlation_matrix
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Compute the pairwise Pearson correlation matrix.
|
||||
///
|
||||
/// `data` is a slice of column vectors — `data[j]` is the return series for
|
||||
/// asset j, so `data[j][i]` is the return of asset j at bar i. All columns
|
||||
/// must have the same length (>= 2).
|
||||
///
|
||||
/// Returns an n_assets × n_assets matrix stored as `Vec<Vec<f64>>`.
|
||||
pub fn correlation_matrix(data: &[Vec<f64>]) -> Vec<Vec<f64>> {
|
||||
let n_assets = data.len();
|
||||
assert!(n_assets > 0, "data must contain at least one asset column");
|
||||
let n_bars = data[0].len();
|
||||
assert!(n_bars >= 2, "data must have at least 2 rows (bars)");
|
||||
#[allow(clippy::needless_range_loop)]
|
||||
for j in 1..n_assets {
|
||||
assert!(
|
||||
data[j].len() == n_bars,
|
||||
"all columns must have equal length; column 0 has {} but column {} has {}",
|
||||
n_bars,
|
||||
j,
|
||||
data[j].len()
|
||||
);
|
||||
}
|
||||
|
||||
// Means
|
||||
let mut means = vec![0.0_f64; n_assets];
|
||||
for j in 0..n_assets {
|
||||
means[j] = data[j].iter().sum::<f64>() / n_bars as f64;
|
||||
}
|
||||
|
||||
// Standard deviations (population)
|
||||
let mut stds = vec![0.0_f64; n_assets];
|
||||
for j in 0..n_assets {
|
||||
let var: f64 = data[j].iter().map(|&v| (v - means[j]).powi(2)).sum::<f64>() / n_bars as f64;
|
||||
stds[j] = var.sqrt();
|
||||
}
|
||||
|
||||
// Build correlation matrix (exploit symmetry: compute each pair once)
|
||||
let mut result = vec![vec![0.0_f64; n_assets]; n_assets];
|
||||
#[allow(clippy::needless_range_loop)]
|
||||
for j1 in 0..n_assets {
|
||||
result[j1][j1] = 1.0;
|
||||
for j2 in (j1 + 1)..n_assets {
|
||||
let mut cov = 0.0_f64;
|
||||
for i in 0..n_bars {
|
||||
cov += (data[j1][i] - means[j1]) * (data[j2][i] - means[j2]);
|
||||
}
|
||||
cov /= n_bars as f64;
|
||||
let denom = stds[j1] * stds[j2];
|
||||
let corr = if denom == 0.0 { f64::NAN } else { cov / denom };
|
||||
result[j1][j2] = corr;
|
||||
result[j2][j1] = corr;
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// relative_strength
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Compute relative strength of an asset vs a benchmark.
|
||||
///
|
||||
/// result[i] = cumprod(1 + asset_returns[0..=i]) / cumprod(1 + benchmark_returns[0..=i])
|
||||
///
|
||||
/// Panics if lengths differ or are zero.
|
||||
pub fn relative_strength(asset_returns: &[f64], benchmark_returns: &[f64]) -> Vec<f64> {
|
||||
let n = asset_returns.len();
|
||||
assert!(
|
||||
n > 0 && benchmark_returns.len() == n,
|
||||
"asset_returns and benchmark_returns must be non-empty and equal length"
|
||||
);
|
||||
let mut result = vec![0.0_f64; n];
|
||||
let mut cum_a = 1.0_f64;
|
||||
let mut cum_b = 1.0_f64;
|
||||
for i in 0..n {
|
||||
cum_a *= 1.0 + asset_returns[i];
|
||||
cum_b *= 1.0 + benchmark_returns[i];
|
||||
result[i] = if cum_b == 0.0 {
|
||||
f64::NAN
|
||||
} else {
|
||||
cum_a / cum_b
|
||||
};
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// spread
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Compute the spread between two series: a - hedge * b.
|
||||
///
|
||||
/// Panics if lengths differ or are zero.
|
||||
pub fn spread(a: &[f64], b: &[f64], hedge: f64) -> Vec<f64> {
|
||||
let n = a.len();
|
||||
assert!(
|
||||
n > 0 && b.len() == n,
|
||||
"a and b must be non-empty and equal length"
|
||||
);
|
||||
a.iter()
|
||||
.zip(b.iter())
|
||||
.map(|(&x, &y)| x - hedge * y)
|
||||
.collect()
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// ratio
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Compute the ratio between two series: a / b.
|
||||
///
|
||||
/// Where b is 0, returns NaN.
|
||||
///
|
||||
/// Panics if lengths differ or are zero.
|
||||
pub fn ratio(a: &[f64], b: &[f64]) -> Vec<f64> {
|
||||
let n = a.len();
|
||||
assert!(
|
||||
n > 0 && b.len() == n,
|
||||
"a and b must be non-empty and equal length"
|
||||
);
|
||||
a.iter()
|
||||
.zip(b.iter())
|
||||
.map(|(&x, &y)| if y == 0.0 { f64::NAN } else { x / y })
|
||||
.collect()
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// zscore_series
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Compute the rolling Z-score of a 1-D series.
|
||||
///
|
||||
/// Z[i] = (x[i] - mean(window)) / std(window)
|
||||
///
|
||||
/// The first `window - 1` entries are NaN. `window` must be >= 2.
|
||||
///
|
||||
/// Panics if `x` is empty or `window < 2`.
|
||||
pub fn zscore_series(x: &[f64], window: usize) -> Vec<f64> {
|
||||
assert!(window >= 2, "window must be >= 2");
|
||||
let n = x.len();
|
||||
assert!(n > 0, "x must be non-empty");
|
||||
let mut result = vec![f64::NAN; n];
|
||||
for i in (window - 1)..n {
|
||||
let win = &x[i + 1 - window..=i];
|
||||
let mean: f64 = win.iter().sum::<f64>() / window as f64;
|
||||
let var: f64 = win.iter().map(|v| (v - mean).powi(2)).sum::<f64>() / window as f64;
|
||||
let std = var.sqrt();
|
||||
result[i] = if std == 0.0 {
|
||||
f64::NAN
|
||||
} else {
|
||||
(x[i] - mean) / std
|
||||
};
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// compose_weighted
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Weighted combination of multiple signal columns.
|
||||
///
|
||||
/// `data` is a slice of column vectors — `data[j]` is one signal column.
|
||||
/// `weights` has one entry per column.
|
||||
///
|
||||
/// Returns a Vec of length n_bars where each entry is the weighted sum across
|
||||
/// columns for that bar.
|
||||
///
|
||||
/// Panics if weights length != number of columns, or columns have unequal lengths.
|
||||
pub fn compose_weighted(data: &[Vec<f64>], weights: &[f64]) -> Vec<f64> {
|
||||
let n_sigs = data.len();
|
||||
assert!(
|
||||
weights.len() == n_sigs,
|
||||
"weights length ({}) must equal number of signal columns ({})",
|
||||
weights.len(),
|
||||
n_sigs
|
||||
);
|
||||
if n_sigs == 0 {
|
||||
return vec![];
|
||||
}
|
||||
let n_bars = data[0].len();
|
||||
#[allow(clippy::needless_range_loop)]
|
||||
for j in 1..n_sigs {
|
||||
assert!(
|
||||
data[j].len() == n_bars,
|
||||
"all columns must have equal length"
|
||||
);
|
||||
}
|
||||
let mut result = vec![0.0_f64; n_bars];
|
||||
for i in 0..n_bars {
|
||||
let mut s = 0.0_f64;
|
||||
for j in 0..n_sigs {
|
||||
s += data[j][i] * weights[j];
|
||||
}
|
||||
result[i] = s;
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
const EPS: f64 = 1e-10;
|
||||
|
||||
fn approx_eq(a: f64, b: f64) -> bool {
|
||||
(a - b).abs() < EPS
|
||||
}
|
||||
|
||||
// -- portfolio_volatility -------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn test_portfolio_volatility_identity_cov() {
|
||||
// Identity covariance, equal weights => sqrt(sum(w_i^2))
|
||||
let cov = vec![vec![1.0, 0.0], vec![0.0, 1.0]];
|
||||
let w = vec![0.5, 0.5];
|
||||
let vol = portfolio_volatility(&cov, &w);
|
||||
// w' I w = 0.25 + 0.25 = 0.5, sqrt = 0.7071...
|
||||
assert!(approx_eq(vol, (0.5_f64).sqrt()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_portfolio_volatility_single_asset() {
|
||||
let cov = vec![vec![0.04]];
|
||||
let w = vec![1.0];
|
||||
assert!(approx_eq(portfolio_volatility(&cov, &w), 0.2));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_portfolio_volatility_correlated() {
|
||||
// Fully correlated: cov = [[0.04, 0.04], [0.04, 0.04]]
|
||||
let cov = vec![vec![0.04, 0.04], vec![0.04, 0.04]];
|
||||
let w = vec![0.5, 0.5];
|
||||
// w' Σ w = 0.04, sqrt = 0.2
|
||||
let vol = portfolio_volatility(&cov, &w);
|
||||
assert!(approx_eq(vol, 0.2));
|
||||
}
|
||||
|
||||
// -- beta_full ------------------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn test_beta_full_same_series() {
|
||||
let r = vec![0.01, -0.02, 0.03, -0.01, 0.02];
|
||||
assert!(approx_eq(beta_full(&r, &r), 1.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_beta_full_double() {
|
||||
let bench = vec![0.01, -0.02, 0.03, -0.01, 0.02];
|
||||
let asset: Vec<f64> = bench.iter().map(|x| x * 2.0).collect();
|
||||
assert!(approx_eq(beta_full(&asset, &bench), 2.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn test_beta_full_zero_variance() {
|
||||
let a = vec![0.01, 0.02];
|
||||
let b = vec![0.05, 0.05]; // zero variance
|
||||
beta_full(&a, &b);
|
||||
}
|
||||
|
||||
// -- rolling_beta ---------------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn test_rolling_beta_warmup_nan() {
|
||||
let a = vec![0.01, -0.02, 0.03, -0.01, 0.02];
|
||||
let b = vec![0.01, -0.02, 0.03, -0.01, 0.02];
|
||||
let rb = rolling_beta(&a, &b, 3);
|
||||
assert_eq!(rb.len(), 5);
|
||||
assert!(rb[0].is_nan());
|
||||
assert!(rb[1].is_nan());
|
||||
// From index 2 onward, beta of identical series = 1.0
|
||||
assert!(approx_eq(rb[2], 1.0));
|
||||
assert!(approx_eq(rb[3], 1.0));
|
||||
assert!(approx_eq(rb[4], 1.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rolling_beta_double() {
|
||||
let bench = vec![0.01, -0.02, 0.03, -0.01, 0.02];
|
||||
let asset: Vec<f64> = bench.iter().map(|x| x * 3.0).collect();
|
||||
let rb = rolling_beta(&asset, &bench, 3);
|
||||
for i in 2..5 {
|
||||
assert!(approx_eq(rb[i], 3.0));
|
||||
}
|
||||
}
|
||||
|
||||
// -- drawdown_series ------------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn test_drawdown_series_monotonic_up() {
|
||||
let eq = vec![100.0, 110.0, 120.0, 130.0];
|
||||
let (dd, max_dd) = drawdown_series(&eq);
|
||||
for &d in &dd {
|
||||
assert!(approx_eq(d, 0.0));
|
||||
}
|
||||
assert!(approx_eq(max_dd, 0.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_drawdown_series_with_dip() {
|
||||
let eq = vec![100.0, 120.0, 90.0, 110.0];
|
||||
let (dd, max_dd) = drawdown_series(&eq);
|
||||
assert!(approx_eq(dd[0], 0.0));
|
||||
assert!(approx_eq(dd[1], 0.0));
|
||||
// dd[2] = (90 - 120) / 120 = -0.25
|
||||
assert!(approx_eq(dd[2], -0.25));
|
||||
// dd[3] = (110 - 120) / 120 = -1/12
|
||||
assert!((dd[3] - (-1.0 / 12.0)).abs() < EPS);
|
||||
assert!(approx_eq(max_dd, -0.25));
|
||||
}
|
||||
|
||||
// -- correlation_matrix ---------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn test_correlation_matrix_identical() {
|
||||
let col = vec![0.01, -0.02, 0.03, -0.01, 0.02];
|
||||
let data = vec![col.clone(), col.clone()];
|
||||
let cm = correlation_matrix(&data);
|
||||
assert_eq!(cm.len(), 2);
|
||||
assert!(approx_eq(cm[0][0], 1.0));
|
||||
assert!(approx_eq(cm[1][1], 1.0));
|
||||
assert!(approx_eq(cm[0][1], 1.0));
|
||||
assert!(approx_eq(cm[1][0], 1.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_correlation_matrix_negatively_correlated() {
|
||||
let col_a = vec![1.0, 2.0, 3.0, 4.0, 5.0];
|
||||
let col_b: Vec<f64> = col_a.iter().map(|x| -x).collect();
|
||||
let data = vec![col_a, col_b];
|
||||
let cm = correlation_matrix(&data);
|
||||
assert!(approx_eq(cm[0][1], -1.0));
|
||||
assert!(approx_eq(cm[1][0], -1.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_correlation_matrix_single_asset() {
|
||||
let data = vec![vec![1.0, 2.0, 3.0]];
|
||||
let cm = correlation_matrix(&data);
|
||||
assert_eq!(cm.len(), 1);
|
||||
assert!(approx_eq(cm[0][0], 1.0));
|
||||
}
|
||||
|
||||
// -- relative_strength ----------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn test_relative_strength_equal() {
|
||||
let r = vec![0.01, -0.02, 0.03];
|
||||
let rs = relative_strength(&r, &r);
|
||||
for &v in &rs {
|
||||
assert!(approx_eq(v, 1.0));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_relative_strength_outperformance() {
|
||||
let a = vec![0.10, 0.10];
|
||||
let b = vec![0.05, 0.05];
|
||||
let rs = relative_strength(&a, &b);
|
||||
// rs[0] = 1.10 / 1.05
|
||||
assert!((rs[0] - 1.10 / 1.05).abs() < EPS);
|
||||
// rs[1] = 1.21 / 1.1025
|
||||
assert!((rs[1] - 1.21 / 1.1025).abs() < EPS);
|
||||
}
|
||||
|
||||
// -- spread ---------------------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn test_spread_basic() {
|
||||
let a = vec![10.0, 20.0, 30.0];
|
||||
let b = vec![5.0, 10.0, 15.0];
|
||||
let s = spread(&a, &b, 2.0);
|
||||
assert!(approx_eq(s[0], 0.0));
|
||||
assert!(approx_eq(s[1], 0.0));
|
||||
assert!(approx_eq(s[2], 0.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_spread_hedge_one() {
|
||||
let a = vec![10.0, 20.0];
|
||||
let b = vec![3.0, 7.0];
|
||||
let s = spread(&a, &b, 1.0);
|
||||
assert!(approx_eq(s[0], 7.0));
|
||||
assert!(approx_eq(s[1], 13.0));
|
||||
}
|
||||
|
||||
// -- ratio ----------------------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn test_ratio_basic() {
|
||||
let a = vec![10.0, 20.0, 30.0];
|
||||
let b = vec![5.0, 10.0, 15.0];
|
||||
let r = ratio(&a, &b);
|
||||
assert!(approx_eq(r[0], 2.0));
|
||||
assert!(approx_eq(r[1], 2.0));
|
||||
assert!(approx_eq(r[2], 2.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ratio_zero_denominator() {
|
||||
let a = vec![10.0, 20.0];
|
||||
let b = vec![0.0, 5.0];
|
||||
let r = ratio(&a, &b);
|
||||
assert!(r[0].is_nan());
|
||||
assert!(approx_eq(r[1], 4.0));
|
||||
}
|
||||
|
||||
// -- zscore_series --------------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn test_zscore_warmup_nan() {
|
||||
let x = vec![1.0, 2.0, 3.0, 4.0, 5.0];
|
||||
let z = zscore_series(&x, 3);
|
||||
assert!(z[0].is_nan());
|
||||
assert!(z[1].is_nan());
|
||||
assert!(!z[2].is_nan());
|
||||
assert!(!z[3].is_nan());
|
||||
assert!(!z[4].is_nan());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_zscore_constant_window() {
|
||||
// All same values in window => std = 0 => NaN
|
||||
let x = vec![5.0, 5.0, 5.0, 5.0];
|
||||
let z = zscore_series(&x, 3);
|
||||
assert!(z[2].is_nan());
|
||||
assert!(z[3].is_nan());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_zscore_known_value() {
|
||||
// Window [1, 2, 3]: mean=2, pop_std = sqrt(2/3) ~0.8165
|
||||
// z = (3 - 2) / sqrt(2/3) = sqrt(3/2) ~ 1.2247
|
||||
let x = vec![1.0, 2.0, 3.0];
|
||||
let z = zscore_series(&x, 3);
|
||||
let expected = (3.0_f64 / 2.0).sqrt();
|
||||
assert!((z[2] - expected).abs() < EPS);
|
||||
}
|
||||
|
||||
// -- compose_weighted -----------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn test_compose_weighted_basic() {
|
||||
let data = vec![vec![1.0, 2.0, 3.0], vec![4.0, 5.0, 6.0]];
|
||||
let weights = vec![0.3, 0.7];
|
||||
let cw = compose_weighted(&data, &weights);
|
||||
// bar 0: 1*0.3 + 4*0.7 = 3.1
|
||||
assert!(approx_eq(cw[0], 3.1));
|
||||
// bar 1: 2*0.3 + 5*0.7 = 4.1
|
||||
assert!(approx_eq(cw[1], 4.1));
|
||||
// bar 2: 3*0.3 + 6*0.7 = 5.1
|
||||
assert!(approx_eq(cw[2], 5.1));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_compose_weighted_single_column() {
|
||||
let data = vec![vec![10.0, 20.0]];
|
||||
let weights = vec![2.0];
|
||||
let cw = compose_weighted(&data, &weights);
|
||||
assert!(approx_eq(cw[0], 20.0));
|
||||
assert!(approx_eq(cw[1], 40.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_compose_weighted_empty() {
|
||||
let data: Vec<Vec<f64>> = vec![];
|
||||
let weights: Vec<f64> = vec![];
|
||||
let cw = compose_weighted(&data, &weights);
|
||||
assert!(cw.is_empty());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,89 @@
|
||||
//! Price transformations — synthesize OHLC arrays into single price arrays.
|
||||
|
||||
/// Average Price: (open + high + low + close) / 4.
|
||||
pub fn avgprice(open: &[f64], high: &[f64], low: &[f64], close: &[f64]) -> Vec<f64> {
|
||||
open.iter()
|
||||
.zip(high.iter())
|
||||
.zip(low.iter())
|
||||
.zip(close.iter())
|
||||
.map(|(((&o, &h), &l), &c)| (o + h + l + c) / 4.0)
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Median Price: (high + low) / 2.
|
||||
pub fn medprice(high: &[f64], low: &[f64]) -> Vec<f64> {
|
||||
high.iter()
|
||||
.zip(low.iter())
|
||||
.map(|(&h, &l)| (h + l) / 2.0)
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Typical Price: (high + low + close) / 3.
|
||||
pub fn typprice(high: &[f64], low: &[f64], close: &[f64]) -> Vec<f64> {
|
||||
high.iter()
|
||||
.zip(low.iter())
|
||||
.zip(close.iter())
|
||||
.map(|((&h, &l), &c)| (h + l + c) / 3.0)
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Weighted Close Price: (high + low + close * 2) / 4.
|
||||
pub fn wclprice(high: &[f64], low: &[f64], close: &[f64]) -> Vec<f64> {
|
||||
high.iter()
|
||||
.zip(low.iter())
|
||||
.zip(close.iter())
|
||||
.map(|((&h, &l), &c)| (h + l + c * 2.0) / 4.0)
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_avgprice() {
|
||||
let o = vec![1.0, 2.0, 3.0];
|
||||
let h = vec![4.0, 5.0, 6.0];
|
||||
let l = vec![0.5, 1.5, 2.5];
|
||||
let c = vec![2.5, 3.5, 4.5];
|
||||
let result = avgprice(&o, &h, &l, &c);
|
||||
assert_eq!(result.len(), 3);
|
||||
assert!((result[0] - 2.0).abs() < 1e-10); // (1+4+0.5+2.5)/4 = 2.0
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_medprice() {
|
||||
let h = vec![10.0, 20.0];
|
||||
let l = vec![6.0, 12.0];
|
||||
let result = medprice(&h, &l);
|
||||
assert!((result[0] - 8.0).abs() < 1e-10);
|
||||
assert!((result[1] - 16.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_typprice() {
|
||||
let h = vec![10.0];
|
||||
let l = vec![6.0];
|
||||
let c = vec![8.0];
|
||||
let result = typprice(&h, &l, &c);
|
||||
assert!((result[0] - 8.0).abs() < 1e-10); // (10+6+8)/3 = 8.0
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_wclprice() {
|
||||
let h = vec![10.0];
|
||||
let l = vec![6.0];
|
||||
let c = vec![8.0];
|
||||
let result = wclprice(&h, &l, &c);
|
||||
assert!((result[0] - 8.0).abs() < 1e-10); // (10+6+16)/4 = 8.0
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_empty_inputs() {
|
||||
let empty: Vec<f64> = vec![];
|
||||
assert!(avgprice(&empty, &empty, &empty, &empty).is_empty());
|
||||
assert!(medprice(&empty, &empty).is_empty());
|
||||
assert!(typprice(&empty, &empty, &empty).is_empty());
|
||||
assert!(wclprice(&empty, &empty, &empty).is_empty());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,166 @@
|
||||
//! Regime detection and structural breaks.
|
||||
//!
|
||||
//! - `regime_adx` — label trend (1) vs range (0) using ADX threshold
|
||||
//! - `regime_combined` — combine ADX + ATR-ratio for robust regime labelling
|
||||
//! - `detect_breaks_cusum` — CUSUM-based structural break detection
|
||||
//! - `rolling_variance_break` — variance ratio break detection
|
||||
|
||||
/// Label each bar as trend (1) or range (0) based on ADX level.
|
||||
///
|
||||
/// Returns `Vec<i8>`: `1` = trend (ADX > threshold), `0` = range, `-1` = NaN/warmup.
|
||||
pub fn regime_adx(adx: &[f64], threshold: f64) -> Vec<i8> {
|
||||
adx.iter()
|
||||
.map(|&v| {
|
||||
if v.is_nan() {
|
||||
-1i8
|
||||
} else if v > threshold {
|
||||
1i8
|
||||
} else {
|
||||
0i8
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Label each bar as trend (1) or range (0) using ADX + ATR-ratio rule.
|
||||
///
|
||||
/// A bar is trending when: `adx[i] > adx_threshold` AND `atr[i] / close[i] > atr_pct_threshold`.
|
||||
///
|
||||
/// Returns `Vec<i8>`: `1` = trend, `0` = range, `-1` = NaN.
|
||||
pub fn regime_combined(
|
||||
adx: &[f64],
|
||||
atr: &[f64],
|
||||
close: &[f64],
|
||||
adx_threshold: f64,
|
||||
atr_pct_threshold: f64,
|
||||
) -> Vec<i8> {
|
||||
let n = adx.len();
|
||||
(0..n)
|
||||
.map(|i| {
|
||||
let av = adx[i];
|
||||
let rv = atr[i];
|
||||
let cv = close[i];
|
||||
if av.is_nan() || rv.is_nan() || cv.is_nan() || cv == 0.0 {
|
||||
-1i8
|
||||
} else if av > adx_threshold && (rv / cv) > atr_pct_threshold {
|
||||
1i8
|
||||
} else {
|
||||
0i8
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Detect structural breaks using a CUSUM (cumulative sum) approach.
|
||||
///
|
||||
/// `window` must be >= 2. Returns `Vec<i8>`: `1` at break bars, `0` elsewhere.
|
||||
pub fn detect_breaks_cusum(series: &[f64], window: usize, threshold: f64, slack: f64) -> Vec<i8> {
|
||||
let n = series.len();
|
||||
let mut out = vec![0i8; n];
|
||||
if n < window || window < 2 {
|
||||
return out;
|
||||
}
|
||||
let mut cusum_pos = 0.0_f64;
|
||||
let mut cusum_neg = 0.0_f64;
|
||||
for i in window..n {
|
||||
let slice = &series[(i - window)..i];
|
||||
let mean: f64 = slice.iter().sum::<f64>() / window as f64;
|
||||
let var: f64 =
|
||||
slice.iter().map(|&v| (v - mean) * (v - mean)).sum::<f64>() / (window - 1) as f64;
|
||||
let std = var.sqrt();
|
||||
if std == 0.0 || std.is_nan() || series[i].is_nan() {
|
||||
continue;
|
||||
}
|
||||
let z = (series[i] - mean) / std;
|
||||
cusum_pos = (cusum_pos + z - slack).max(0.0);
|
||||
cusum_neg = (cusum_neg - z - slack).max(0.0);
|
||||
if cusum_pos > threshold || cusum_neg > threshold {
|
||||
out[i] = 1;
|
||||
cusum_pos = 0.0;
|
||||
cusum_neg = 0.0;
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Detect volatility regime breaks using rolling variance ratio.
|
||||
///
|
||||
/// `short_window` must be >= 2, `long_window` must be > `short_window`.
|
||||
/// Returns `Vec<i8>`: `1` at break bars, `0` elsewhere.
|
||||
pub fn rolling_variance_break(
|
||||
series: &[f64],
|
||||
short_window: usize,
|
||||
long_window: usize,
|
||||
threshold: f64,
|
||||
) -> Vec<i8> {
|
||||
let n = series.len();
|
||||
let mut out = vec![0i8; n];
|
||||
if n < long_window || short_window < 2 || long_window <= short_window {
|
||||
return out;
|
||||
}
|
||||
|
||||
let variance = |slice: &[f64]| -> f64 {
|
||||
let k = slice.len();
|
||||
let mean: f64 = slice.iter().sum::<f64>() / k as f64;
|
||||
slice.iter().map(|&v| (v - mean) * (v - mean)).sum::<f64>() / (k - 1) as f64
|
||||
};
|
||||
|
||||
for i in long_window..n {
|
||||
let long_slice = &series[(i - long_window)..i];
|
||||
let short_slice = &series[(i - short_window)..i];
|
||||
let long_var = variance(long_slice);
|
||||
let short_var = variance(short_slice);
|
||||
if long_var == 0.0 || long_var.is_nan() || short_var.is_nan() {
|
||||
continue;
|
||||
}
|
||||
if short_var / long_var > threshold {
|
||||
out[i] = 1;
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_regime_adx_basic() {
|
||||
let adx = vec![f64::NAN, 20.0, 30.0, 10.0, 50.0];
|
||||
let result = regime_adx(&adx, 25.0);
|
||||
assert_eq!(result, vec![-1, 0, 1, 0, 1]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_regime_combined() {
|
||||
let adx = vec![30.0, 30.0, 10.0];
|
||||
let atr = vec![1.0, 0.001, 1.0];
|
||||
let close = vec![100.0, 100.0, 100.0];
|
||||
let result = regime_combined(&adx, &atr, &close, 25.0, 0.005);
|
||||
assert_eq!(result[0], 1); // ADX>25 and ATR/close=0.01>0.005
|
||||
assert_eq!(result[1], 0); // ATR/close=0.00001 < 0.005
|
||||
assert_eq!(result[2], 0); // ADX<25
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_detect_breaks_cusum_short_input() {
|
||||
let series = vec![1.0, 2.0];
|
||||
let result = detect_breaks_cusum(&series, 5, 3.0, 0.5);
|
||||
assert!(result.iter().all(|&v| v == 0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rolling_variance_break_short_input() {
|
||||
let series = vec![1.0, 2.0, 3.0];
|
||||
let result = rolling_variance_break(&series, 2, 5, 2.0);
|
||||
assert!(result.iter().all(|&v| v == 0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_empty() {
|
||||
assert!(regime_adx(&[], 25.0).is_empty());
|
||||
assert!(regime_combined(&[], &[], &[], 25.0, 0.005).is_empty());
|
||||
assert!(detect_breaks_cusum(&[], 2, 3.0, 0.5).is_empty());
|
||||
assert!(rolling_variance_break(&[], 2, 5, 2.0).is_empty());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,277 @@
|
||||
//! Resampling — OHLCV resampling and multi-timeframe helpers, pure Rust.
|
||||
//!
|
||||
//! # Functions
|
||||
//! - `volume_bars` — Aggregate OHLCV bars into bars of fixed volume size.
|
||||
//! - `ohlcv_agg` — Aggregate OHLCV bars given contiguous integer group labels.
|
||||
|
||||
/// OHLCV 5-tuple return type alias.
|
||||
type Ohlcv5 = (Vec<f64>, Vec<f64>, Vec<f64>, Vec<f64>, Vec<f64>);
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// volume_bars
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Aggregate OHLCV data into volume bars of a fixed volume threshold.
|
||||
///
|
||||
/// Each output bar accumulates input bars until `volume_threshold` units of
|
||||
/// volume have been consumed. The resulting bar has:
|
||||
/// - open = first open of the group
|
||||
/// - high = max high of the group
|
||||
/// - low = min low of the group
|
||||
/// - close = last close of the group
|
||||
/// - volume = sum of volumes (approximately `volume_threshold`)
|
||||
///
|
||||
/// Returns `(open, high, low, close, volume)`.
|
||||
///
|
||||
/// # Panics
|
||||
/// Panics if arrays are empty, have unequal lengths, or `volume_threshold <= 0`.
|
||||
pub fn volume_bars(
|
||||
open: &[f64],
|
||||
high: &[f64],
|
||||
low: &[f64],
|
||||
close: &[f64],
|
||||
volume: &[f64],
|
||||
volume_threshold: f64,
|
||||
) -> Ohlcv5 {
|
||||
assert!(volume_threshold > 0.0, "volume_threshold must be > 0");
|
||||
let n = open.len();
|
||||
assert!(n > 0, "input arrays must be non-empty");
|
||||
assert!(
|
||||
high.len() == n && low.len() == n && close.len() == n && volume.len() == n,
|
||||
"all input arrays must have equal length"
|
||||
);
|
||||
|
||||
let mut out_open: Vec<f64> = Vec::new();
|
||||
let mut out_high: Vec<f64> = Vec::new();
|
||||
let mut out_low: Vec<f64> = Vec::new();
|
||||
let mut out_close: Vec<f64> = Vec::new();
|
||||
let mut out_vol: Vec<f64> = Vec::new();
|
||||
|
||||
let mut bar_open = open[0];
|
||||
let mut bar_high = high[0];
|
||||
let mut bar_low = low[0];
|
||||
let mut bar_close = close[0];
|
||||
let mut bar_vol = volume[0];
|
||||
|
||||
for i in 1..n {
|
||||
bar_high = bar_high.max(high[i]);
|
||||
bar_low = bar_low.min(low[i]);
|
||||
bar_close = close[i];
|
||||
bar_vol += volume[i];
|
||||
|
||||
if bar_vol >= volume_threshold {
|
||||
out_open.push(bar_open);
|
||||
out_high.push(bar_high);
|
||||
out_low.push(bar_low);
|
||||
out_close.push(bar_close);
|
||||
out_vol.push(bar_vol);
|
||||
// Start new bar
|
||||
if i + 1 < n {
|
||||
bar_open = open[i + 1];
|
||||
bar_high = high[i + 1];
|
||||
bar_low = low[i + 1];
|
||||
bar_close = close[i + 1];
|
||||
bar_vol = volume[i + 1];
|
||||
}
|
||||
}
|
||||
}
|
||||
// Push any remaining partial bar
|
||||
if bar_vol > 0.0 && out_vol.last().is_none_or(|&last| last != bar_vol) {
|
||||
out_open.push(bar_open);
|
||||
out_high.push(bar_high);
|
||||
out_low.push(bar_low);
|
||||
out_close.push(bar_close);
|
||||
out_vol.push(bar_vol);
|
||||
}
|
||||
|
||||
(out_open, out_high, out_low, out_close, out_vol)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// ohlcv_agg
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Aggregate OHLCV bars by integer group labels.
|
||||
///
|
||||
/// Groups consecutive bars with the same label and computes:
|
||||
/// - open = first open of the group
|
||||
/// - high = max high of the group
|
||||
/// - low = min low of the group
|
||||
/// - close = last close of the group
|
||||
/// - volume = sum of volumes
|
||||
///
|
||||
/// `labels` must be non-decreasing (groups are contiguous).
|
||||
///
|
||||
/// Returns `(open, high, low, close, volume)`.
|
||||
///
|
||||
/// # Panics
|
||||
/// Panics if arrays are empty or have unequal lengths.
|
||||
pub fn ohlcv_agg(
|
||||
open: &[f64],
|
||||
high: &[f64],
|
||||
low: &[f64],
|
||||
close: &[f64],
|
||||
volume: &[f64],
|
||||
labels: &[i64],
|
||||
) -> Ohlcv5 {
|
||||
let n = open.len();
|
||||
assert!(n > 0, "input arrays must be non-empty");
|
||||
assert!(
|
||||
high.len() == n
|
||||
&& low.len() == n
|
||||
&& close.len() == n
|
||||
&& volume.len() == n
|
||||
&& labels.len() == n,
|
||||
"all input arrays must have equal length"
|
||||
);
|
||||
|
||||
let mut out_open: Vec<f64> = Vec::new();
|
||||
let mut out_high: Vec<f64> = Vec::new();
|
||||
let mut out_low: Vec<f64> = Vec::new();
|
||||
let mut out_close: Vec<f64> = Vec::new();
|
||||
let mut out_vol: Vec<f64> = Vec::new();
|
||||
|
||||
let mut cur_label = labels[0];
|
||||
let mut bar_open = open[0];
|
||||
let mut bar_high = high[0];
|
||||
let mut bar_low = low[0];
|
||||
let mut bar_close = close[0];
|
||||
let mut bar_vol = volume[0];
|
||||
|
||||
for i in 1..n {
|
||||
if labels[i] != cur_label {
|
||||
out_open.push(bar_open);
|
||||
out_high.push(bar_high);
|
||||
out_low.push(bar_low);
|
||||
out_close.push(bar_close);
|
||||
out_vol.push(bar_vol);
|
||||
cur_label = labels[i];
|
||||
bar_open = open[i];
|
||||
bar_high = high[i];
|
||||
bar_low = low[i];
|
||||
bar_close = close[i];
|
||||
bar_vol = volume[i];
|
||||
} else {
|
||||
bar_high = bar_high.max(high[i]);
|
||||
bar_low = bar_low.min(low[i]);
|
||||
bar_close = close[i];
|
||||
bar_vol += volume[i];
|
||||
}
|
||||
}
|
||||
out_open.push(bar_open);
|
||||
out_high.push(bar_high);
|
||||
out_low.push(bar_low);
|
||||
out_close.push(bar_close);
|
||||
out_vol.push(bar_vol);
|
||||
|
||||
(out_open, out_high, out_low, out_close, out_vol)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
// -- volume_bars ---------------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn test_volume_bars_basic() {
|
||||
let o = [100.0, 101.0, 102.0, 103.0, 104.0];
|
||||
let h = [105.0, 106.0, 107.0, 108.0, 109.0];
|
||||
let l = [95.0, 96.0, 97.0, 98.0, 99.0];
|
||||
let c = [101.0, 102.0, 103.0, 104.0, 105.0];
|
||||
let v = [50.0, 60.0, 40.0, 70.0, 30.0];
|
||||
// threshold 100: first bar covers indices 0..2 (vol=110>=100)
|
||||
let (ro, rh, rl, rc, rv) = volume_bars(&o, &h, &l, &c, &v, 100.0);
|
||||
assert!(rv.len() >= 2);
|
||||
// First bar: vol = 50+60 = 110
|
||||
assert!((rv[0] - 110.0).abs() < 1e-10);
|
||||
assert!((ro[0] - 100.0).abs() < 1e-10);
|
||||
assert!((rh[0] - 106.0).abs() < 1e-10);
|
||||
assert!((rl[0] - 95.0).abs() < 1e-10);
|
||||
assert!((rc[0] - 102.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_volume_bars_single_element() {
|
||||
let (ro, rh, rl, rc, rv) = volume_bars(&[10.0], &[12.0], &[8.0], &[11.0], &[50.0], 100.0);
|
||||
assert_eq!(rv.len(), 1);
|
||||
assert!((rv[0] - 50.0).abs() < 1e-10);
|
||||
assert!((ro[0] - 10.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic(expected = "volume_threshold must be > 0")]
|
||||
fn test_volume_bars_zero_threshold() {
|
||||
volume_bars(&[1.0], &[1.0], &[1.0], &[1.0], &[1.0], 0.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic(expected = "input arrays must be non-empty")]
|
||||
fn test_volume_bars_empty() {
|
||||
volume_bars(&[], &[], &[], &[], &[], 100.0);
|
||||
}
|
||||
|
||||
// -- ohlcv_agg -----------------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn test_ohlcv_agg_basic() {
|
||||
let o = [100.0, 101.0, 102.0, 103.0];
|
||||
let h = [105.0, 106.0, 108.0, 109.0];
|
||||
let l = [95.0, 96.0, 97.0, 98.0];
|
||||
let c = [101.0, 102.0, 103.0, 104.0];
|
||||
let v = [10.0, 20.0, 30.0, 40.0];
|
||||
let labels: [i64; 4] = [0, 0, 1, 1];
|
||||
let (ro, rh, rl, rc, rv) = ohlcv_agg(&o, &h, &l, &c, &v, &labels);
|
||||
assert_eq!(ro.len(), 2);
|
||||
// Group 0: open=100, high=max(105,106)=106, low=min(95,96)=95, close=102, vol=30
|
||||
assert!((ro[0] - 100.0).abs() < 1e-10);
|
||||
assert!((rh[0] - 106.0).abs() < 1e-10);
|
||||
assert!((rl[0] - 95.0).abs() < 1e-10);
|
||||
assert!((rc[0] - 102.0).abs() < 1e-10);
|
||||
assert!((rv[0] - 30.0).abs() < 1e-10);
|
||||
// Group 1: open=102, high=max(108,109)=109, low=min(97,98)=97, close=104, vol=70
|
||||
assert!((ro[1] - 102.0).abs() < 1e-10);
|
||||
assert!((rh[1] - 109.0).abs() < 1e-10);
|
||||
assert!((rl[1] - 97.0).abs() < 1e-10);
|
||||
assert!((rc[1] - 104.0).abs() < 1e-10);
|
||||
assert!((rv[1] - 70.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ohlcv_agg_single_group() {
|
||||
let o = [100.0, 101.0];
|
||||
let h = [105.0, 106.0];
|
||||
let l = [95.0, 96.0];
|
||||
let c = [101.0, 102.0];
|
||||
let v = [10.0, 20.0];
|
||||
let labels: [i64; 2] = [0, 0];
|
||||
let (ro, rh, rl, rc, rv) = ohlcv_agg(&o, &h, &l, &c, &v, &labels);
|
||||
assert_eq!(ro.len(), 1);
|
||||
assert!((rv[0] - 30.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ohlcv_agg_each_bar_own_group() {
|
||||
let o = [100.0, 101.0, 102.0];
|
||||
let h = [105.0, 106.0, 107.0];
|
||||
let l = [95.0, 96.0, 97.0];
|
||||
let c = [101.0, 102.0, 103.0];
|
||||
let v = [10.0, 20.0, 30.0];
|
||||
let labels: [i64; 3] = [0, 1, 2];
|
||||
let (ro, _rh, _rl, _rc, rv) = ohlcv_agg(&o, &h, &l, &c, &v, &labels);
|
||||
assert_eq!(ro.len(), 3);
|
||||
assert!((rv[0] - 10.0).abs() < 1e-10);
|
||||
assert!((rv[1] - 20.0).abs() < 1e-10);
|
||||
assert!((rv[2] - 30.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic(expected = "input arrays must be non-empty")]
|
||||
fn test_ohlcv_agg_empty() {
|
||||
ohlcv_agg(&[], &[], &[], &[], &[], &[]);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,131 @@
|
||||
//! Signal processing helpers.
|
||||
//!
|
||||
//! - `rank_values` — fractional rank of a slice (1-based, ties averaged)
|
||||
//! - `compose_rank` — rank-based composite scores for a 2-D signal matrix
|
||||
//! - `top_n_indices` — indices of the N largest values
|
||||
//! - `bottom_n_indices` — indices of the N smallest values
|
||||
|
||||
/// Compute fractional rank of each element (1-based, ascending).
|
||||
/// Ties receive the average of their rank positions.
|
||||
pub fn rank_values(x: &[f64]) -> Vec<f64> {
|
||||
let n = x.len();
|
||||
let mut order: Vec<usize> = (0..n).collect();
|
||||
order.sort_by(|&a, &b| x[a].partial_cmp(&x[b]).unwrap_or(std::cmp::Ordering::Equal));
|
||||
|
||||
let mut ranks = vec![0.0_f64; n];
|
||||
let mut i = 0;
|
||||
while i < n {
|
||||
let val = x[order[i]];
|
||||
let mut j = i + 1;
|
||||
while j < n && x[order[j]] == val {
|
||||
j += 1;
|
||||
}
|
||||
let avg_rank = (i + 1 + j) as f64 / 2.0;
|
||||
for k in i..j {
|
||||
ranks[order[k]] = avg_rank;
|
||||
}
|
||||
i = j;
|
||||
}
|
||||
ranks
|
||||
}
|
||||
|
||||
/// Compute rank-based composite scores for a 2-D signal matrix.
|
||||
///
|
||||
/// Each column is ranked independently, and the per-row ranks are summed.
|
||||
/// `signals` is a slice of columns, each column being a `&[f64]` of the same length.
|
||||
pub fn compose_rank(signals: &[&[f64]]) -> Vec<f64> {
|
||||
if signals.is_empty() {
|
||||
return vec![];
|
||||
}
|
||||
let n_bars = signals[0].len();
|
||||
let mut scores = vec![0.0_f64; n_bars];
|
||||
for &column in signals {
|
||||
let ranks = rank_values(column);
|
||||
for (bar_idx, rank) in ranks.into_iter().enumerate() {
|
||||
scores[bar_idx] += rank;
|
||||
}
|
||||
}
|
||||
scores
|
||||
}
|
||||
|
||||
/// Return the indices of the N largest values in `x` (descending by value).
|
||||
pub fn top_n_indices(x: &[f64], n: usize) -> Vec<i64> {
|
||||
let len = x.len();
|
||||
let k = n.min(len);
|
||||
let mut order: Vec<usize> = (0..len).collect();
|
||||
order.sort_by(|&a, &b| x[b].partial_cmp(&x[a]).unwrap_or(std::cmp::Ordering::Equal));
|
||||
order[..k].iter().map(|&i| i as i64).collect()
|
||||
}
|
||||
|
||||
/// Return the indices of the N smallest values in `x` (ascending by value).
|
||||
pub fn bottom_n_indices(x: &[f64], n: usize) -> Vec<i64> {
|
||||
let len = x.len();
|
||||
let k = n.min(len);
|
||||
let mut order: Vec<usize> = (0..len).collect();
|
||||
order.sort_by(|&a, &b| x[a].partial_cmp(&x[b]).unwrap_or(std::cmp::Ordering::Equal));
|
||||
order[..k].iter().map(|&i| i as i64).collect()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_rank_values() {
|
||||
let x = vec![3.0, 1.0, 2.0];
|
||||
let ranks = rank_values(&x);
|
||||
assert!((ranks[0] - 3.0).abs() < 1e-10); // 3.0 is largest → rank 3
|
||||
assert!((ranks[1] - 1.0).abs() < 1e-10); // 1.0 is smallest → rank 1
|
||||
assert!((ranks[2] - 2.0).abs() < 1e-10); // 2.0 is middle → rank 2
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rank_values_ties() {
|
||||
let x = vec![1.0, 2.0, 2.0, 4.0];
|
||||
let ranks = rank_values(&x);
|
||||
assert!((ranks[0] - 1.0).abs() < 1e-10);
|
||||
assert!((ranks[1] - 2.5).abs() < 1e-10); // tied → average
|
||||
assert!((ranks[2] - 2.5).abs() < 1e-10);
|
||||
assert!((ranks[3] - 4.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_compose_rank() {
|
||||
let col1 = vec![3.0, 1.0, 2.0];
|
||||
let col2 = vec![1.0, 3.0, 2.0];
|
||||
let signals: Vec<&[f64]> = vec![&col1, &col2];
|
||||
let scores = compose_rank(&signals);
|
||||
// Row 0: rank(3.0)=3 + rank(1.0)=1 = 4
|
||||
// Row 1: rank(1.0)=1 + rank(3.0)=3 = 4
|
||||
// Row 2: rank(2.0)=2 + rank(2.0)=2 = 4
|
||||
assert!((scores[0] - 4.0).abs() < 1e-10);
|
||||
assert!((scores[1] - 4.0).abs() < 1e-10);
|
||||
assert!((scores[2] - 4.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_top_n_indices() {
|
||||
let x = vec![10.0, 50.0, 30.0, 20.0, 40.0];
|
||||
let result = top_n_indices(&x, 3);
|
||||
assert_eq!(result.len(), 3);
|
||||
assert_eq!(result[0], 1); // 50.0
|
||||
assert_eq!(result[1], 4); // 40.0
|
||||
assert_eq!(result[2], 2); // 30.0
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bottom_n_indices() {
|
||||
let x = vec![10.0, 50.0, 30.0, 20.0, 40.0];
|
||||
let result = bottom_n_indices(&x, 2);
|
||||
assert_eq!(result.len(), 2);
|
||||
assert_eq!(result[0], 0); // 10.0
|
||||
assert_eq!(result[1], 3); // 20.0
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_top_n_exceeds_len() {
|
||||
let x = vec![1.0, 2.0];
|
||||
let result = top_n_indices(&x, 5);
|
||||
assert_eq!(result.len(), 2);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,161 @@
|
||||
//! Runtime-dispatched SIMD primitives.
|
||||
//!
|
||||
//! Each public reduction here is compiled into several CPU-feature-specific
|
||||
//! variants (baseline, SSE, AVX2/FMA, AVX-512 on x86_64; NEON on aarch64; …)
|
||||
//! by [`multiversion`]. The fastest variant the *current* CPU supports is
|
||||
//! chosen at runtime via CPUID. This gives one binary that:
|
||||
//!
|
||||
//! * runs on **any** CPU of the target architecture — no illegal-instruction
|
||||
//! (SIGILL) crashes on pre-AVX2 chips, unlike a static `-C target-cpu=…`;
|
||||
//! * still uses wide vector units where the hardware has them.
|
||||
//!
|
||||
//! The hot loops accumulate into **independent lanes** before a final
|
||||
//! horizontal combine. That is what lets the optimizer auto-vectorize them:
|
||||
//! a plain sequential `iter().sum()` is a dependency chain LLVM may not
|
||||
//! reorder (doing so would change floating-point rounding). As a consequence
|
||||
//! these results differ from a strict left-to-right sum by a few ULPs — well
|
||||
//! inside every indicator's documented tolerance.
|
||||
|
||||
/// Number of independent accumulator lanes. Eight `f64` lanes cover the
|
||||
/// widest target we dispatch to (AVX-512 = 8×f64); narrower targets (AVX2,
|
||||
/// NEON) simply use a subset.
|
||||
#[cfg(feature = "simd")]
|
||||
const LANES: usize = 8;
|
||||
|
||||
/// Sum of a slice of `f64`, runtime-dispatched.
|
||||
#[cfg(feature = "simd")]
|
||||
#[multiversion::multiversion(targets = "simd")]
|
||||
pub(crate) fn sum(data: &[f64]) -> f64 {
|
||||
let mut acc = [0.0f64; LANES];
|
||||
let mut chunks = data.chunks_exact(LANES);
|
||||
for chunk in &mut chunks {
|
||||
for (a, &v) in acc.iter_mut().zip(chunk) {
|
||||
*a += v;
|
||||
}
|
||||
}
|
||||
let remainder: f64 = chunks.remainder().iter().sum();
|
||||
remainder + acc.iter().sum::<f64>()
|
||||
}
|
||||
|
||||
/// Pure-scalar fallback when the `simd` feature is disabled.
|
||||
#[cfg(not(feature = "simd"))]
|
||||
pub(crate) fn sum(data: &[f64]) -> f64 {
|
||||
data.iter().sum()
|
||||
}
|
||||
|
||||
/// Weighted-moving-average seed for the first window.
|
||||
///
|
||||
/// Returns `(t, s)` where `t = Σ data[k] * (k + 1)` (1-based linear weights)
|
||||
/// and `s = Σ data[k]`. Used to seed the O(n) WMA recurrence.
|
||||
#[cfg(feature = "simd")]
|
||||
#[multiversion::multiversion(targets = "simd")]
|
||||
pub(crate) fn wma_seed(data: &[f64]) -> (f64, f64) {
|
||||
// Lane-local accumulation (same idea as `sum`) so each CPU-feature clone
|
||||
// can vectorize: `t` weights each value by its 1-based global index.
|
||||
let mut t_acc = [0.0f64; LANES];
|
||||
let mut s_acc = [0.0f64; LANES];
|
||||
let mut chunks = data.chunks_exact(LANES);
|
||||
let mut base = 0.0f64; // global index of this chunk's first element
|
||||
for chunk in &mut chunks {
|
||||
for (lane, ((t, s), &v)) in t_acc
|
||||
.iter_mut()
|
||||
.zip(s_acc.iter_mut())
|
||||
.zip(chunk)
|
||||
.enumerate()
|
||||
{
|
||||
*t += v * (base + lane as f64 + 1.0);
|
||||
*s += v;
|
||||
}
|
||||
base += LANES as f64;
|
||||
}
|
||||
let mut t = 0.0;
|
||||
let mut s = 0.0;
|
||||
for (i, &v) in chunks.remainder().iter().enumerate() {
|
||||
t += v * (base + i as f64 + 1.0);
|
||||
s += v;
|
||||
}
|
||||
(t + t_acc.iter().sum::<f64>(), s + s_acc.iter().sum::<f64>())
|
||||
}
|
||||
|
||||
/// Pure-scalar fallback when the `simd` feature is disabled.
|
||||
#[cfg(not(feature = "simd"))]
|
||||
pub(crate) fn wma_seed(data: &[f64]) -> (f64, f64) {
|
||||
let mut t = 0.0;
|
||||
let mut s = 0.0;
|
||||
for (k, &v) in data.iter().enumerate() {
|
||||
t += v * (k + 1) as f64;
|
||||
s += v;
|
||||
}
|
||||
(t, s)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// Strict sequential reference — the ground truth we compare against.
|
||||
fn naive_sum(data: &[f64]) -> f64 {
|
||||
data.iter().sum()
|
||||
}
|
||||
|
||||
fn naive_wma_seed(data: &[f64]) -> (f64, f64) {
|
||||
let t = data
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(k, &v)| v * (k + 1) as f64)
|
||||
.sum();
|
||||
let s = data.iter().sum();
|
||||
(t, s)
|
||||
}
|
||||
|
||||
/// Deterministic test vectors spanning the lane boundaries: empty, a
|
||||
/// partial chunk (< LANES), an exact multiple, and an exact-multiple +
|
||||
/// remainder. This exercises every branch of the chunked reduction.
|
||||
fn cases() -> Vec<Vec<f64>> {
|
||||
let big: Vec<f64> = (0..1000).map(|i| (i as f64) * 0.5 - 123.0).collect();
|
||||
vec![
|
||||
vec![],
|
||||
vec![42.0],
|
||||
vec![1.0, 2.0, 3.0], // < LANES
|
||||
(1..=8).map(|i| i as f64).collect(), // exactly LANES
|
||||
(1..=17).map(|i| i as f64).collect(), // LANES*2 + 1
|
||||
big,
|
||||
]
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sum_matches_sequential_within_tolerance() {
|
||||
for data in cases() {
|
||||
let got = sum(&data);
|
||||
let want = naive_sum(&data);
|
||||
assert!(
|
||||
(got - want).abs() <= 1e-9 * want.abs().max(1.0),
|
||||
"sum mismatch: got {got}, want {want}, len {}",
|
||||
data.len()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wma_seed_matches_sequential_within_tolerance() {
|
||||
for data in cases() {
|
||||
let (t, s) = wma_seed(&data);
|
||||
let (wt, ws) = naive_wma_seed(&data);
|
||||
assert!(
|
||||
(t - wt).abs() <= 1e-9 * wt.abs().max(1.0),
|
||||
"wma t mismatch: got {t}, want {wt}, len {}",
|
||||
data.len()
|
||||
);
|
||||
assert!(
|
||||
(s - ws).abs() <= 1e-9 * ws.abs().max(1.0),
|
||||
"wma s mismatch: got {s}, want {ws}, len {}",
|
||||
data.len()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sum_empty_is_zero() {
|
||||
assert_eq!(sum(&[]), 0.0);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,492 @@
|
||||
//! Statistic functions.
|
||||
|
||||
/// Compute the rolling population standard deviation, scaled by `nbdev`.
|
||||
///
|
||||
/// Uses population variance (`ddof = 0`). Returns `nbdev * stddev` for
|
||||
/// each window. The first `timeperiod - 1` values are `NaN`.
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `real` - Input series.
|
||||
/// * `timeperiod` - Rolling window size (must be >= 1).
|
||||
/// * `nbdev` - Multiplier applied to the standard deviation (use 1.0 for raw stddev).
|
||||
pub fn stddev(real: &[f64], timeperiod: usize, nbdev: f64) -> Vec<f64> {
|
||||
let n = real.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if timeperiod < 1 || n < timeperiod {
|
||||
return result;
|
||||
}
|
||||
for i in (timeperiod - 1)..n {
|
||||
let window = &real[i + 1 - timeperiod..=i];
|
||||
let mean: f64 = window.iter().sum::<f64>() / timeperiod as f64;
|
||||
let var: f64 = window.iter().map(|&x| (x - mean).powi(2)).sum::<f64>() / timeperiod as f64;
|
||||
result[i] = var.sqrt() * nbdev;
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// Rolling population variance, scaled by `nbdev²`.
|
||||
pub fn var(real: &[f64], timeperiod: usize, nbdev: f64) -> Vec<f64> {
|
||||
let n = real.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if timeperiod < 1 || n < timeperiod {
|
||||
return result;
|
||||
}
|
||||
for i in (timeperiod - 1)..n {
|
||||
let window = &real[i + 1 - timeperiod..=i];
|
||||
let mean: f64 = window.iter().sum::<f64>() / timeperiod as f64;
|
||||
let variance: f64 =
|
||||
window.iter().map(|&x| (x - mean).powi(2)).sum::<f64>() / timeperiod as f64;
|
||||
result[i] = variance * nbdev * nbdev;
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Linear regression helpers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
fn rolling_linreg_apply<F>(prices: &[f64], timeperiod: usize, mut map: F) -> Vec<f64>
|
||||
where
|
||||
F: FnMut(f64, f64) -> f64,
|
||||
{
|
||||
let n = prices.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if timeperiod == 0 || n < timeperiod {
|
||||
return result;
|
||||
}
|
||||
let period = timeperiod as f64;
|
||||
let last_x = (timeperiod - 1) as f64;
|
||||
let sum_x = last_x * period / 2.0;
|
||||
let sum_x2 = last_x * period * (2.0 * period - 1.0) / 6.0;
|
||||
let denom = period * sum_x2 - sum_x * sum_x;
|
||||
|
||||
let mut sum_y: f64 = prices[..timeperiod].iter().sum();
|
||||
let mut sum_xy: f64 = prices[..timeperiod]
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(idx, &v)| idx as f64 * v)
|
||||
.sum();
|
||||
|
||||
for end in (timeperiod - 1)..n {
|
||||
let slope = if denom != 0.0 {
|
||||
(period * sum_xy - sum_x * sum_y) / denom
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
let intercept = (sum_y - slope * sum_x) / period;
|
||||
result[end] = map(slope, intercept);
|
||||
if end + 1 < n {
|
||||
let outgoing = prices[end + 1 - timeperiod];
|
||||
let incoming = prices[end + 1];
|
||||
let prev_sum_y = sum_y;
|
||||
sum_y = prev_sum_y - outgoing + incoming;
|
||||
sum_xy = sum_xy - (prev_sum_y - outgoing) + last_x * incoming;
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// Linear regression fitted value at the last point of the window.
|
||||
pub fn linearreg(close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let last_x = if timeperiod > 0 {
|
||||
(timeperiod - 1) as f64
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
rolling_linreg_apply(close, timeperiod, |slope, intercept| {
|
||||
intercept + slope * last_x
|
||||
})
|
||||
}
|
||||
|
||||
/// Slope of the rolling linear regression line.
|
||||
pub fn linearreg_slope(close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
rolling_linreg_apply(close, timeperiod, |slope, _| slope)
|
||||
}
|
||||
|
||||
/// Intercept of the rolling linear regression line.
|
||||
pub fn linearreg_intercept(close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
rolling_linreg_apply(close, timeperiod, |_, intercept| intercept)
|
||||
}
|
||||
|
||||
/// Angle of the regression line in degrees.
|
||||
pub fn linearreg_angle(close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
rolling_linreg_apply(close, timeperiod, |slope, _| {
|
||||
slope.atan() * 180.0 / std::f64::consts::PI
|
||||
})
|
||||
}
|
||||
|
||||
/// Time Series Forecast: linear regression extrapolated one period ahead.
|
||||
pub fn tsf(close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let forecast_x = timeperiod as f64;
|
||||
rolling_linreg_apply(close, timeperiod, |slope, intercept| {
|
||||
intercept + slope * forecast_x
|
||||
})
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Beta (rolling, return-based)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Rolling beta: regression of real1 daily returns on real0 daily returns.
|
||||
pub fn beta(real0: &[f64], real1: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let n = real0.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if timeperiod == 0 || n <= timeperiod {
|
||||
return result;
|
||||
}
|
||||
|
||||
let price_return = |curr: f64, prev: f64| -> f64 {
|
||||
if prev != 0.0 {
|
||||
curr / prev - 1.0
|
||||
} else {
|
||||
f64::NAN
|
||||
}
|
||||
};
|
||||
let rx: Vec<f64> = real0.windows(2).map(|w| price_return(w[1], w[0])).collect();
|
||||
let ry: Vec<f64> = real1.windows(2).map(|w| price_return(w[1], w[0])).collect();
|
||||
|
||||
let period = timeperiod as f64;
|
||||
let mut sum_rx = 0.0_f64;
|
||||
let mut sum_ry = 0.0_f64;
|
||||
let mut sum_rx2 = 0.0_f64;
|
||||
let mut sum_rxry = 0.0_f64;
|
||||
let mut invalid = 0usize;
|
||||
|
||||
for idx in 0..timeperiod {
|
||||
let (ret_x, ret_y) = (rx[idx], ry[idx]);
|
||||
if ret_x.is_finite() && ret_y.is_finite() {
|
||||
sum_rx += ret_x;
|
||||
sum_ry += ret_y;
|
||||
sum_rx2 += ret_x * ret_x;
|
||||
sum_rxry += ret_x * ret_y;
|
||||
} else {
|
||||
invalid += 1;
|
||||
}
|
||||
}
|
||||
|
||||
for end in timeperiod..n {
|
||||
result[end] = if invalid == 0 {
|
||||
let denom = period * sum_rx2 - sum_rx * sum_rx;
|
||||
if denom != 0.0 {
|
||||
(period * sum_rxry - sum_rx * sum_ry) / denom
|
||||
} else {
|
||||
f64::NAN
|
||||
}
|
||||
} else {
|
||||
f64::NAN
|
||||
};
|
||||
|
||||
if end + 1 < n {
|
||||
let out = end - timeperiod;
|
||||
let (ox, oy) = (rx[out], ry[out]);
|
||||
if ox.is_finite() && oy.is_finite() {
|
||||
sum_rx -= ox;
|
||||
sum_ry -= oy;
|
||||
sum_rx2 -= ox * ox;
|
||||
sum_rxry -= ox * oy;
|
||||
} else {
|
||||
invalid -= 1;
|
||||
}
|
||||
let (ix, iy) = (rx[end], ry[end]);
|
||||
if ix.is_finite() && iy.is_finite() {
|
||||
sum_rx += ix;
|
||||
sum_ry += iy;
|
||||
sum_rx2 += ix * ix;
|
||||
sum_rxry += ix * iy;
|
||||
} else {
|
||||
invalid += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Correlation (rolling Pearson)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Rolling Pearson correlation coefficient between two series.
|
||||
pub fn correl(real0: &[f64], real1: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let n = real0.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if timeperiod == 0 || n < timeperiod {
|
||||
return result;
|
||||
}
|
||||
|
||||
let period = timeperiod as f64;
|
||||
let mut sum_x: f64 = real0[..timeperiod].iter().sum();
|
||||
let mut sum_y: f64 = real1[..timeperiod].iter().sum();
|
||||
let mut sum_x2: f64 = real0[..timeperiod].iter().map(|v| v * v).sum();
|
||||
let mut sum_y2: f64 = real1[..timeperiod].iter().map(|v| v * v).sum();
|
||||
let mut sum_xy: f64 = real0[..timeperiod]
|
||||
.iter()
|
||||
.zip(real1[..timeperiod].iter())
|
||||
.map(|(&a, &b)| a * b)
|
||||
.sum();
|
||||
|
||||
#[allow(clippy::needless_range_loop)]
|
||||
for end in (timeperiod - 1)..n {
|
||||
let denom_x = period * sum_x2 - sum_x * sum_x;
|
||||
let denom_y = period * sum_y2 - sum_y * sum_y;
|
||||
result[end] = if denom_x > 0.0 && denom_y > 0.0 {
|
||||
(period * sum_xy - sum_x * sum_y) / (denom_x * denom_y).sqrt()
|
||||
} else {
|
||||
f64::NAN
|
||||
};
|
||||
|
||||
if end + 1 < n {
|
||||
let out = end + 1 - timeperiod;
|
||||
let inc = end + 1;
|
||||
sum_x += real0[inc] - real0[out];
|
||||
sum_y += real1[inc] - real1[out];
|
||||
sum_x2 += real0[inc] * real0[inc] - real0[out] * real0[out];
|
||||
sum_y2 += real1[inc] * real1[inc] - real1[out] * real1[out];
|
||||
sum_xy += real0[inc] * real1[inc] - real0[out] * real1[out];
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Dynamic Time Warping (DTW)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Internal helper: build the full DTW accumulated-cost matrix.
|
||||
///
|
||||
/// Local cost: `|s1[i] - s2[j]|` (Euclidean / L1 for 1-D series).
|
||||
/// This matches the convention used by `dtaidistance.dtw.distance()`.
|
||||
///
|
||||
/// Out-of-band cells (Sakoe-Chiba constraint) are set to `f64::INFINITY`.
|
||||
fn dtw_matrix(s1: &[f64], s2: &[f64], window: Option<usize>) -> Vec<Vec<f64>> {
|
||||
let n = s1.len();
|
||||
let m = s2.len();
|
||||
let mut dp = vec![vec![f64::INFINITY; m]; n];
|
||||
for i in 0..n {
|
||||
// Window convention matches dtaidistance: window=w means |i-j| < w.
|
||||
// None = unconstrained (full matrix).
|
||||
let (j_lo, j_hi) = match window {
|
||||
None => (0, m),
|
||||
Some(w) => {
|
||||
let lo = i.saturating_sub(w.saturating_sub(1));
|
||||
let hi = i.saturating_add(w).min(m);
|
||||
(lo, hi)
|
||||
}
|
||||
};
|
||||
for j in j_lo..j_hi {
|
||||
// Squared Euclidean local cost — matches dtaidistance convention.
|
||||
// The final sqrt is applied only once at the top level (not per-step).
|
||||
let cost = (s1[i] - s2[j]).powi(2);
|
||||
let prev = if i == 0 && j == 0 {
|
||||
0.0
|
||||
} else if i == 0 {
|
||||
dp[0][j - 1]
|
||||
} else if j == 0 {
|
||||
dp[i - 1][0]
|
||||
} else {
|
||||
dp[i - 1][j - 1].min(dp[i - 1][j]).min(dp[i][j - 1])
|
||||
};
|
||||
dp[i][j] = cost + prev;
|
||||
}
|
||||
}
|
||||
dp
|
||||
}
|
||||
|
||||
/// Compute the Dynamic Time Warping distance between two 1-D series.
|
||||
///
|
||||
/// Returns the accumulated Euclidean cost along the optimal warping path.
|
||||
/// Uses `|s1[i] - s2[j]|` as the local cost, matching `dtaidistance` convention.
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `s1` - First time series.
|
||||
/// * `s2` - Second time series.
|
||||
/// * `window` - Optional Sakoe-Chiba band width. `None` = unconstrained.
|
||||
///
|
||||
/// Returns `f64::NAN` if either input is empty.
|
||||
pub fn dtw_distance(s1: &[f64], s2: &[f64], window: Option<usize>) -> f64 {
|
||||
if s1.is_empty() || s2.is_empty() {
|
||||
return f64::NAN;
|
||||
}
|
||||
let dp = dtw_matrix(s1, s2, window);
|
||||
// sqrt applied once at the end — matches dtaidistance.dtw.distance() convention.
|
||||
dp[s1.len() - 1][s2.len() - 1].sqrt()
|
||||
}
|
||||
|
||||
/// Compute the DTW distance and the optimal warping path between two 1-D series.
|
||||
///
|
||||
/// The warping path is a `Vec<(usize, usize)>` of `(i, j)` index pairs,
|
||||
/// starting at `(0, 0)` and ending at `(n-1, m-1)`, monotonically non-decreasing.
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `s1` - First time series.
|
||||
/// * `s2` - Second time series.
|
||||
/// * `window` - Optional Sakoe-Chiba band width. `None` = unconstrained.
|
||||
///
|
||||
/// Returns `(f64::NAN, vec![])` if either input is empty.
|
||||
pub fn dtw_path(s1: &[f64], s2: &[f64], window: Option<usize>) -> (f64, Vec<(usize, usize)>) {
|
||||
if s1.is_empty() || s2.is_empty() {
|
||||
return (f64::NAN, vec![]);
|
||||
}
|
||||
let dp = dtw_matrix(s1, s2, window);
|
||||
let dist = dp[s1.len() - 1][s2.len() - 1].sqrt();
|
||||
|
||||
// Backtrace from (n-1, m-1) to (0, 0)
|
||||
let mut path = Vec::new();
|
||||
let (mut i, mut j) = (s1.len() - 1, s2.len() - 1);
|
||||
path.push((i, j));
|
||||
while i > 0 || j > 0 {
|
||||
let (ni, nj) = match (i, j) {
|
||||
(0, _) => (0, j - 1),
|
||||
(_, 0) => (i - 1, 0),
|
||||
_ => {
|
||||
let diag = dp[i - 1][j - 1];
|
||||
let up = dp[i - 1][j];
|
||||
let left = dp[i][j - 1];
|
||||
let best = diag.min(up).min(left);
|
||||
if best == diag {
|
||||
(i - 1, j - 1)
|
||||
} else if best == up {
|
||||
(i - 1, j)
|
||||
} else {
|
||||
(i, j - 1)
|
||||
}
|
||||
}
|
||||
};
|
||||
i = ni;
|
||||
j = nj;
|
||||
path.push((i, j));
|
||||
}
|
||||
path.reverse();
|
||||
(dist, path)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn stddev_constant() {
|
||||
let prices = vec![5.0; 5];
|
||||
let result = stddev(&prices, 3, 1.0);
|
||||
for v in result.iter().filter(|v| !v.is_nan()) {
|
||||
assert!(v.abs() < 1e-10);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dtw_identical_series_is_zero() {
|
||||
let a = vec![1.0, 2.0, 3.0, 4.0, 5.0];
|
||||
assert_eq!(dtw_distance(&a, &a, None), 0.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dtw_known_shifted_series() {
|
||||
// [0,1,2] vs [1,2,3]: DTW uses squared Euclidean local cost + final sqrt.
|
||||
// Optimal path (0,0)→(1,0)→(2,1)→(2,2), accumulated cost = 1+0+0+1 = 2, sqrt(2).
|
||||
// Matches dtaidistance.dtw.distance([0,1,2],[1,2,3]) = 1.4142...
|
||||
let a = vec![0.0, 1.0, 2.0];
|
||||
let b = vec![1.0, 2.0, 3.0];
|
||||
let expected = 2.0_f64.sqrt();
|
||||
let result = dtw_distance(&a, &b, None);
|
||||
assert!(
|
||||
(result - expected).abs() < 1e-12,
|
||||
"got {result}, expected {expected}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dtw_known_even_shift() {
|
||||
// [0,2,4] vs [1,3,5]: diagonal path, squared costs 1+1+1=3, sqrt(3).
|
||||
// Matches dtaidistance.dtw.distance([0,2,4],[1,3,5]) = 1.7320...
|
||||
let a = vec![0.0, 2.0, 4.0];
|
||||
let b = vec![1.0, 3.0, 5.0];
|
||||
let expected = 3.0_f64.sqrt();
|
||||
let result = dtw_distance(&a, &b, None);
|
||||
assert!(
|
||||
(result - expected).abs() < 1e-12,
|
||||
"got {result}, expected {expected}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dtw_single_element() {
|
||||
let a = vec![3.0];
|
||||
let b = vec![7.0];
|
||||
assert_eq!(dtw_distance(&a, &b, None), 4.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dtw_empty_returns_nan() {
|
||||
assert!(dtw_distance(&[], &[1.0, 2.0], None).is_nan());
|
||||
assert!(dtw_distance(&[1.0, 2.0], &[], None).is_nan());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dtw_path_endpoints() {
|
||||
let a = vec![1.0, 2.0, 3.0, 4.0];
|
||||
let b = vec![1.5, 2.5, 3.5, 4.5];
|
||||
let (_, path) = dtw_path(&a, &b, None);
|
||||
assert_eq!(path.first(), Some(&(0, 0)));
|
||||
assert_eq!(path.last(), Some(&(3, 3)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dtw_path_is_monotone() {
|
||||
let a = vec![1.0, 3.0, 2.0, 5.0, 4.0];
|
||||
let b = vec![2.0, 1.0, 4.0, 3.0, 6.0];
|
||||
let (_, path) = dtw_path(&a, &b, None);
|
||||
for k in 1..path.len() {
|
||||
assert!(path[k].0 >= path[k - 1].0);
|
||||
assert!(path[k].1 >= path[k - 1].1);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dtw_path_distance_matches_distance_only() {
|
||||
let a = vec![1.0, 4.0, 2.0, 8.0, 3.0];
|
||||
let b = vec![2.0, 3.0, 7.0, 4.0, 5.0];
|
||||
let d1 = dtw_distance(&a, &b, None);
|
||||
let (d2, _) = dtw_path(&a, &b, None);
|
||||
assert!((d1 - d2).abs() < 1e-12);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dtw_nan_in_input_propagates() {
|
||||
// NaN in either input must propagate to the distance (IEEE 754 semantics).
|
||||
let a = vec![1.0, 2.0, f64::NAN, 4.0];
|
||||
let b = vec![1.0, 2.0, 3.0, 4.0];
|
||||
assert!(dtw_distance(&a, &b, None).is_nan());
|
||||
assert!(dtw_distance(&b, &a, None).is_nan());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dtw_is_symmetric() {
|
||||
let a = vec![1.0, 4.0, 2.0, 8.0, 3.0, 6.0, 5.0];
|
||||
let b = vec![2.0, 3.0, 7.0, 4.0, 5.0, 1.0, 9.0];
|
||||
let d_ab = dtw_distance(&a, &b, None);
|
||||
let d_ba = dtw_distance(&b, &a, None);
|
||||
assert!((d_ab - d_ba).abs() < 1e-12);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dtw_path_length_bounded() {
|
||||
// A valid warp path has length between max(n, m) and n + m - 1.
|
||||
let a: Vec<f64> = (0..7).map(|x| x as f64).collect();
|
||||
let b: Vec<f64> = (0..10).map(|x| (x as f64).sin()).collect();
|
||||
let (_, path) = dtw_path(&a, &b, None);
|
||||
let n = a.len();
|
||||
let m = b.len();
|
||||
assert!(path.len() >= n.max(m));
|
||||
assert!(path.len() <= n + m - 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dtw_window_constrained_ge_unconstrained() {
|
||||
// window convention matches dtaidistance: Some(w) means |i-j| < w.
|
||||
// A narrow window restricts warping, so constrained distance >= unconstrained.
|
||||
let a: Vec<f64> = (0..20).map(|x| x as f64).collect();
|
||||
let b: Vec<f64> = (0..20).map(|x| x as f64 + 3.0).collect();
|
||||
let d_full = dtw_distance(&a, &b, None);
|
||||
let d_narrow = dtw_distance(&a, &b, Some(3));
|
||||
assert!(d_narrow >= d_full - 1e-12);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,946 @@
|
||||
//! Streaming / Incremental Indicators — bar-by-bar stateful structs.
|
||||
//!
|
||||
//! Pure Rust implementations with no PyO3 dependency. Each struct:
|
||||
//! - Accepts one value per call to `update()`.
|
||||
//! - Returns `NaN` (or a NaN tuple) during the warm-up window.
|
||||
//! - Exposes a `reset()` method to restart from scratch.
|
||||
//! - Has a `period()` accessor (where applicable).
|
||||
|
||||
use std::collections::VecDeque;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Error type
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Validation error for streaming indicator parameters.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct StreamingError(pub String);
|
||||
|
||||
impl std::fmt::Display for StreamingError {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
write!(f, "{}", self.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl std::error::Error for StreamingError {}
|
||||
|
||||
fn validate_timeperiod(value: usize, name: &str, minimum: usize) -> Result<(), StreamingError> {
|
||||
if value < minimum {
|
||||
return Err(StreamingError(format!(
|
||||
"{} must be >= {}, got {}",
|
||||
name, minimum, value
|
||||
)));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Internal helper: EMA state (used inside composite classes)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// SMA-seeded EMA state machine. Not exposed directly — used by
|
||||
/// `StreamingEMA`, `StreamingMACD`, etc.
|
||||
pub(crate) struct EmaState {
|
||||
period: usize,
|
||||
alpha: f64,
|
||||
ema: f64,
|
||||
seed_buf: Vec<f64>,
|
||||
seeded: bool,
|
||||
}
|
||||
|
||||
impl EmaState {
|
||||
pub fn new(period: usize) -> Self {
|
||||
Self {
|
||||
period,
|
||||
alpha: 2.0 / (period as f64 + 1.0),
|
||||
ema: 0.0,
|
||||
seed_buf: Vec::with_capacity(period),
|
||||
seeded: false,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn update(&mut self, value: f64) -> f64 {
|
||||
if !self.seeded {
|
||||
self.seed_buf.push(value);
|
||||
if self.seed_buf.len() < self.period {
|
||||
return f64::NAN;
|
||||
}
|
||||
let seed = self.seed_buf.iter().sum::<f64>() / self.period as f64;
|
||||
self.ema = seed;
|
||||
self.seeded = true;
|
||||
return seed;
|
||||
}
|
||||
self.ema += self.alpha * (value - self.ema);
|
||||
self.ema
|
||||
}
|
||||
|
||||
pub fn reset(&mut self) {
|
||||
self.ema = 0.0;
|
||||
self.seed_buf.clear();
|
||||
self.seeded = false;
|
||||
}
|
||||
|
||||
pub fn period(&self) -> usize {
|
||||
self.period
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Internal helper: ATR state (Wilder smoothing)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Wilder-smoothed ATR state machine. Used by `StreamingATR` and
|
||||
/// `StreamingSupertrend`.
|
||||
pub(crate) struct AtrState {
|
||||
period: usize,
|
||||
prev_close: f64,
|
||||
tr_buf: Vec<f64>,
|
||||
atr: f64,
|
||||
seeded: bool,
|
||||
has_prev: bool,
|
||||
}
|
||||
|
||||
impl AtrState {
|
||||
pub fn new(period: usize) -> Self {
|
||||
Self {
|
||||
period,
|
||||
prev_close: 0.0,
|
||||
tr_buf: Vec::with_capacity(period),
|
||||
atr: 0.0,
|
||||
seeded: false,
|
||||
has_prev: false,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn update(&mut self, high: f64, low: f64, close: f64) -> f64 {
|
||||
let tr = if self.has_prev {
|
||||
let hl = high - low;
|
||||
let hc = (high - self.prev_close).abs();
|
||||
let lc = (low - self.prev_close).abs();
|
||||
hl.max(hc).max(lc)
|
||||
} else {
|
||||
high - low
|
||||
};
|
||||
self.prev_close = close;
|
||||
self.has_prev = true;
|
||||
|
||||
if !self.seeded {
|
||||
self.tr_buf.push(tr);
|
||||
if self.tr_buf.len() < self.period {
|
||||
return f64::NAN;
|
||||
}
|
||||
let seed = self.tr_buf.iter().sum::<f64>() / self.period as f64;
|
||||
self.atr = seed;
|
||||
self.seeded = true;
|
||||
return f64::NAN; // first `period` bars (including this one) return NaN
|
||||
}
|
||||
let pf = (self.period - 1) as f64;
|
||||
self.atr = (self.atr * pf + tr) / self.period as f64;
|
||||
self.atr
|
||||
}
|
||||
|
||||
pub fn reset(&mut self) {
|
||||
self.prev_close = 0.0;
|
||||
self.has_prev = false;
|
||||
self.tr_buf.clear();
|
||||
self.atr = 0.0;
|
||||
self.seeded = false;
|
||||
}
|
||||
|
||||
pub fn period(&self) -> usize {
|
||||
self.period
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// StreamingSMA
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Simple Moving Average — O(1) per update via running sum.
|
||||
///
|
||||
/// Returns NaN during the first `period - 1` bars.
|
||||
pub struct StreamingSMA {
|
||||
period: usize,
|
||||
buf: VecDeque<f64>,
|
||||
running_sum: f64,
|
||||
count: usize,
|
||||
}
|
||||
|
||||
impl StreamingSMA {
|
||||
pub fn new(period: usize) -> Result<Self, StreamingError> {
|
||||
validate_timeperiod(period, "period", 1)?;
|
||||
Ok(Self {
|
||||
period,
|
||||
buf: VecDeque::with_capacity(period + 1),
|
||||
running_sum: 0.0,
|
||||
count: 0,
|
||||
})
|
||||
}
|
||||
|
||||
/// Add a new bar and return the current SMA (NaN during warmup).
|
||||
pub fn update(&mut self, value: f64) -> f64 {
|
||||
if self.buf.len() == self.period {
|
||||
if let Some(old) = self.buf.pop_front() {
|
||||
self.running_sum -= old;
|
||||
}
|
||||
}
|
||||
self.buf.push_back(value);
|
||||
self.running_sum += value;
|
||||
self.count += 1;
|
||||
if self.count < self.period {
|
||||
f64::NAN
|
||||
} else {
|
||||
self.running_sum / self.period as f64
|
||||
}
|
||||
}
|
||||
|
||||
/// Reset state to initial condition.
|
||||
pub fn reset(&mut self) {
|
||||
self.buf.clear();
|
||||
self.running_sum = 0.0;
|
||||
self.count = 0;
|
||||
}
|
||||
|
||||
pub fn period(&self) -> usize {
|
||||
self.period
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// StreamingEMA
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Exponential Moving Average with SMA seeding.
|
||||
///
|
||||
/// Uses a simple SMA for the first `period` bars to seed the EMA, then
|
||||
/// switches to the standard EMA formula (alpha = 2 / (period + 1)).
|
||||
/// Returns NaN during the warmup window.
|
||||
pub struct StreamingEMA {
|
||||
inner: EmaState,
|
||||
}
|
||||
|
||||
impl StreamingEMA {
|
||||
pub fn new(period: usize) -> Result<Self, StreamingError> {
|
||||
validate_timeperiod(period, "period", 1)?;
|
||||
Ok(Self {
|
||||
inner: EmaState::new(period),
|
||||
})
|
||||
}
|
||||
|
||||
/// Add a new bar and return the current EMA (NaN during warmup).
|
||||
pub fn update(&mut self, value: f64) -> f64 {
|
||||
self.inner.update(value)
|
||||
}
|
||||
|
||||
pub fn reset(&mut self) {
|
||||
self.inner.reset();
|
||||
}
|
||||
|
||||
pub fn period(&self) -> usize {
|
||||
self.inner.period()
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// StreamingRSI
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Relative Strength Index with TA-Lib-compatible Wilder seeding.
|
||||
///
|
||||
/// Returns NaN during the first `period` bars.
|
||||
pub struct StreamingRSI {
|
||||
period: usize,
|
||||
prev: f64,
|
||||
has_prev: bool,
|
||||
gains: Vec<f64>,
|
||||
losses: Vec<f64>,
|
||||
avg_gain: f64,
|
||||
avg_loss: f64,
|
||||
seeded: bool,
|
||||
}
|
||||
|
||||
impl StreamingRSI {
|
||||
pub fn new(period: usize) -> Result<Self, StreamingError> {
|
||||
validate_timeperiod(period, "period", 1)?;
|
||||
Ok(Self {
|
||||
period,
|
||||
prev: 0.0,
|
||||
has_prev: false,
|
||||
gains: Vec::with_capacity(period),
|
||||
losses: Vec::with_capacity(period),
|
||||
avg_gain: 0.0,
|
||||
avg_loss: 0.0,
|
||||
seeded: false,
|
||||
})
|
||||
}
|
||||
|
||||
/// Add a new close and return RSI in [0, 100] (NaN during warmup).
|
||||
pub fn update(&mut self, value: f64) -> f64 {
|
||||
if !self.has_prev {
|
||||
self.prev = value;
|
||||
self.has_prev = true;
|
||||
return f64::NAN;
|
||||
}
|
||||
let delta = value - self.prev;
|
||||
self.prev = value;
|
||||
let gain = if delta > 0.0 { delta } else { 0.0 };
|
||||
let loss = if delta < 0.0 { -delta } else { 0.0 };
|
||||
|
||||
if !self.seeded {
|
||||
self.gains.push(gain);
|
||||
self.losses.push(loss);
|
||||
if self.gains.len() < self.period {
|
||||
return f64::NAN;
|
||||
}
|
||||
self.avg_gain = self.gains.iter().sum::<f64>() / self.period as f64;
|
||||
self.avg_loss = self.losses.iter().sum::<f64>() / self.period as f64;
|
||||
self.seeded = true;
|
||||
} else {
|
||||
let pf = (self.period - 1) as f64;
|
||||
self.avg_gain = (self.avg_gain * pf + gain) / self.period as f64;
|
||||
self.avg_loss = (self.avg_loss * pf + loss) / self.period as f64;
|
||||
}
|
||||
|
||||
if self.avg_loss == 0.0 {
|
||||
return 100.0;
|
||||
}
|
||||
let rs = self.avg_gain / self.avg_loss;
|
||||
100.0 - 100.0 / (1.0 + rs)
|
||||
}
|
||||
|
||||
pub fn reset(&mut self) {
|
||||
self.prev = 0.0;
|
||||
self.has_prev = false;
|
||||
self.gains.clear();
|
||||
self.losses.clear();
|
||||
self.avg_gain = 0.0;
|
||||
self.avg_loss = 0.0;
|
||||
self.seeded = false;
|
||||
}
|
||||
|
||||
pub fn period(&self) -> usize {
|
||||
self.period
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// StreamingATR
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Average True Range with TA-Lib-compatible Wilder seeding.
|
||||
///
|
||||
/// Accepts (high, low, close) per bar.
|
||||
/// Returns NaN during the first `period` bars.
|
||||
pub struct StreamingATR {
|
||||
inner: AtrState,
|
||||
}
|
||||
|
||||
impl StreamingATR {
|
||||
pub fn new(period: usize) -> Result<Self, StreamingError> {
|
||||
validate_timeperiod(period, "period", 1)?;
|
||||
Ok(Self {
|
||||
inner: AtrState::new(period),
|
||||
})
|
||||
}
|
||||
|
||||
/// Add a new bar (high, low, close) and return ATR (NaN during warmup).
|
||||
pub fn update(&mut self, high: f64, low: f64, close: f64) -> f64 {
|
||||
self.inner.update(high, low, close)
|
||||
}
|
||||
|
||||
pub fn reset(&mut self) {
|
||||
self.inner.reset();
|
||||
}
|
||||
|
||||
pub fn period(&self) -> usize {
|
||||
self.inner.period()
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// StreamingBBands
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Bollinger Bands — streaming variant using Welford's online algorithm.
|
||||
///
|
||||
/// Returns (upper, middle, lower).
|
||||
/// NaN tuple during the warmup window.
|
||||
pub struct StreamingBBands {
|
||||
period: usize,
|
||||
nbdevup: f64,
|
||||
nbdevdn: f64,
|
||||
buf: VecDeque<f64>,
|
||||
mean: f64,
|
||||
m2: f64,
|
||||
}
|
||||
|
||||
impl StreamingBBands {
|
||||
pub fn new(period: usize, nbdevup: f64, nbdevdn: f64) -> Result<Self, StreamingError> {
|
||||
validate_timeperiod(period, "period", 2)?;
|
||||
Ok(Self {
|
||||
period,
|
||||
nbdevup,
|
||||
nbdevdn,
|
||||
buf: VecDeque::with_capacity(period + 1),
|
||||
mean: 0.0,
|
||||
m2: 0.0,
|
||||
})
|
||||
}
|
||||
|
||||
/// Add a new bar; return (upper, middle, lower). NaN tuple during warmup.
|
||||
pub fn update(&mut self, value: f64) -> (f64, f64, f64) {
|
||||
let n = self.buf.len();
|
||||
|
||||
if n == self.period {
|
||||
let x_old = self.buf.pop_front().unwrap();
|
||||
let count = self.period as f64;
|
||||
let delta_old = x_old - self.mean;
|
||||
self.mean -= delta_old / (count - 1.0);
|
||||
let delta2_old = x_old - self.mean;
|
||||
self.m2 -= delta_old * delta2_old;
|
||||
}
|
||||
|
||||
self.buf.push_back(value);
|
||||
let count = self.buf.len() as f64;
|
||||
let delta_new = value - self.mean;
|
||||
self.mean += delta_new / count;
|
||||
let delta2_new = value - self.mean;
|
||||
self.m2 += delta_new * delta2_new;
|
||||
|
||||
if self.m2 < 0.0 {
|
||||
self.m2 = 0.0;
|
||||
}
|
||||
|
||||
if self.buf.len() < self.period {
|
||||
return (f64::NAN, f64::NAN, f64::NAN);
|
||||
}
|
||||
|
||||
let variance = self.m2 / (count - 1.0);
|
||||
let std = variance.sqrt();
|
||||
(
|
||||
self.mean + self.nbdevup * std,
|
||||
self.mean,
|
||||
self.mean - self.nbdevdn * std,
|
||||
)
|
||||
}
|
||||
|
||||
pub fn reset(&mut self) {
|
||||
self.buf.clear();
|
||||
self.mean = 0.0;
|
||||
self.m2 = 0.0;
|
||||
}
|
||||
|
||||
pub fn period(&self) -> usize {
|
||||
self.period
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// StreamingMACD
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// MACD — fast EMA, slow EMA, signal EMA.
|
||||
///
|
||||
/// Returns (macd_line, signal_line, histogram).
|
||||
/// NaN values during warmup.
|
||||
pub struct StreamingMACD {
|
||||
fast: EmaState,
|
||||
slow: EmaState,
|
||||
signal: EmaState,
|
||||
}
|
||||
|
||||
impl StreamingMACD {
|
||||
pub fn new(
|
||||
fastperiod: usize,
|
||||
slowperiod: usize,
|
||||
signalperiod: usize,
|
||||
) -> Result<Self, StreamingError> {
|
||||
validate_timeperiod(fastperiod, "fastperiod", 1)?;
|
||||
validate_timeperiod(slowperiod, "slowperiod", 1)?;
|
||||
validate_timeperiod(signalperiod, "signalperiod", 1)?;
|
||||
if fastperiod >= slowperiod {
|
||||
return Err(StreamingError(
|
||||
"fastperiod must be < slowperiod".to_string(),
|
||||
));
|
||||
}
|
||||
Ok(Self {
|
||||
fast: EmaState::new(fastperiod),
|
||||
slow: EmaState::new(slowperiod),
|
||||
signal: EmaState::new(signalperiod),
|
||||
})
|
||||
}
|
||||
|
||||
/// Add a new close; return (macd_line, signal_line, histogram).
|
||||
pub fn update(&mut self, value: f64) -> (f64, f64, f64) {
|
||||
let fast_val = self.fast.update(value);
|
||||
let slow_val = self.slow.update(value);
|
||||
|
||||
if slow_val.is_nan() {
|
||||
return (f64::NAN, f64::NAN, f64::NAN);
|
||||
}
|
||||
|
||||
let macd = fast_val - slow_val;
|
||||
let signal = self.signal.update(macd);
|
||||
if signal.is_nan() {
|
||||
return (macd, f64::NAN, f64::NAN);
|
||||
}
|
||||
(macd, signal, macd - signal)
|
||||
}
|
||||
|
||||
pub fn reset(&mut self) {
|
||||
self.fast.reset();
|
||||
self.slow.reset();
|
||||
self.signal.reset();
|
||||
}
|
||||
|
||||
pub fn fast_period(&self) -> usize {
|
||||
self.fast.period()
|
||||
}
|
||||
|
||||
pub fn slow_period(&self) -> usize {
|
||||
self.slow.period()
|
||||
}
|
||||
|
||||
pub fn signal_period(&self) -> usize {
|
||||
self.signal.period()
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// StreamingStoch
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Slow Stochastic (SMA-smoothed).
|
||||
///
|
||||
/// Returns (slowk, slowd).
|
||||
/// NaN tuple during warmup.
|
||||
pub struct StreamingStoch {
|
||||
fastk_period: usize,
|
||||
slowk_period: usize,
|
||||
slowd_period: usize,
|
||||
high_buf: VecDeque<f64>,
|
||||
low_buf: VecDeque<f64>,
|
||||
fastk_buf: VecDeque<f64>,
|
||||
slowk_buf: VecDeque<f64>,
|
||||
}
|
||||
|
||||
impl StreamingStoch {
|
||||
pub fn new(
|
||||
fastk_period: usize,
|
||||
slowk_period: usize,
|
||||
slowd_period: usize,
|
||||
) -> Result<Self, StreamingError> {
|
||||
validate_timeperiod(fastk_period, "fastk_period", 1)?;
|
||||
validate_timeperiod(slowk_period, "slowk_period", 1)?;
|
||||
validate_timeperiod(slowd_period, "slowd_period", 1)?;
|
||||
Ok(Self {
|
||||
fastk_period,
|
||||
slowk_period,
|
||||
slowd_period,
|
||||
high_buf: VecDeque::with_capacity(fastk_period + 1),
|
||||
low_buf: VecDeque::with_capacity(fastk_period + 1),
|
||||
fastk_buf: VecDeque::with_capacity(slowk_period + 1),
|
||||
slowk_buf: VecDeque::with_capacity(slowd_period + 1),
|
||||
})
|
||||
}
|
||||
|
||||
/// Add a new bar (high, low, close); return (slowk, slowd).
|
||||
pub fn update(&mut self, high: f64, low: f64, close: f64) -> (f64, f64) {
|
||||
if self.high_buf.len() == self.fastk_period {
|
||||
self.high_buf.pop_front();
|
||||
self.low_buf.pop_front();
|
||||
}
|
||||
self.high_buf.push_back(high);
|
||||
self.low_buf.push_back(low);
|
||||
|
||||
if self.high_buf.len() < self.fastk_period {
|
||||
return (f64::NAN, f64::NAN);
|
||||
}
|
||||
|
||||
let max_h = self
|
||||
.high_buf
|
||||
.iter()
|
||||
.cloned()
|
||||
.fold(f64::NEG_INFINITY, f64::max);
|
||||
let min_l = self.low_buf.iter().cloned().fold(f64::INFINITY, f64::min);
|
||||
|
||||
let fastk = if max_h != min_l {
|
||||
100.0 * (close - min_l) / (max_h - min_l)
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
|
||||
if self.fastk_buf.len() == self.slowk_period {
|
||||
self.fastk_buf.pop_front();
|
||||
}
|
||||
self.fastk_buf.push_back(fastk);
|
||||
if self.fastk_buf.len() < self.slowk_period {
|
||||
return (f64::NAN, f64::NAN);
|
||||
}
|
||||
|
||||
let slowk = self.fastk_buf.iter().sum::<f64>() / self.slowk_period as f64;
|
||||
|
||||
if self.slowk_buf.len() == self.slowd_period {
|
||||
self.slowk_buf.pop_front();
|
||||
}
|
||||
self.slowk_buf.push_back(slowk);
|
||||
if self.slowk_buf.len() < self.slowd_period {
|
||||
return (slowk, f64::NAN);
|
||||
}
|
||||
|
||||
let slowd = self.slowk_buf.iter().sum::<f64>() / self.slowd_period as f64;
|
||||
(slowk, slowd)
|
||||
}
|
||||
|
||||
pub fn reset(&mut self) {
|
||||
self.high_buf.clear();
|
||||
self.low_buf.clear();
|
||||
self.fastk_buf.clear();
|
||||
self.slowk_buf.clear();
|
||||
}
|
||||
|
||||
pub fn period(&self) -> usize {
|
||||
self.fastk_period
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// StreamingVWAP
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Cumulative Volume Weighted Average Price.
|
||||
///
|
||||
/// Resets automatically when `reset()` is called (e.g. at session open).
|
||||
/// Accepts (high, low, close, volume) per bar.
|
||||
#[derive(Default)]
|
||||
pub struct StreamingVWAP {
|
||||
cum_tpv: f64,
|
||||
cum_vol: f64,
|
||||
}
|
||||
|
||||
impl StreamingVWAP {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
cum_tpv: 0.0,
|
||||
cum_vol: 0.0,
|
||||
}
|
||||
}
|
||||
|
||||
/// Add a new bar (high, low, close, volume) and return cumulative VWAP.
|
||||
pub fn update(&mut self, high: f64, low: f64, close: f64, volume: f64) -> f64 {
|
||||
let tp = (high + low + close) / 3.0;
|
||||
self.cum_tpv += tp * volume;
|
||||
self.cum_vol += volume;
|
||||
if self.cum_vol == 0.0 {
|
||||
f64::NAN
|
||||
} else {
|
||||
self.cum_tpv / self.cum_vol
|
||||
}
|
||||
}
|
||||
|
||||
/// Reset for a new session.
|
||||
pub fn reset(&mut self) {
|
||||
self.cum_tpv = 0.0;
|
||||
self.cum_vol = 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// StreamingSupertrend
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// ATR-based Supertrend — streaming variant.
|
||||
///
|
||||
/// Accepts (high, low, close) per bar.
|
||||
/// Returns (supertrend_line, direction).
|
||||
/// direction: 1 = uptrend, -1 = downtrend, 0 = warmup.
|
||||
pub struct StreamingSupertrend {
|
||||
period: usize,
|
||||
multiplier: f64,
|
||||
atr: AtrState,
|
||||
upper_band: f64,
|
||||
lower_band: f64,
|
||||
has_bands: bool,
|
||||
direction: i8,
|
||||
prev_close: f64,
|
||||
has_prev: bool,
|
||||
}
|
||||
|
||||
impl StreamingSupertrend {
|
||||
pub fn new(period: usize, multiplier: f64) -> Result<Self, StreamingError> {
|
||||
validate_timeperiod(period, "period", 1)?;
|
||||
Ok(Self {
|
||||
period,
|
||||
multiplier,
|
||||
atr: AtrState::new(period),
|
||||
upper_band: 0.0,
|
||||
lower_band: 0.0,
|
||||
has_bands: false,
|
||||
direction: 0,
|
||||
prev_close: 0.0,
|
||||
has_prev: false,
|
||||
})
|
||||
}
|
||||
|
||||
/// Add a new bar (high, low, close); return (supertrend_line, direction).
|
||||
pub fn update(&mut self, high: f64, low: f64, close: f64) -> (f64, i8) {
|
||||
let atr = self.atr.update(high, low, close);
|
||||
if atr.is_nan() {
|
||||
self.prev_close = close;
|
||||
self.has_prev = true;
|
||||
return (f64::NAN, 0);
|
||||
}
|
||||
|
||||
let hl2 = (high + low) / 2.0;
|
||||
let upper_basic = hl2 + self.multiplier * atr;
|
||||
let lower_basic = hl2 - self.multiplier * atr;
|
||||
|
||||
if !self.has_bands {
|
||||
self.upper_band = upper_basic;
|
||||
self.lower_band = lower_basic;
|
||||
self.has_bands = true;
|
||||
self.direction = -1;
|
||||
self.prev_close = close;
|
||||
self.has_prev = true;
|
||||
return (self.upper_band, self.direction);
|
||||
}
|
||||
|
||||
let prev_close = self.prev_close;
|
||||
|
||||
let new_lower = if lower_basic > self.lower_band || prev_close < self.lower_band {
|
||||
lower_basic
|
||||
} else {
|
||||
self.lower_band
|
||||
};
|
||||
let new_upper = if upper_basic < self.upper_band || prev_close > self.upper_band {
|
||||
upper_basic
|
||||
} else {
|
||||
self.upper_band
|
||||
};
|
||||
|
||||
self.lower_band = new_lower;
|
||||
self.upper_band = new_upper;
|
||||
|
||||
self.direction = if self.direction == -1 {
|
||||
if close > new_upper {
|
||||
1
|
||||
} else {
|
||||
-1
|
||||
}
|
||||
} else if close < new_lower {
|
||||
-1
|
||||
} else {
|
||||
1
|
||||
};
|
||||
|
||||
self.prev_close = close;
|
||||
let line = if self.direction == 1 {
|
||||
new_lower
|
||||
} else {
|
||||
new_upper
|
||||
};
|
||||
(line, self.direction)
|
||||
}
|
||||
|
||||
pub fn reset(&mut self) {
|
||||
self.atr.reset();
|
||||
self.upper_band = 0.0;
|
||||
self.lower_band = 0.0;
|
||||
self.has_bands = false;
|
||||
self.direction = 0;
|
||||
self.prev_close = 0.0;
|
||||
self.has_prev = false;
|
||||
}
|
||||
|
||||
pub fn period(&self) -> usize {
|
||||
self.period
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// Helper: compare two f64 values, treating NaN == NaN as true.
|
||||
fn approx_eq(a: f64, b: f64, tol: f64) -> bool {
|
||||
if a.is_nan() && b.is_nan() {
|
||||
return true;
|
||||
}
|
||||
(a - b).abs() < tol
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_sma_basic() {
|
||||
let mut sma = StreamingSMA::new(3).unwrap();
|
||||
assert!(sma.update(1.0).is_nan());
|
||||
assert!(sma.update(2.0).is_nan());
|
||||
let v = sma.update(3.0);
|
||||
assert!(approx_eq(v, 2.0, 1e-10));
|
||||
let v = sma.update(4.0);
|
||||
assert!(approx_eq(v, 3.0, 1e-10));
|
||||
let v = sma.update(5.0);
|
||||
assert!(approx_eq(v, 4.0, 1e-10));
|
||||
assert_eq!(sma.period(), 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_sma_reset() {
|
||||
let mut sma = StreamingSMA::new(2).unwrap();
|
||||
sma.update(10.0);
|
||||
sma.update(20.0);
|
||||
sma.reset();
|
||||
assert!(sma.update(5.0).is_nan());
|
||||
let v = sma.update(7.0);
|
||||
assert!(approx_eq(v, 6.0, 1e-10));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ema_warmup_and_decay() {
|
||||
let mut ema = StreamingEMA::new(3).unwrap();
|
||||
assert!(ema.update(2.0).is_nan());
|
||||
assert!(ema.update(4.0).is_nan());
|
||||
// Third bar: SMA seed = (2+4+6)/3 = 4.0
|
||||
let v = ema.update(6.0);
|
||||
assert!(approx_eq(v, 4.0, 1e-10));
|
||||
// Fourth bar: alpha = 0.5, ema = 4.0 + 0.5*(8.0-4.0) = 6.0
|
||||
let v = ema.update(8.0);
|
||||
assert!(approx_eq(v, 6.0, 1e-10));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rsi_warmup() {
|
||||
let mut rsi = StreamingRSI::new(3).unwrap();
|
||||
// First bar: no prev
|
||||
assert!(rsi.update(44.0).is_nan());
|
||||
// Bars 2-4: collecting gains/losses
|
||||
assert!(rsi.update(44.5).is_nan());
|
||||
assert!(rsi.update(43.5).is_nan());
|
||||
// Bar 5: seeded
|
||||
let v = rsi.update(44.5);
|
||||
assert!(!v.is_nan());
|
||||
assert!(v >= 0.0 && v <= 100.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_atr_warmup() {
|
||||
let mut atr = StreamingATR::new(3).unwrap();
|
||||
// First 3 bars return NaN (period = 3, seed happens on bar 3 but still NaN)
|
||||
assert!(atr.update(10.0, 9.0, 9.5).is_nan());
|
||||
assert!(atr.update(11.0, 9.5, 10.5).is_nan());
|
||||
assert!(atr.update(10.5, 9.0, 9.5).is_nan());
|
||||
// Bar 4: first real value
|
||||
let v = atr.update(11.0, 10.0, 10.5);
|
||||
assert!(!v.is_nan());
|
||||
assert!(v > 0.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bbands_warmup() {
|
||||
let mut bb = StreamingBBands::new(3, 2.0, 2.0).unwrap();
|
||||
let (u, m, l) = bb.update(10.0);
|
||||
assert!(u.is_nan() && m.is_nan() && l.is_nan());
|
||||
let (u, m, l) = bb.update(11.0);
|
||||
assert!(u.is_nan() && m.is_nan() && l.is_nan());
|
||||
let (u, m, l) = bb.update(12.0);
|
||||
assert!(!u.is_nan() && !m.is_nan() && !l.is_nan());
|
||||
assert!(approx_eq(m, 11.0, 1e-10));
|
||||
assert!(u > m && l < m);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_macd_basic() {
|
||||
let mut macd = StreamingMACD::new(3, 5, 2).unwrap();
|
||||
// Feed enough bars for the slow (5) to seed
|
||||
for i in 0..4 {
|
||||
let (m, s, h) = macd.update(100.0 + i as f64);
|
||||
assert!(m.is_nan());
|
||||
}
|
||||
// Bar 5: slow seeds
|
||||
let (m, s, _h) = macd.update(104.0);
|
||||
assert!(!m.is_nan());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_macd_fast_ge_slow_rejected() {
|
||||
assert!(StreamingMACD::new(5, 3, 2).is_err());
|
||||
assert!(StreamingMACD::new(5, 5, 2).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_stoch_basic() {
|
||||
let mut stoch = StreamingStoch::new(3, 2, 2).unwrap();
|
||||
// Need fastk_period bars, then slowk_period, then slowd_period
|
||||
let (k, d) = stoch.update(10.0, 8.0, 9.0);
|
||||
assert!(k.is_nan() && d.is_nan());
|
||||
let (k, d) = stoch.update(11.0, 9.0, 10.0);
|
||||
assert!(k.is_nan() && d.is_nan());
|
||||
// Bar 3: fastk ready, collecting slowk
|
||||
let (k, d) = stoch.update(12.0, 10.0, 11.0);
|
||||
assert!(k.is_nan());
|
||||
// Bar 4
|
||||
let (k, d) = stoch.update(13.0, 11.0, 12.0);
|
||||
assert!(!k.is_nan());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_vwap_basic() {
|
||||
let mut vwap = StreamingVWAP::new();
|
||||
let v = vwap.update(10.0, 8.0, 9.0, 100.0);
|
||||
// tp = (10+8+9)/3 = 9.0, vwap = 9.0*100/100 = 9.0
|
||||
assert!(approx_eq(v, 9.0, 1e-10));
|
||||
let v = vwap.update(12.0, 10.0, 11.0, 200.0);
|
||||
// tp2 = 11.0, cum_tpv = 900+2200=3100, cum_vol=300, vwap=10.333..
|
||||
assert!(approx_eq(v, 3100.0 / 300.0, 1e-10));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_vwap_zero_volume() {
|
||||
let mut vwap = StreamingVWAP::new();
|
||||
let v = vwap.update(10.0, 8.0, 9.0, 0.0);
|
||||
assert!(v.is_nan());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_supertrend_warmup() {
|
||||
let mut st = StreamingSupertrend::new(3, 2.0).unwrap();
|
||||
let (line, dir) = st.update(10.0, 9.0, 9.5);
|
||||
assert!(line.is_nan() && dir == 0);
|
||||
let (line, dir) = st.update(11.0, 9.5, 10.5);
|
||||
assert!(line.is_nan() && dir == 0);
|
||||
let (line, dir) = st.update(10.5, 9.0, 9.5);
|
||||
assert!(line.is_nan() && dir == 0);
|
||||
// Bar 4: first real value
|
||||
let (line, dir) = st.update(11.0, 10.0, 10.5);
|
||||
assert!(!line.is_nan());
|
||||
assert!(dir == 1 || dir == -1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_streaming_sma_matches_batch() {
|
||||
// Compare streaming SMA against a simple batch computation
|
||||
let data = vec![1.0, 3.0, 5.0, 7.0, 9.0, 11.0, 13.0];
|
||||
let period = 3;
|
||||
let mut sma = StreamingSMA::new(period).unwrap();
|
||||
let streaming: Vec<f64> = data.iter().map(|&v| sma.update(v)).collect();
|
||||
|
||||
// Batch SMA
|
||||
for i in 0..data.len() {
|
||||
if i + 1 < period {
|
||||
assert!(streaming[i].is_nan(), "bar {} should be NaN", i);
|
||||
} else {
|
||||
let batch: f64 = data[i + 1 - period..=i].iter().sum::<f64>() / period as f64;
|
||||
assert!(
|
||||
approx_eq(streaming[i], batch, 1e-10),
|
||||
"bar {}: streaming={} batch={}",
|
||||
i,
|
||||
streaming[i],
|
||||
batch
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,95 @@
|
||||
//! Volatility indicators.
|
||||
|
||||
/// Compute the Average True Range (ATR), Wilder smoothed (TA-Lib compatible).
|
||||
///
|
||||
/// ATR measures market volatility by smoothing the True Range with Wilder's
|
||||
/// method. Seeded with the SMA of `TR[1..=timeperiod]` (bar 0 is skipped,
|
||||
/// matching TA-Lib). Returns non-negative values; the first `timeperiod`
|
||||
/// indices are `NaN`.
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `high` / `low` / `close` - OHLC price series (same length).
|
||||
/// * `timeperiod` - Smoothing period (typically 14).
|
||||
pub fn atr(high: &[f64], low: &[f64], close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let n = high.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if n <= timeperiod || timeperiod < 1 {
|
||||
return result;
|
||||
}
|
||||
// Seed: SMA of TR[1..=timeperiod] (TA-Lib skips TR[0]).
|
||||
// Compute TR on-the-fly to avoid a separate Vec allocation.
|
||||
let mut seed = 0.0_f64;
|
||||
for i in 1..=timeperiod {
|
||||
let hl = high[i] - low[i];
|
||||
let hpc = (high[i] - close[i - 1]).abs();
|
||||
let lpc = (low[i] - close[i - 1]).abs();
|
||||
seed += hl.max(hpc).max(lpc);
|
||||
}
|
||||
seed /= timeperiod as f64;
|
||||
result[timeperiod] = seed;
|
||||
let p = timeperiod as f64;
|
||||
for i in (timeperiod + 1)..n {
|
||||
let hl = high[i] - low[i];
|
||||
let hpc = (high[i] - close[i - 1]).abs();
|
||||
let lpc = (low[i] - close[i - 1]).abs();
|
||||
let tr = hl.max(hpc).max(lpc);
|
||||
result[i] = (result[i - 1] * (p - 1.0) + tr) / p;
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// Compute the True Range for each bar.
|
||||
///
|
||||
/// `TR = max(H - L, |H - C_prev|, |L - C_prev|)`. For bar 0, TR is
|
||||
/// simply `H - L` (no previous close available). Returns non-negative
|
||||
/// values for every bar (no `NaN` warmup).
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `high` / `low` / `close` - OHLC price series (same length).
|
||||
pub fn trange(high: &[f64], low: &[f64], close: &[f64]) -> Vec<f64> {
|
||||
let n = high.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if n == 0 {
|
||||
return result;
|
||||
}
|
||||
result[0] = high[0] - low[0];
|
||||
for i in 1..n {
|
||||
let hl = high[i] - low[i];
|
||||
let hpc = (high[i] - close[i - 1]).abs();
|
||||
let lpc = (low[i] - close[i - 1]).abs();
|
||||
result[i] = hl.max(hpc).max(lpc);
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// Normalized Average True Range: `ATR / close * 100`.
|
||||
pub fn natr(high: &[f64], low: &[f64], close: &[f64], timeperiod: usize) -> Vec<f64> {
|
||||
let atr_vals = atr(high, low, close, timeperiod);
|
||||
atr_vals
|
||||
.iter()
|
||||
.zip(close.iter())
|
||||
.map(|(&a, &c)| {
|
||||
if a.is_nan() || c == 0.0 {
|
||||
f64::NAN
|
||||
} else {
|
||||
a / c * 100.0
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn atr_nonnegative() {
|
||||
let h = vec![2.0, 3.0, 4.0, 5.0, 6.0];
|
||||
let l = vec![1.0, 2.0, 3.0, 4.0, 5.0];
|
||||
let c = vec![1.5, 2.5, 3.5, 4.5, 5.5];
|
||||
let result = atr(&h, &l, &c, 3);
|
||||
for v in result.iter().filter(|v| !v.is_nan()) {
|
||||
assert!(*v >= 0.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,193 @@
|
||||
//! Volume indicators.
|
||||
|
||||
/// Compute On-Balance Volume (OBV).
|
||||
///
|
||||
/// OBV is a cumulative indicator that adds volume on up-close bars and
|
||||
/// subtracts volume on down-close bars. Unchanged closes contribute zero.
|
||||
/// Returns a `Vec<f64>` of length `n` with no `NaN` values.
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `close` - Price series.
|
||||
/// * `volume` - Volume series (same length as `close`).
|
||||
pub fn obv(close: &[f64], volume: &[f64]) -> Vec<f64> {
|
||||
let n = close.len();
|
||||
let mut result = vec![0.0_f64; n];
|
||||
if n == 0 {
|
||||
return result;
|
||||
}
|
||||
// result[0] stays 0; accumulation starts from bar 1
|
||||
for i in 1..n {
|
||||
result[i] = result[i - 1]
|
||||
+ if close[i] > close[i - 1] {
|
||||
volume[i]
|
||||
} else if close[i] < close[i - 1] {
|
||||
-volume[i]
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// Compute the Money Flow Index (MFI).
|
||||
///
|
||||
/// MFI is a volume-weighted RSI, returning values in `[0, 100]`.
|
||||
/// `typical_price = (H + L + C) / 3`; money flow is positive when
|
||||
/// typical price rises, negative when it falls. The first `timeperiod`
|
||||
/// values are `NaN`.
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `high` / `low` / `close` - OHLC price series (same length).
|
||||
/// * `volume` - Volume series (same length).
|
||||
/// * `timeperiod` - Lookback window (typically 14).
|
||||
pub fn mfi(
|
||||
high: &[f64],
|
||||
low: &[f64],
|
||||
close: &[f64],
|
||||
volume: &[f64],
|
||||
timeperiod: usize,
|
||||
) -> Vec<f64> {
|
||||
let n = high.len();
|
||||
let mut result = vec![f64::NAN; n];
|
||||
if timeperiod < 1 || n <= timeperiod {
|
||||
return result;
|
||||
}
|
||||
|
||||
let mut pos_flow = vec![0.0_f64; n];
|
||||
let mut neg_flow = vec![0.0_f64; n];
|
||||
let mut tp_prev = (high[0] + low[0] + close[0]) / 3.0;
|
||||
|
||||
for i in 1..n {
|
||||
let tp_cur = (high[i] + low[i] + close[i]) / 3.0;
|
||||
let rmf = tp_cur * volume[i];
|
||||
if tp_cur > tp_prev {
|
||||
pos_flow[i] = rmf;
|
||||
} else if tp_cur < tp_prev {
|
||||
neg_flow[i] = rmf;
|
||||
}
|
||||
tp_prev = tp_cur;
|
||||
}
|
||||
|
||||
// Sliding window sum over timeperiod bars (indices i+1-timeperiod ..= i).
|
||||
// First valid window: indices 1..=timeperiod.
|
||||
let mut pos_sum: f64 = pos_flow[1..=timeperiod].iter().sum();
|
||||
let mut neg_sum: f64 = neg_flow[1..=timeperiod].iter().sum();
|
||||
let mfr = if neg_sum == 0.0 {
|
||||
f64::MAX
|
||||
} else {
|
||||
pos_sum / neg_sum
|
||||
};
|
||||
result[timeperiod] = 100.0 - 100.0 / (1.0 + mfr);
|
||||
|
||||
for i in (timeperiod + 1)..n {
|
||||
pos_sum += pos_flow[i] - pos_flow[i - timeperiod];
|
||||
neg_sum += neg_flow[i] - neg_flow[i - timeperiod];
|
||||
let mfr = if neg_sum == 0.0 {
|
||||
f64::MAX
|
||||
} else {
|
||||
pos_sum / neg_sum
|
||||
};
|
||||
result[i] = 100.0 - 100.0 / (1.0 + mfr);
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// Chaikin Accumulation/Distribution Line.
|
||||
///
|
||||
/// Cumulates `(close - low - (high - close)) / (high - low) * volume`.
|
||||
pub fn ad(high: &[f64], low: &[f64], close: &[f64], volume: &[f64]) -> Vec<f64> {
|
||||
let n = high.len();
|
||||
let mut result = vec![0.0_f64; n];
|
||||
let mut ad_val = 0.0_f64;
|
||||
for i in 0..n {
|
||||
let hl = high[i] - low[i];
|
||||
let clv = if hl != 0.0 {
|
||||
((close[i] - low[i]) - (high[i] - close[i])) / hl
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
ad_val += clv * volume[i];
|
||||
result[i] = ad_val;
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// Chaikin A/D Oscillator: fast EMA of AD minus slow EMA of AD.
|
||||
///
|
||||
/// Uses the core EMA implementation from `overlap::ema`.
|
||||
pub fn adosc(
|
||||
high: &[f64],
|
||||
low: &[f64],
|
||||
close: &[f64],
|
||||
volume: &[f64],
|
||||
fastperiod: usize,
|
||||
slowperiod: usize,
|
||||
) -> Vec<f64> {
|
||||
let n = high.len();
|
||||
let ad_vals = ad(high, low, close, volume);
|
||||
let fast_ema = crate::overlap::ema(&ad_vals, fastperiod);
|
||||
let slow_ema = crate::overlap::ema(&ad_vals, slowperiod);
|
||||
let warmup = slowperiod - 1;
|
||||
let mut result = vec![f64::NAN; n];
|
||||
for i in warmup..n {
|
||||
if !fast_ema[i].is_nan() && !slow_ema[i].is_nan() {
|
||||
result[i] = fast_ema[i] - slow_ema[i];
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn obv_up_trend() {
|
||||
let c = vec![1.0, 2.0, 3.0];
|
||||
let v = vec![100.0, 200.0, 300.0];
|
||||
let result = obv(&c, &v);
|
||||
assert!((result[0] - 0.0).abs() < 1e-10);
|
||||
assert!((result[1] - 200.0).abs() < 1e-10);
|
||||
assert!((result[2] - 500.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ad_basic() {
|
||||
let h = vec![10.0, 12.0, 11.0];
|
||||
let l = vec![8.0, 9.0, 9.0];
|
||||
let c = vec![9.0, 11.0, 10.0];
|
||||
let v = vec![1000.0, 2000.0, 1500.0];
|
||||
let result = ad(&h, &l, &c, &v);
|
||||
assert_eq!(result.len(), 3);
|
||||
// CLV[0] = ((9-8) - (10-9)) / (10-8) = (1 - 1) / 2 = 0
|
||||
assert!((result[0] - 0.0).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn adosc_basic() {
|
||||
let n = 30;
|
||||
let h: Vec<f64> = (1..=n).map(|i| i as f64 + 1.0).collect();
|
||||
let l: Vec<f64> = (1..=n).map(|i| i as f64 - 1.0).collect();
|
||||
let c: Vec<f64> = (1..=n).map(|i| i as f64).collect();
|
||||
let v: Vec<f64> = vec![1000.0; n];
|
||||
let result = adosc(&h, &l, &c, &v, 3, 10);
|
||||
assert_eq!(result.len(), n);
|
||||
// Warmup period should be NaN
|
||||
for i in 0..9 {
|
||||
assert!(result[i].is_nan());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mfi_range() {
|
||||
let n = 50;
|
||||
let high: Vec<f64> = (1..=n).map(|i| i as f64 + 0.5).collect();
|
||||
let low: Vec<f64> = (1..=n).map(|i| i as f64 - 0.5).collect();
|
||||
let close: Vec<f64> = (1..=n).map(|i| i as f64).collect();
|
||||
let volume: Vec<f64> = vec![1_000_000.0; n];
|
||||
let result = mfi(&high, &low, &close, &volume, 14);
|
||||
for v in result.iter().filter(|v| !v.is_nan()) {
|
||||
assert!(*v >= 0.0 && *v <= 100.0, "MFI out of range: {v}");
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user