feat: add 9 Risk / Performance indicators (B18) (#218)
Adds nine risk/performance metrics to the existing **Risk / Performance** family, all consuming a per-period return series (`f64` in, `f64` out). Indicator count **498 → 507**. ## Indicators Single-param (`new(period)`, macro bindings): - **SterlingRatio** — mean return over average drawdown of the equity curve. - **BurkeRatio** — return over root-sum-squared drawdowns. - **MartinRatio** — Ulcer Performance Index; return over RMS percentage drawdown. - **TailRatio** — 95th percentile over the absolute 5th percentile return. - **KRatio** — Kestner; equity-curve OLS slope over the standard error of that slope. - **CommonSenseRatio** — tail ratio times gain-to-pain. - **GainToPainRatio** — sum of returns over the sum of absolute losses. Multi-param (hand-written Python/Node bindings, variadic WASM macro): - **UpsidePotentialRatio** — `new(period, mar)`; upside mean over downside deviation (Sortino philosophy). - **M2Measure** — `new(period, risk_free, benchmark_stddev)`; Modigliani M², Sharpe rescaled into benchmark return units. ## Touchpoints Core modules + unit tests, `mod.rs`/`lib.rs` wiring, Python/Node/WASM bindings (`index.d.ts`/`index.js` regenerated), fuzz drive lines, Python `SCALAR` registry + Node factories, CHANGELOG, and the indicator counters. ## Verification - `cargo test -p wickra-core --lib` — 4149 passed - `cargo test -p wickra-core --doc` — 457 passed - `cargo clippy --workspace --all-targets --all-features -- -D warnings` — clean - `npm test` (node) — 577 passed - `pytest` (python) — 947 passed
This commit is contained in:
kingchenc
@@ -0,0 +1,218 @@
|
||||
//! Burke Ratio — mean return over the square root of the summed squared drawdowns.
|
||||
|
||||
use std::collections::VecDeque;
|
||||
|
||||
use crate::error::{Error, Result};
|
||||
use crate::traits::Indicator;
|
||||
|
||||
/// Burke Ratio over a trailing window of `period` returns.
|
||||
///
|
||||
/// ```text
|
||||
/// equity_t = Π_{i<=t} (1 + return_i) (compounded curve)
|
||||
/// peak_t = max_{s<=t} equity_s
|
||||
/// dd_t = (peak_t − equity_t) / peak_t (fractional drawdown, >= 0)
|
||||
/// Burke = mean(returns) / sqrt( Σ dd_t² )
|
||||
/// ```
|
||||
///
|
||||
/// The Burke Ratio divides the average per-period return by the **Euclidean norm of
|
||||
/// the drawdowns** — the square root of the *sum* of squared drawdowns. Squaring
|
||||
/// penalises deep drawdowns far more than shallow ones, and summing (rather than
|
||||
/// averaging) means the denominator grows with both the depth and the *number* of
|
||||
/// drawdowns. This makes Burke the most outlier-sensitive of Wickra's three
|
||||
/// drawdown ratios: where the [`SterlingRatio`](crate::SterlingRatio) averages raw
|
||||
/// drawdowns and shrugs off a single crater, Burke makes that crater dominate.
|
||||
/// The [`MartinRatio`](crate::MartinRatio) sits between them with a root-*mean*
|
||||
/// square of percentage drawdowns. A window that never draws down has a zero
|
||||
/// denominator and the indicator reports `0.0`.
|
||||
///
|
||||
/// The first value lands after `period` returns; each `update` rebuilds the equity
|
||||
/// curve over the window (O(period)), which is O(1) in the length of the overall
|
||||
/// series.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```
|
||||
/// use wickra_core::{Indicator, BurkeRatio};
|
||||
///
|
||||
/// let mut indicator = BurkeRatio::new(12).unwrap();
|
||||
/// let mut last = None;
|
||||
/// for i in 0..24 {
|
||||
/// last = indicator.update((f64::from(i) * 0.5).sin() * 0.05);
|
||||
/// }
|
||||
/// assert!(last.is_some());
|
||||
/// ```
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct BurkeRatio {
|
||||
period: usize,
|
||||
window: VecDeque<f64>,
|
||||
}
|
||||
|
||||
impl BurkeRatio {
|
||||
/// Construct a Burke Ratio over `period` returns.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// Returns [`Error::InvalidPeriod`] if `period < 2`.
|
||||
pub fn new(period: usize) -> Result<Self> {
|
||||
if period < 2 {
|
||||
return Err(Error::InvalidPeriod {
|
||||
message: "burke ratio needs period >= 2",
|
||||
});
|
||||
}
|
||||
Ok(Self {
|
||||
period,
|
||||
window: VecDeque::with_capacity(period),
|
||||
})
|
||||
}
|
||||
|
||||
/// Configured window of returns.
|
||||
pub const fn period(&self) -> usize {
|
||||
self.period
|
||||
}
|
||||
|
||||
fn compute(&self) -> f64 {
|
||||
#[allow(clippy::cast_precision_loss)]
|
||||
let length = self.window.len() as f64;
|
||||
let mut sum_return = 0.0;
|
||||
let mut sum_drawdown_sq = 0.0;
|
||||
let mut equity = 1.0;
|
||||
let mut peak: f64 = 1.0;
|
||||
for ret in &self.window {
|
||||
sum_return += *ret;
|
||||
equity *= 1.0 + *ret;
|
||||
peak = peak.max(equity);
|
||||
let drawdown = (peak - equity) / peak;
|
||||
sum_drawdown_sq += drawdown * drawdown;
|
||||
}
|
||||
let denom = sum_drawdown_sq.sqrt();
|
||||
if denom > 0.0 {
|
||||
(sum_return / length) / denom
|
||||
} else {
|
||||
0.0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Indicator for BurkeRatio {
|
||||
type Input = f64;
|
||||
type Output = f64;
|
||||
|
||||
fn update(&mut self, ret: f64) -> Option<f64> {
|
||||
if !ret.is_finite() {
|
||||
return None;
|
||||
}
|
||||
if self.window.len() == self.period {
|
||||
self.window.pop_front();
|
||||
}
|
||||
self.window.push_back(ret);
|
||||
if self.window.len() < self.period {
|
||||
return None;
|
||||
}
|
||||
Some(self.compute())
|
||||
}
|
||||
|
||||
fn reset(&mut self) {
|
||||
self.window.clear();
|
||||
}
|
||||
|
||||
fn warmup_period(&self) -> usize {
|
||||
self.period
|
||||
}
|
||||
|
||||
fn is_ready(&self) -> bool {
|
||||
self.window.len() == self.period
|
||||
}
|
||||
|
||||
fn name(&self) -> &'static str {
|
||||
"BurkeRatio"
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::traits::BatchExt;
|
||||
use approx::assert_relative_eq;
|
||||
|
||||
#[test]
|
||||
fn rejects_period_less_than_two() {
|
||||
assert!(matches!(
|
||||
BurkeRatio::new(1),
|
||||
Err(Error::InvalidPeriod { .. })
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn accessors_and_metadata() {
|
||||
let br = BurkeRatio::new(12).unwrap();
|
||||
assert_eq!(br.period(), 12);
|
||||
assert_eq!(br.warmup_period(), 12);
|
||||
assert_eq!(br.name(), "BurkeRatio");
|
||||
assert!(!br.is_ready());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reference_value() {
|
||||
// returns [0.1, -0.1, 0.1]: dd = [0, 0.1, 0.01].
|
||||
// Σ dd² = 0.01 + 0.0001 = 0.0101; denom = sqrt(0.0101).
|
||||
// Burke = (0.1/3) / sqrt(0.0101).
|
||||
let mut br = BurkeRatio::new(3).unwrap();
|
||||
let out = br.batch(&[0.1, -0.1, 0.1]);
|
||||
let expected = (0.1_f64 / 3.0) / (0.0101_f64).sqrt();
|
||||
assert_relative_eq!(out[2].unwrap(), expected, epsilon = 1e-9);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn no_drawdown_is_zero() {
|
||||
let mut br = BurkeRatio::new(3).unwrap();
|
||||
let last = br
|
||||
.batch(&[0.01, 0.02, 0.03])
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.last()
|
||||
.unwrap();
|
||||
assert_relative_eq!(last, 0.0, epsilon = 1e-12);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn losing_window_is_negative() {
|
||||
let mut br = BurkeRatio::new(3).unwrap();
|
||||
let last = br
|
||||
.batch(&[-0.05, -0.02, -0.03])
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.last()
|
||||
.unwrap();
|
||||
assert!(last < 0.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ignores_non_finite_input() {
|
||||
let mut br = BurkeRatio::new(3).unwrap();
|
||||
assert_eq!(br.update(0.1), None);
|
||||
assert_eq!(br.update(f64::NAN), None);
|
||||
assert_eq!(br.update(-0.1), None);
|
||||
assert!(br.update(0.1).is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reset_clears_state() {
|
||||
let mut br = BurkeRatio::new(3).unwrap();
|
||||
br.batch(&[0.1, -0.1, 0.1]);
|
||||
assert!(br.is_ready());
|
||||
br.reset();
|
||||
assert!(!br.is_ready());
|
||||
assert_eq!(br.update(0.1), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn batch_equals_streaming() {
|
||||
let rets: Vec<f64> = (0..60)
|
||||
.map(|i| (f64::from(i) * 0.25).sin() * 0.05)
|
||||
.collect();
|
||||
let batch = BurkeRatio::new(12).unwrap().batch(&rets);
|
||||
let mut streamer = BurkeRatio::new(12).unwrap();
|
||||
let streamed: Vec<_> = rets.iter().map(|r| streamer.update(*r)).collect();
|
||||
assert_eq!(batch, streamed);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,248 @@
|
||||
//! Common Sense Ratio (Schwager / Carver) — profit factor multiplied by the tail ratio.
|
||||
|
||||
use std::collections::VecDeque;
|
||||
|
||||
use crate::error::{Error, Result};
|
||||
use crate::traits::Indicator;
|
||||
|
||||
/// Common Sense Ratio over a trailing window of `period` returns.
|
||||
///
|
||||
/// ```text
|
||||
/// ProfitFactor = Σ gains / Σ |losses| over the window
|
||||
/// TailRatio = P95(returns) / |P5(returns)| over the window
|
||||
/// CSR = ProfitFactor · TailRatio
|
||||
/// ```
|
||||
///
|
||||
/// The Common Sense Ratio fuses two views of a return series into one number. The
|
||||
/// [profit factor](crate::ProfitFactor) captures the *body* of the distribution —
|
||||
/// how much you make per unit you lose on the average bar. The
|
||||
/// [`TailRatio`](crate::TailRatio) captures the *extremes* — whether the largest
|
||||
/// gains outweigh the largest losses. Multiplying them produces a ratio that is
|
||||
/// only comfortably above `1.0` when a strategy wins on both fronts: a respectable
|
||||
/// profit factor can still hide catastrophic left-tail risk, and a fat right tail
|
||||
/// means little if the body bleeds. Above `1.0` the strategy is sound on a
|
||||
/// common-sense basis; below `1.0` something — body or tail — is working against it.
|
||||
///
|
||||
/// Percentiles use linear interpolation over the sorted window. A window with no
|
||||
/// losses (zero profit-factor denominator) or no left tail (zero P5) reports `0.0`
|
||||
/// rather than dividing by zero.
|
||||
///
|
||||
/// The first value lands after `period` returns; each `update` re-sorts the window
|
||||
/// (O(period log period)), which is O(1) in the length of the overall series.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```
|
||||
/// use wickra_core::{Indicator, CommonSenseRatio};
|
||||
///
|
||||
/// let mut indicator = CommonSenseRatio::new(20).unwrap();
|
||||
/// let mut last = None;
|
||||
/// for i in 0..40 {
|
||||
/// last = indicator.update((f64::from(i) * 0.3).sin() * 0.02);
|
||||
/// }
|
||||
/// assert!(last.is_some());
|
||||
/// ```
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct CommonSenseRatio {
|
||||
period: usize,
|
||||
window: VecDeque<f64>,
|
||||
}
|
||||
|
||||
impl CommonSenseRatio {
|
||||
/// Construct a Common Sense Ratio over `period` returns.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// Returns [`Error::InvalidPeriod`] if `period < 2` (percentiles need at least
|
||||
/// two observations).
|
||||
pub fn new(period: usize) -> Result<Self> {
|
||||
if period < 2 {
|
||||
return Err(Error::InvalidPeriod {
|
||||
message: "common sense ratio needs period >= 2",
|
||||
});
|
||||
}
|
||||
Ok(Self {
|
||||
period,
|
||||
window: VecDeque::with_capacity(period),
|
||||
})
|
||||
}
|
||||
|
||||
/// Configured window of returns.
|
||||
pub const fn period(&self) -> usize {
|
||||
self.period
|
||||
}
|
||||
|
||||
fn compute(&self) -> f64 {
|
||||
let mut gains = 0.0;
|
||||
let mut losses = 0.0;
|
||||
for ret in &self.window {
|
||||
gains += ret.max(0.0);
|
||||
losses += (-ret).max(0.0);
|
||||
}
|
||||
if losses <= 0.0 {
|
||||
return 0.0;
|
||||
}
|
||||
let mut sorted: Vec<f64> = self.window.iter().copied().collect();
|
||||
sorted.sort_unstable_by(f64::total_cmp);
|
||||
let lower_tail = percentile(&sorted, 5.0).abs();
|
||||
if lower_tail <= 0.0 {
|
||||
return 0.0;
|
||||
}
|
||||
let profit_factor = gains / losses;
|
||||
let tail_ratio = percentile(&sorted, 95.0) / lower_tail;
|
||||
profit_factor * tail_ratio
|
||||
}
|
||||
}
|
||||
|
||||
/// Linear-interpolation percentile of an ascending, non-empty slice.
|
||||
fn percentile(sorted: &[f64], pct: f64) -> f64 {
|
||||
let last_index = sorted.len() - 1;
|
||||
#[allow(clippy::cast_precision_loss)]
|
||||
let rank = pct / 100.0 * last_index as f64;
|
||||
let floor = rank.floor();
|
||||
// `rank` lies in `[0, last_index]`, so its floor is a valid in-bounds index.
|
||||
#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
|
||||
let lower = floor as usize;
|
||||
if lower >= last_index {
|
||||
return sorted[last_index];
|
||||
}
|
||||
let frac = rank - floor;
|
||||
sorted[lower] + frac * (sorted[lower + 1] - sorted[lower])
|
||||
}
|
||||
|
||||
impl Indicator for CommonSenseRatio {
|
||||
type Input = f64;
|
||||
type Output = f64;
|
||||
|
||||
fn update(&mut self, ret: f64) -> Option<f64> {
|
||||
if !ret.is_finite() {
|
||||
return None;
|
||||
}
|
||||
if self.window.len() == self.period {
|
||||
self.window.pop_front();
|
||||
}
|
||||
self.window.push_back(ret);
|
||||
if self.window.len() < self.period {
|
||||
return None;
|
||||
}
|
||||
Some(self.compute())
|
||||
}
|
||||
|
||||
fn reset(&mut self) {
|
||||
self.window.clear();
|
||||
}
|
||||
|
||||
fn warmup_period(&self) -> usize {
|
||||
self.period
|
||||
}
|
||||
|
||||
fn is_ready(&self) -> bool {
|
||||
self.window.len() == self.period
|
||||
}
|
||||
|
||||
fn name(&self) -> &'static str {
|
||||
"CommonSenseRatio"
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::traits::BatchExt;
|
||||
use approx::assert_relative_eq;
|
||||
|
||||
#[test]
|
||||
fn rejects_period_less_than_two() {
|
||||
assert!(matches!(
|
||||
CommonSenseRatio::new(1),
|
||||
Err(Error::InvalidPeriod { .. })
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn accessors_and_metadata() {
|
||||
let csr = CommonSenseRatio::new(20).unwrap();
|
||||
assert_eq!(csr.period(), 20);
|
||||
assert_eq!(csr.warmup_period(), 20);
|
||||
assert_eq!(csr.name(), "CommonSenseRatio");
|
||||
assert!(!csr.is_ready());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reference_value() {
|
||||
// window [-0.04, -0.02, 0.0, 0.02, 0.04].
|
||||
// gains = 0.06, losses = 0.06 -> profit factor 1.0.
|
||||
// P95 = 0.036, |P5| = 0.036 -> tail ratio 1.0. CSR = 1.0.
|
||||
let mut csr = CommonSenseRatio::new(5).unwrap();
|
||||
let out = csr.batch(&[-0.04, -0.02, 0.0, 0.02, 0.04]);
|
||||
assert_relative_eq!(out[4].unwrap(), 1.0, epsilon = 1e-9);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn no_losses_is_zero() {
|
||||
let mut csr = CommonSenseRatio::new(3).unwrap();
|
||||
let last = csr
|
||||
.batch(&[0.01, 0.02, 0.03])
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.last()
|
||||
.unwrap();
|
||||
assert_relative_eq!(last, 0.0, epsilon = 1e-12);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn flat_window_is_zero() {
|
||||
// All zeros: no losses denominator -> zero (the gains/losses guard fires).
|
||||
let mut csr = CommonSenseRatio::new(4).unwrap();
|
||||
let last = csr.batch(&[0.0; 4]).into_iter().flatten().last().unwrap();
|
||||
assert_relative_eq!(last, 0.0, epsilon = 1e-12);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ignores_non_finite_input() {
|
||||
let mut csr = CommonSenseRatio::new(3).unwrap();
|
||||
assert_eq!(csr.update(0.01), None);
|
||||
assert_eq!(csr.update(f64::NAN), None);
|
||||
assert_eq!(csr.update(-0.02), None);
|
||||
assert!(csr.update(0.03).is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reset_clears_state() {
|
||||
let mut csr = CommonSenseRatio::new(3).unwrap();
|
||||
csr.batch(&[-0.01, 0.0, 0.02]);
|
||||
assert!(csr.is_ready());
|
||||
csr.reset();
|
||||
assert!(!csr.is_ready());
|
||||
assert_eq!(csr.update(0.01), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn batch_equals_streaming() {
|
||||
let rets: Vec<f64> = (0..60)
|
||||
.map(|i| (f64::from(i) * 0.25).sin() * 0.02)
|
||||
.collect();
|
||||
let batch = CommonSenseRatio::new(15).unwrap().batch(&rets);
|
||||
let mut streamer = CommonSenseRatio::new(15).unwrap();
|
||||
let streamed: Vec<_> = rets.iter().map(|r| streamer.update(*r)).collect();
|
||||
assert_eq!(batch, streamed);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn percentile_at_top_returns_last() {
|
||||
// The rank floor reaching the final index returns the largest element.
|
||||
assert_relative_eq!(percentile(&[1.0, 2.0, 3.0], 100.0), 3.0, epsilon = 1e-12);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn zero_lower_tail_is_zero() {
|
||||
// One loss but a 5th percentile of exactly zero: the tail term collapses
|
||||
// and the indicator reports 0.0 rather than dividing by zero. With period
|
||||
// 21 the 5% rank lands on sorted index 1, which is 0.0 here.
|
||||
let mut returns = vec![0.0; 21];
|
||||
returns[0] = -0.1;
|
||||
let mut csr = CommonSenseRatio::new(21).unwrap();
|
||||
let last = csr.batch(&returns).into_iter().flatten().last().unwrap();
|
||||
assert_relative_eq!(last, 0.0, epsilon = 1e-12);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,229 @@
|
||||
//! Gain-to-Pain Ratio (Schwager) — sum of returns over the sum of losses.
|
||||
|
||||
use std::collections::VecDeque;
|
||||
|
||||
use crate::error::{Error, Result};
|
||||
use crate::traits::Indicator;
|
||||
|
||||
/// Gain-to-Pain Ratio — Jack Schwager's measure of return per unit of downside:
|
||||
/// the sum of all returns divided by the sum of the absolute *negative* returns.
|
||||
///
|
||||
/// ```text
|
||||
/// GPR = Σ returns / Σ |negative returns| over the window
|
||||
/// ```
|
||||
///
|
||||
/// Where the [`GainLossRatio`](crate::GainLossRatio) compares *average* win to
|
||||
/// *average* loss and the [`ProfitFactor`](crate::ProfitFactor) compares gross
|
||||
/// profit to gross loss, the Gain-to-Pain Ratio puts the **net** result over the
|
||||
/// total pain endured to earn it. Schwager treats a GPR above `1.0` as good and
|
||||
/// above `2.0` as excellent for a monthly return series: the strategy made more
|
||||
/// than it lost on the way, and twice as much when GPR is `2`. A flat series, or
|
||||
/// one with no losses, has no measurable pain and reports `0` (undefined).
|
||||
///
|
||||
/// The output is unbounded and may be negative (a net-losing window). The first
|
||||
/// value lands after `period` returns; each `update` is O(1).
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```
|
||||
/// use wickra_core::{Indicator, GainToPainRatio};
|
||||
///
|
||||
/// let mut indicator = GainToPainRatio::new(12).unwrap();
|
||||
/// let mut last = None;
|
||||
/// for i in 0..24 {
|
||||
/// last = indicator.update((f64::from(i) * 0.5).sin() * 0.02);
|
||||
/// }
|
||||
/// assert!(last.is_some());
|
||||
/// ```
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct GainToPainRatio {
|
||||
period: usize,
|
||||
window: VecDeque<f64>,
|
||||
sum_all: f64,
|
||||
sum_pain: f64,
|
||||
}
|
||||
|
||||
impl GainToPainRatio {
|
||||
/// Construct a Gain-to-Pain Ratio over `period` returns.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// Returns [`Error::PeriodZero`] if `period == 0`.
|
||||
pub fn new(period: usize) -> Result<Self> {
|
||||
if period == 0 {
|
||||
return Err(Error::PeriodZero);
|
||||
}
|
||||
Ok(Self {
|
||||
period,
|
||||
window: VecDeque::with_capacity(period),
|
||||
sum_all: 0.0,
|
||||
sum_pain: 0.0,
|
||||
})
|
||||
}
|
||||
|
||||
/// Configured window of returns.
|
||||
pub const fn period(&self) -> usize {
|
||||
self.period
|
||||
}
|
||||
}
|
||||
|
||||
impl Indicator for GainToPainRatio {
|
||||
type Input = f64;
|
||||
type Output = f64;
|
||||
|
||||
fn update(&mut self, ret: f64) -> Option<f64> {
|
||||
if !ret.is_finite() {
|
||||
return if self.window.len() == self.period {
|
||||
Some(self.compute())
|
||||
} else {
|
||||
None
|
||||
};
|
||||
}
|
||||
if self.window.len() == self.period {
|
||||
let old = self.window.pop_front().expect("non-empty");
|
||||
self.sum_all -= old;
|
||||
if old < 0.0 {
|
||||
self.sum_pain -= -old;
|
||||
}
|
||||
}
|
||||
self.window.push_back(ret);
|
||||
self.sum_all += ret;
|
||||
if ret < 0.0 {
|
||||
self.sum_pain += -ret;
|
||||
}
|
||||
if self.window.len() < self.period {
|
||||
return None;
|
||||
}
|
||||
Some(self.compute())
|
||||
}
|
||||
|
||||
fn reset(&mut self) {
|
||||
self.window.clear();
|
||||
self.sum_all = 0.0;
|
||||
self.sum_pain = 0.0;
|
||||
}
|
||||
|
||||
fn warmup_period(&self) -> usize {
|
||||
self.period
|
||||
}
|
||||
|
||||
fn is_ready(&self) -> bool {
|
||||
self.window.len() == self.period
|
||||
}
|
||||
|
||||
fn name(&self) -> &'static str {
|
||||
"GainToPainRatio"
|
||||
}
|
||||
}
|
||||
|
||||
impl GainToPainRatio {
|
||||
fn compute(&self) -> f64 {
|
||||
if self.sum_pain > 0.0 {
|
||||
self.sum_all / self.sum_pain
|
||||
} else {
|
||||
0.0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::traits::BatchExt;
|
||||
use approx::assert_relative_eq;
|
||||
|
||||
#[test]
|
||||
fn rejects_zero_period() {
|
||||
assert!(matches!(GainToPainRatio::new(0), Err(Error::PeriodZero)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn accessors_and_metadata() {
|
||||
let g = GainToPainRatio::new(12).unwrap();
|
||||
assert_eq!(g.period(), 12);
|
||||
assert_eq!(g.warmup_period(), 12);
|
||||
assert_eq!(g.name(), "GainToPainRatio");
|
||||
assert!(!g.is_ready());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn first_emission_at_warmup_period() {
|
||||
let mut g = GainToPainRatio::new(4).unwrap();
|
||||
let out = g.batch(&[0.01, -0.01, 0.02, -0.01, 0.03]);
|
||||
for v in out.iter().take(3) {
|
||||
assert!(v.is_none());
|
||||
}
|
||||
assert!(out[3].is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reference_value() {
|
||||
// returns: +0.04, -0.02 -> sum_all = 0.02, pain = 0.02 -> GPR = 1.0.
|
||||
let mut g = GainToPainRatio::new(2).unwrap();
|
||||
let out = g.batch(&[0.04, -0.02]);
|
||||
assert_relative_eq!(out[1].unwrap(), 1.0, epsilon = 1e-9);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn net_losing_window_is_negative() {
|
||||
let mut g = GainToPainRatio::new(3).unwrap();
|
||||
let last = g
|
||||
.batch(&[-0.03, 0.01, -0.02])
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.last()
|
||||
.unwrap();
|
||||
assert!(last < 0.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn no_pain_is_zero() {
|
||||
let mut g = GainToPainRatio::new(3).unwrap();
|
||||
let last = g
|
||||
.batch(&[0.01, 0.02, 0.03])
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.last()
|
||||
.unwrap();
|
||||
assert_relative_eq!(last, 0.0, epsilon = 1e-12);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ignores_non_finite() {
|
||||
let mut g = GainToPainRatio::new(2).unwrap();
|
||||
let ready = g
|
||||
.batch(&[0.04, -0.02])
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.last()
|
||||
.unwrap();
|
||||
assert_eq!(g.update(f64::NAN), Some(ready));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn non_finite_before_ready_is_none() {
|
||||
// A non-finite value arriving before the window fills yields None.
|
||||
let mut g = GainToPainRatio::new(3).unwrap();
|
||||
assert_eq!(g.update(0.02), None);
|
||||
assert_eq!(g.update(f64::NAN), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reset_clears_state() {
|
||||
let mut g = GainToPainRatio::new(2).unwrap();
|
||||
g.batch(&[0.04, -0.02]);
|
||||
assert!(g.is_ready());
|
||||
g.reset();
|
||||
assert!(!g.is_ready());
|
||||
assert_eq!(g.update(0.01), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn batch_equals_streaming() {
|
||||
let rets: Vec<f64> = (0..60).map(|i| (f64::from(i) * 0.3).sin() * 0.02).collect();
|
||||
let batch = GainToPainRatio::new(12).unwrap().batch(&rets);
|
||||
let mut b = GainToPainRatio::new(12).unwrap();
|
||||
let streamed: Vec<_> = rets.iter().map(|r| b.update(*r)).collect();
|
||||
assert_eq!(batch, streamed);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,239 @@
|
||||
//! K-Ratio (Kestner) — slope of the cumulative-return curve over the standard error of that slope.
|
||||
|
||||
use std::collections::VecDeque;
|
||||
|
||||
use crate::error::{Error, Result};
|
||||
use crate::traits::Indicator;
|
||||
|
||||
/// K-Ratio over a trailing window of `period` returns.
|
||||
///
|
||||
/// Lars Kestner's K-Ratio measures the *consistency* of an equity curve, not just
|
||||
/// its return. It builds the cumulative-return curve over the window, fits an
|
||||
/// ordinary-least-squares trend line through it against time, and divides the
|
||||
/// fitted slope by the standard error of that slope:
|
||||
///
|
||||
/// ```text
|
||||
/// equity_t = Σ_{i<=t} return_i (cumulative curve, t = 1..period)
|
||||
/// slope, intercept = OLS(equity_t ~ t)
|
||||
/// SE(slope) = sqrt( (Σ residual² / (period − 2)) / Σ(t − t̄)² )
|
||||
/// K-Ratio = slope / SE(slope)
|
||||
/// ```
|
||||
///
|
||||
/// A high K-Ratio means the equity curve climbs *steadily* — a steep slope with
|
||||
/// little scatter around the trend. A strategy that earns the same total return in
|
||||
/// a few lucky jumps scores lower because its residual scatter inflates the
|
||||
/// standard error. This is the original 1996 form; later Kestner revisions scale by
|
||||
/// the number of periods (`slope / (SE · period)` in 2003, `slope / (SE · √period)`
|
||||
/// in 2013) — apply that scaling downstream if you need to compare across window
|
||||
/// lengths.
|
||||
///
|
||||
/// A perfectly straight window (e.g. constant returns) has zero residual scatter,
|
||||
/// so the slope's standard error is zero and the K-Ratio is undefined; the
|
||||
/// indicator reports `0.0` in that degenerate case. The statistic therefore needs
|
||||
/// some dispersion in the returns to be meaningful.
|
||||
///
|
||||
/// The first value lands after `period` returns; each `update` re-fits the line
|
||||
/// over the window (O(period)), which is O(1) in the length of the overall series.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```
|
||||
/// use wickra_core::{Indicator, KRatio};
|
||||
///
|
||||
/// let mut indicator = KRatio::new(30).unwrap();
|
||||
/// let mut last = None;
|
||||
/// for i in 0..60 {
|
||||
/// last = indicator.update(0.001 + (f64::from(i) * 0.3).sin() * 0.01);
|
||||
/// }
|
||||
/// assert!(last.is_some());
|
||||
/// ```
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct KRatio {
|
||||
period: usize,
|
||||
window: VecDeque<f64>,
|
||||
}
|
||||
|
||||
impl KRatio {
|
||||
/// Construct a K-Ratio over `period` returns.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// Returns [`Error::InvalidPeriod`] if `period < 3` (the slope's standard error
|
||||
/// divides by `period − 2`).
|
||||
pub fn new(period: usize) -> Result<Self> {
|
||||
if period < 3 {
|
||||
return Err(Error::InvalidPeriod {
|
||||
message: "k-ratio needs period >= 3",
|
||||
});
|
||||
}
|
||||
Ok(Self {
|
||||
period,
|
||||
window: VecDeque::with_capacity(period),
|
||||
})
|
||||
}
|
||||
|
||||
/// Configured window of returns.
|
||||
pub const fn period(&self) -> usize {
|
||||
self.period
|
||||
}
|
||||
|
||||
fn compute(&self) -> f64 {
|
||||
let count = self.window.len();
|
||||
#[allow(clippy::cast_precision_loss)]
|
||||
let length = count as f64;
|
||||
// Build the cumulative-equity curve and its mean.
|
||||
let mut equity = 0.0;
|
||||
let mut curve: Vec<f64> = Vec::with_capacity(count);
|
||||
let mut sum_equity = 0.0;
|
||||
for ret in &self.window {
|
||||
equity += *ret;
|
||||
curve.push(equity);
|
||||
sum_equity += equity;
|
||||
}
|
||||
// Times are 1..=count, so Σt = count(count+1)/2 in closed form.
|
||||
let mean_time = f64::midpoint(length, 1.0);
|
||||
let mean_equity = sum_equity / length;
|
||||
let mut sxx = 0.0;
|
||||
let mut sxy = 0.0;
|
||||
for (index, value) in curve.iter().enumerate() {
|
||||
#[allow(clippy::cast_precision_loss)]
|
||||
let time = (index + 1) as f64;
|
||||
let dt = time - mean_time;
|
||||
sxx += dt * dt;
|
||||
sxy += dt * (value - mean_equity);
|
||||
}
|
||||
// sxx > 0 for count >= 2 (distinct integer times), guaranteed by period >= 3.
|
||||
let slope = sxy / sxx;
|
||||
let intercept = mean_equity - slope * mean_time;
|
||||
let mut sse = 0.0;
|
||||
for (index, value) in curve.iter().enumerate() {
|
||||
#[allow(clippy::cast_precision_loss)]
|
||||
let time = (index + 1) as f64;
|
||||
let residual = value - (intercept + slope * time);
|
||||
sse += residual * residual;
|
||||
}
|
||||
if sse <= 0.0 {
|
||||
return 0.0;
|
||||
}
|
||||
let se_slope = (sse / (length - 2.0) / sxx).sqrt();
|
||||
slope / se_slope
|
||||
}
|
||||
}
|
||||
|
||||
impl Indicator for KRatio {
|
||||
type Input = f64;
|
||||
type Output = f64;
|
||||
|
||||
fn update(&mut self, ret: f64) -> Option<f64> {
|
||||
if !ret.is_finite() {
|
||||
return None;
|
||||
}
|
||||
if self.window.len() == self.period {
|
||||
self.window.pop_front();
|
||||
}
|
||||
self.window.push_back(ret);
|
||||
if self.window.len() < self.period {
|
||||
return None;
|
||||
}
|
||||
Some(self.compute())
|
||||
}
|
||||
|
||||
fn reset(&mut self) {
|
||||
self.window.clear();
|
||||
}
|
||||
|
||||
fn warmup_period(&self) -> usize {
|
||||
self.period
|
||||
}
|
||||
|
||||
fn is_ready(&self) -> bool {
|
||||
self.window.len() == self.period
|
||||
}
|
||||
|
||||
fn name(&self) -> &'static str {
|
||||
"KRatio"
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::traits::BatchExt;
|
||||
use approx::assert_relative_eq;
|
||||
|
||||
#[test]
|
||||
fn rejects_period_less_than_three() {
|
||||
assert!(matches!(KRatio::new(2), Err(Error::InvalidPeriod { .. })));
|
||||
assert!(matches!(KRatio::new(0), Err(Error::InvalidPeriod { .. })));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn accessors_and_metadata() {
|
||||
let kr = KRatio::new(30).unwrap();
|
||||
assert_eq!(kr.period(), 30);
|
||||
assert_eq!(kr.warmup_period(), 30);
|
||||
assert_eq!(kr.name(), "KRatio");
|
||||
assert!(!kr.is_ready());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reference_value() {
|
||||
// returns [0.01, 0.02, 0.03] -> equity curve [0.01, 0.03, 0.06].
|
||||
// slope = 0.025, SE(slope) = sqrt((1/60000)/1/2) = 1/sqrt(120000).
|
||||
// K-Ratio = 0.025 * sqrt(120000) = 5*sqrt(3) ≈ 8.660254.
|
||||
let mut kr = KRatio::new(3).unwrap();
|
||||
let out = kr.batch(&[0.01, 0.02, 0.03]);
|
||||
let expected = 0.025_f64 / (1.0_f64 / 120_000.0).sqrt();
|
||||
assert_relative_eq!(out[2].unwrap(), expected, epsilon = 1e-6);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn constant_returns_are_degenerate_zero() {
|
||||
// A perfectly linear equity curve has zero residual scatter -> undefined.
|
||||
let mut kr = KRatio::new(4).unwrap();
|
||||
let last = kr.batch(&[0.01; 4]).into_iter().flatten().last().unwrap();
|
||||
assert_relative_eq!(last, 0.0, epsilon = 1e-12);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rising_curve_is_positive() {
|
||||
let mut kr = KRatio::new(5).unwrap();
|
||||
let last = kr
|
||||
.batch(&[0.01, 0.012, 0.009, 0.011, 0.013])
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.last()
|
||||
.unwrap();
|
||||
assert!(last > 0.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ignores_non_finite_input() {
|
||||
let mut kr = KRatio::new(3).unwrap();
|
||||
assert_eq!(kr.update(0.01), None);
|
||||
assert_eq!(kr.update(f64::NAN), None);
|
||||
assert_eq!(kr.update(0.02), None);
|
||||
assert!(kr.update(0.03).is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reset_clears_state() {
|
||||
let mut kr = KRatio::new(3).unwrap();
|
||||
kr.batch(&[0.01, 0.02, 0.03]);
|
||||
assert!(kr.is_ready());
|
||||
kr.reset();
|
||||
assert!(!kr.is_ready());
|
||||
assert_eq!(kr.update(0.01), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn batch_equals_streaming() {
|
||||
let rets: Vec<f64> = (0..60)
|
||||
.map(|i| 0.001 + (f64::from(i) * 0.25).sin() * 0.01)
|
||||
.collect();
|
||||
let batch = KRatio::new(20).unwrap().batch(&rets);
|
||||
let mut streamer = KRatio::new(20).unwrap();
|
||||
let streamed: Vec<_> = rets.iter().map(|r| streamer.update(*r)).collect();
|
||||
assert_eq!(batch, streamed);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,232 @@
|
||||
//! M² / Modigliani–Modigliani measure — Sharpe expressed in benchmark return units.
|
||||
|
||||
use std::collections::VecDeque;
|
||||
|
||||
use crate::error::{Error, Result};
|
||||
use crate::traits::Indicator;
|
||||
|
||||
/// M² (Modigliani–Modigliani) measure over a trailing window of `period` returns.
|
||||
///
|
||||
/// ```text
|
||||
/// Sharpe = (mean(returns) − risk_free) / stddev(returns)
|
||||
/// M² = risk_free + Sharpe · benchmark_stddev
|
||||
/// ```
|
||||
///
|
||||
/// The [`SharpeRatio`](crate::SharpeRatio) is dimensionless, which makes it hard to
|
||||
/// communicate: "0.8" means little to a client. M² rescales the Sharpe ratio back
|
||||
/// into *return units* by levering (or de-levering) the portfolio to the
|
||||
/// benchmark's volatility. The result answers a concrete question: "if this
|
||||
/// strategy had run at the market's risk level, what return would it have
|
||||
/// produced?" Two portfolios can then be ranked on the same risk-adjusted scale,
|
||||
/// and M² preserves the Sharpe ordering while being quoted as a percentage.
|
||||
///
|
||||
/// `stddev` is the sample standard deviation (Bessel's `n − 1`).
|
||||
/// `risk_free` is the per-period risk-free rate and `benchmark_stddev` the
|
||||
/// per-period volatility of the benchmark, both supplied by the caller at the
|
||||
/// return frequency. A flat window has zero volatility and the Sharpe ratio is
|
||||
/// undefined; the indicator returns `0.0` in that case rather than producing `NaN`.
|
||||
///
|
||||
/// Each `update` is O(1) — running sums maintain `Σr` and `Σr²` as the window slides.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```
|
||||
/// use wickra_core::{Indicator, M2Measure};
|
||||
///
|
||||
/// let mut indicator = M2Measure::new(20, 0.0, 0.02).unwrap();
|
||||
/// let mut last = None;
|
||||
/// for i in 0..40 {
|
||||
/// last = indicator.update(0.001 + (f64::from(i) * 0.1).sin() * 0.01);
|
||||
/// }
|
||||
/// assert!(last.is_some());
|
||||
/// ```
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct M2Measure {
|
||||
period: usize,
|
||||
risk_free: f64,
|
||||
benchmark_stddev: f64,
|
||||
window: VecDeque<f64>,
|
||||
sum: f64,
|
||||
sum_sq: f64,
|
||||
}
|
||||
|
||||
impl M2Measure {
|
||||
/// Construct an M² measure over `period` returns with the given per-period
|
||||
/// risk-free rate and benchmark standard deviation.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// Returns [`Error::InvalidPeriod`] if `period < 2`, or
|
||||
/// [`Error::InvalidParameter`] if `risk_free` is not finite or
|
||||
/// `benchmark_stddev` is negative or not finite.
|
||||
pub fn new(period: usize, risk_free: f64, benchmark_stddev: f64) -> Result<Self> {
|
||||
if period < 2 {
|
||||
return Err(Error::InvalidPeriod {
|
||||
message: "m2 measure needs period >= 2",
|
||||
});
|
||||
}
|
||||
if !risk_free.is_finite() || !benchmark_stddev.is_finite() || benchmark_stddev < 0.0 {
|
||||
return Err(Error::InvalidParameter {
|
||||
message: "risk_free must be finite and benchmark_stddev finite and non-negative",
|
||||
});
|
||||
}
|
||||
Ok(Self {
|
||||
period,
|
||||
risk_free,
|
||||
benchmark_stddev,
|
||||
window: VecDeque::with_capacity(period),
|
||||
sum: 0.0,
|
||||
sum_sq: 0.0,
|
||||
})
|
||||
}
|
||||
|
||||
/// Configured window of returns.
|
||||
pub const fn period(&self) -> usize {
|
||||
self.period
|
||||
}
|
||||
|
||||
/// Configured per-period risk-free rate.
|
||||
pub const fn risk_free(&self) -> f64 {
|
||||
self.risk_free
|
||||
}
|
||||
|
||||
/// Configured per-period benchmark standard deviation.
|
||||
pub const fn benchmark_stddev(&self) -> f64 {
|
||||
self.benchmark_stddev
|
||||
}
|
||||
}
|
||||
|
||||
impl Indicator for M2Measure {
|
||||
type Input = f64;
|
||||
type Output = f64;
|
||||
|
||||
fn update(&mut self, ret: f64) -> Option<f64> {
|
||||
if !ret.is_finite() {
|
||||
return None;
|
||||
}
|
||||
if self.window.len() == self.period {
|
||||
let old = self.window.pop_front().expect("non-empty");
|
||||
self.sum -= old;
|
||||
self.sum_sq -= old * old;
|
||||
}
|
||||
self.window.push_back(ret);
|
||||
self.sum += ret;
|
||||
self.sum_sq += ret * ret;
|
||||
if self.window.len() < self.period {
|
||||
return None;
|
||||
}
|
||||
let n = self.period as f64;
|
||||
let mean = self.sum / n;
|
||||
let var = (self.sum_sq - n * mean * mean).max(0.0) / (n - 1.0);
|
||||
let sd = var.sqrt();
|
||||
if sd == 0.0 {
|
||||
return Some(0.0);
|
||||
}
|
||||
let sharpe = (mean - self.risk_free) / sd;
|
||||
Some(self.risk_free + sharpe * self.benchmark_stddev)
|
||||
}
|
||||
|
||||
fn reset(&mut self) {
|
||||
self.window.clear();
|
||||
self.sum = 0.0;
|
||||
self.sum_sq = 0.0;
|
||||
}
|
||||
|
||||
fn warmup_period(&self) -> usize {
|
||||
self.period
|
||||
}
|
||||
|
||||
fn is_ready(&self) -> bool {
|
||||
self.window.len() == self.period
|
||||
}
|
||||
|
||||
fn name(&self) -> &'static str {
|
||||
"M2Measure"
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::traits::BatchExt;
|
||||
use approx::assert_relative_eq;
|
||||
|
||||
#[test]
|
||||
fn rejects_period_less_than_two() {
|
||||
assert!(matches!(
|
||||
M2Measure::new(1, 0.0, 0.02),
|
||||
Err(Error::InvalidPeriod { .. })
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_invalid_benchmark_stddev() {
|
||||
assert!(matches!(
|
||||
M2Measure::new(10, 0.0, -0.01),
|
||||
Err(Error::InvalidParameter { .. })
|
||||
));
|
||||
assert!(matches!(
|
||||
M2Measure::new(10, f64::NAN, 0.02),
|
||||
Err(Error::InvalidParameter { .. })
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn accessors_and_metadata() {
|
||||
let m2 = M2Measure::new(20, 0.001, 0.02).unwrap();
|
||||
assert_eq!(m2.period(), 20);
|
||||
assert_relative_eq!(m2.risk_free(), 0.001, epsilon = 1e-12);
|
||||
assert_relative_eq!(m2.benchmark_stddev(), 0.02, epsilon = 1e-12);
|
||||
assert_eq!(m2.warmup_period(), 20);
|
||||
assert_eq!(m2.name(), "M2Measure");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reference_value() {
|
||||
// returns [0.01, 0.02, 0.03, 0.04], rf = 0, benchmark_stddev = 0.02.
|
||||
// mean = 0.025, sd = sqrt(0.000166666...), Sharpe = 0.025 / sd.
|
||||
// M2 = 0 + Sharpe * 0.02.
|
||||
let mut m2 = M2Measure::new(4, 0.0, 0.02).unwrap();
|
||||
let out = m2.batch(&[0.01, 0.02, 0.03, 0.04]);
|
||||
let sharpe = 0.025_f64 / (0.000_166_666_666_666_666_67_f64).sqrt();
|
||||
assert_relative_eq!(out[3].unwrap(), sharpe * 0.02, epsilon = 1e-9);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn constant_returns_yield_zero() {
|
||||
let mut m2 = M2Measure::new(5, 0.0, 0.02).unwrap();
|
||||
for v in m2.batch(&[0.01; 10]).into_iter().flatten() {
|
||||
assert_relative_eq!(v, 0.0, epsilon = 1e-12);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ignores_non_finite_input() {
|
||||
let mut m2 = M2Measure::new(3, 0.0, 0.02).unwrap();
|
||||
assert_eq!(m2.update(0.01), None);
|
||||
assert_eq!(m2.update(f64::NAN), None);
|
||||
assert_eq!(m2.update(0.02), None);
|
||||
assert!(m2.update(0.03).is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reset_clears_state() {
|
||||
let mut m2 = M2Measure::new(3, 0.0, 0.02).unwrap();
|
||||
m2.batch(&[0.01, 0.02, 0.03]);
|
||||
assert!(m2.is_ready());
|
||||
m2.reset();
|
||||
assert!(!m2.is_ready());
|
||||
assert_eq!(m2.update(0.01), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn batch_equals_streaming() {
|
||||
let rets: Vec<f64> = (0..50)
|
||||
.map(|i| 0.001 + (f64::from(i) * 0.2).sin() * 0.01)
|
||||
.collect();
|
||||
let batch = M2Measure::new(10, 0.0, 0.02).unwrap().batch(&rets);
|
||||
let mut streamer = M2Measure::new(10, 0.0, 0.02).unwrap();
|
||||
let streamed: Vec<_> = rets.iter().map(|r| streamer.update(*r)).collect();
|
||||
assert_eq!(batch, streamed);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,220 @@
|
||||
//! Martin Ratio (Ulcer Performance Index) — mean return over the Ulcer Index.
|
||||
|
||||
use std::collections::VecDeque;
|
||||
|
||||
use crate::error::{Error, Result};
|
||||
use crate::traits::Indicator;
|
||||
|
||||
/// Martin Ratio — also called the Ulcer Performance Index (UPI) — over a trailing
|
||||
/// window of `period` returns.
|
||||
///
|
||||
/// ```text
|
||||
/// equity_t = Π_{i<=t} (1 + return_i) (compounded curve)
|
||||
/// peak_t = max_{s<=t} equity_s
|
||||
/// dd_t% = 100 · (peak_t − equity_t) / peak_t (percentage drawdown)
|
||||
/// UlcerIdx = sqrt( mean( dd_t%² ) )
|
||||
/// Martin = mean(returns) / UlcerIdx
|
||||
/// ```
|
||||
///
|
||||
/// The Martin Ratio divides the average per-period return by the **Ulcer Index** —
|
||||
/// the root-mean-square of the *percentage* drawdowns. The Ulcer Index, by
|
||||
/// construction, measures the depth *and* duration of the time spent under water:
|
||||
/// a long shallow slump and a short deep one can score the same. Compared to
|
||||
/// Wickra's other drawdown ratios, Martin uses the RMS (not the average as in the
|
||||
/// [`SterlingRatio`](crate::SterlingRatio), nor the un-normalised sum-norm as in the
|
||||
/// [`BurkeRatio`](crate::BurkeRatio)) and expresses drawdowns in **percent**, so its
|
||||
/// denominator is on a `0..100` scale and its output is numerically smaller than
|
||||
/// the fractional-drawdown ratios. A window that never draws down has an Ulcer Index
|
||||
/// of zero and the indicator reports `0.0`.
|
||||
///
|
||||
/// The first value lands after `period` returns; each `update` rebuilds the equity
|
||||
/// curve over the window (O(period)), which is O(1) in the length of the overall
|
||||
/// series.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```
|
||||
/// use wickra_core::{Indicator, MartinRatio};
|
||||
///
|
||||
/// let mut indicator = MartinRatio::new(14).unwrap();
|
||||
/// let mut last = None;
|
||||
/// for i in 0..28 {
|
||||
/// last = indicator.update((f64::from(i) * 0.5).sin() * 0.05);
|
||||
/// }
|
||||
/// assert!(last.is_some());
|
||||
/// ```
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct MartinRatio {
|
||||
period: usize,
|
||||
window: VecDeque<f64>,
|
||||
}
|
||||
|
||||
impl MartinRatio {
|
||||
/// Construct a Martin Ratio over `period` returns.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// Returns [`Error::InvalidPeriod`] if `period < 2`.
|
||||
pub fn new(period: usize) -> Result<Self> {
|
||||
if period < 2 {
|
||||
return Err(Error::InvalidPeriod {
|
||||
message: "martin ratio needs period >= 2",
|
||||
});
|
||||
}
|
||||
Ok(Self {
|
||||
period,
|
||||
window: VecDeque::with_capacity(period),
|
||||
})
|
||||
}
|
||||
|
||||
/// Configured window of returns.
|
||||
pub const fn period(&self) -> usize {
|
||||
self.period
|
||||
}
|
||||
|
||||
fn compute(&self) -> f64 {
|
||||
#[allow(clippy::cast_precision_loss)]
|
||||
let length = self.window.len() as f64;
|
||||
let mut sum_return = 0.0;
|
||||
let mut sum_drawdown_pct_sq = 0.0;
|
||||
let mut equity = 1.0;
|
||||
let mut peak: f64 = 1.0;
|
||||
for ret in &self.window {
|
||||
sum_return += *ret;
|
||||
equity *= 1.0 + *ret;
|
||||
peak = peak.max(equity);
|
||||
let drawdown_pct = 100.0 * (peak - equity) / peak;
|
||||
sum_drawdown_pct_sq += drawdown_pct * drawdown_pct;
|
||||
}
|
||||
let ulcer_index = (sum_drawdown_pct_sq / length).sqrt();
|
||||
if ulcer_index > 0.0 {
|
||||
(sum_return / length) / ulcer_index
|
||||
} else {
|
||||
0.0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Indicator for MartinRatio {
|
||||
type Input = f64;
|
||||
type Output = f64;
|
||||
|
||||
fn update(&mut self, ret: f64) -> Option<f64> {
|
||||
if !ret.is_finite() {
|
||||
return None;
|
||||
}
|
||||
if self.window.len() == self.period {
|
||||
self.window.pop_front();
|
||||
}
|
||||
self.window.push_back(ret);
|
||||
if self.window.len() < self.period {
|
||||
return None;
|
||||
}
|
||||
Some(self.compute())
|
||||
}
|
||||
|
||||
fn reset(&mut self) {
|
||||
self.window.clear();
|
||||
}
|
||||
|
||||
fn warmup_period(&self) -> usize {
|
||||
self.period
|
||||
}
|
||||
|
||||
fn is_ready(&self) -> bool {
|
||||
self.window.len() == self.period
|
||||
}
|
||||
|
||||
fn name(&self) -> &'static str {
|
||||
"MartinRatio"
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::traits::BatchExt;
|
||||
use approx::assert_relative_eq;
|
||||
|
||||
#[test]
|
||||
fn rejects_period_less_than_two() {
|
||||
assert!(matches!(
|
||||
MartinRatio::new(1),
|
||||
Err(Error::InvalidPeriod { .. })
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn accessors_and_metadata() {
|
||||
let mr = MartinRatio::new(14).unwrap();
|
||||
assert_eq!(mr.period(), 14);
|
||||
assert_eq!(mr.warmup_period(), 14);
|
||||
assert_eq!(mr.name(), "MartinRatio");
|
||||
assert!(!mr.is_ready());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reference_value() {
|
||||
// returns [0.1, -0.1, 0.1]: drawdowns% = [0, 10, 1].
|
||||
// Ulcer Index = sqrt((0 + 100 + 1)/3) = sqrt(101/3).
|
||||
// Martin = (0.1/3) / sqrt(101/3).
|
||||
let mut mr = MartinRatio::new(3).unwrap();
|
||||
let out = mr.batch(&[0.1, -0.1, 0.1]);
|
||||
let expected = (0.1_f64 / 3.0) / (101.0_f64 / 3.0).sqrt();
|
||||
assert_relative_eq!(out[2].unwrap(), expected, epsilon = 1e-9);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn no_drawdown_is_zero() {
|
||||
let mut mr = MartinRatio::new(3).unwrap();
|
||||
let last = mr
|
||||
.batch(&[0.01, 0.02, 0.03])
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.last()
|
||||
.unwrap();
|
||||
assert_relative_eq!(last, 0.0, epsilon = 1e-12);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn losing_window_is_negative() {
|
||||
let mut mr = MartinRatio::new(3).unwrap();
|
||||
let last = mr
|
||||
.batch(&[-0.05, -0.02, -0.03])
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.last()
|
||||
.unwrap();
|
||||
assert!(last < 0.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ignores_non_finite_input() {
|
||||
let mut mr = MartinRatio::new(3).unwrap();
|
||||
assert_eq!(mr.update(0.1), None);
|
||||
assert_eq!(mr.update(f64::NAN), None);
|
||||
assert_eq!(mr.update(-0.1), None);
|
||||
assert!(mr.update(0.1).is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reset_clears_state() {
|
||||
let mut mr = MartinRatio::new(3).unwrap();
|
||||
mr.batch(&[0.1, -0.1, 0.1]);
|
||||
assert!(mr.is_ready());
|
||||
mr.reset();
|
||||
assert!(!mr.is_ready());
|
||||
assert_eq!(mr.update(0.1), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn batch_equals_streaming() {
|
||||
let rets: Vec<f64> = (0..60)
|
||||
.map(|i| (f64::from(i) * 0.25).sin() * 0.05)
|
||||
.collect();
|
||||
let batch = MartinRatio::new(14).unwrap().batch(&rets);
|
||||
let mut streamer = MartinRatio::new(14).unwrap();
|
||||
let streamed: Vec<_> = rets.iter().map(|r| streamer.update(*r)).collect();
|
||||
assert_eq!(batch, streamed);
|
||||
}
|
||||
}
|
||||
@@ -63,6 +63,7 @@ mod bomar_bands;
|
||||
mod breadth_thrust;
|
||||
mod breakaway;
|
||||
mod bullish_percent_index;
|
||||
mod burke_ratio;
|
||||
mod butterfly;
|
||||
mod calendar_spread;
|
||||
mod calmar_ratio;
|
||||
@@ -84,6 +85,7 @@ mod cmf;
|
||||
mod cmo;
|
||||
mod coefficient_of_variation;
|
||||
mod cointegration;
|
||||
mod common_sense_ratio;
|
||||
mod composite_profile;
|
||||
mod concealing_baby_swallow;
|
||||
mod conditional_value_at_risk;
|
||||
@@ -163,6 +165,7 @@ mod funding_rate;
|
||||
mod funding_rate_mean;
|
||||
mod funding_rate_zscore;
|
||||
mod gain_loss_ratio;
|
||||
mod gain_to_pain_ratio;
|
||||
mod gap_side_by_side_white;
|
||||
mod garch11;
|
||||
mod garman_klass;
|
||||
@@ -214,6 +217,7 @@ mod inverted_hammer;
|
||||
mod jarque_bera;
|
||||
mod jma;
|
||||
mod jump_indicator;
|
||||
mod k_ratio;
|
||||
mod kagi_bars;
|
||||
mod kalman_hedge_ratio;
|
||||
mod kama;
|
||||
@@ -241,6 +245,7 @@ mod log_return;
|
||||
mod long_legged_doji;
|
||||
mod long_line;
|
||||
mod long_short_ratio;
|
||||
mod m2_measure;
|
||||
mod ma_envelope;
|
||||
mod macd;
|
||||
mod macd_ext;
|
||||
@@ -248,6 +253,7 @@ mod macd_fix;
|
||||
mod macd_histogram;
|
||||
mod mama;
|
||||
mod market_facilitation_index;
|
||||
mod martin_ratio;
|
||||
mod marubozu;
|
||||
mod mass_index;
|
||||
mod mat_hold;
|
||||
@@ -389,6 +395,7 @@ mod starc_bands;
|
||||
mod stc;
|
||||
mod std_dev;
|
||||
mod step_trailing_stop;
|
||||
mod sterling_ratio;
|
||||
mod stick_sandwich;
|
||||
mod stoch_rsi;
|
||||
mod stochastic;
|
||||
@@ -396,6 +403,7 @@ mod stochastic_cci;
|
||||
mod super_smoother;
|
||||
mod super_trend;
|
||||
mod t3;
|
||||
mod tail_ratio;
|
||||
mod taker_buy_sell_ratio;
|
||||
mod takuri;
|
||||
mod tasuki_gap;
|
||||
@@ -466,6 +474,7 @@ mod universal_oscillator;
|
||||
mod up_down_volume_ratio;
|
||||
mod upside_gap_three_methods;
|
||||
mod upside_gap_two_crows;
|
||||
mod upside_potential_ratio;
|
||||
mod value_area;
|
||||
mod value_at_risk;
|
||||
mod variance;
|
||||
@@ -561,6 +570,7 @@ pub use bomar_bands::{BomarBands, BomarBandsOutput};
|
||||
pub use breadth_thrust::BreadthThrust;
|
||||
pub use breakaway::Breakaway;
|
||||
pub use bullish_percent_index::BullishPercentIndex;
|
||||
pub use burke_ratio::BurkeRatio;
|
||||
pub use butterfly::Butterfly;
|
||||
pub use calendar_spread::CalendarSpread;
|
||||
pub use calmar_ratio::CalmarRatio;
|
||||
@@ -582,6 +592,7 @@ pub use cmf::ChaikinMoneyFlow;
|
||||
pub use cmo::Cmo;
|
||||
pub use coefficient_of_variation::CoefficientOfVariation;
|
||||
pub use cointegration::{Cointegration, CointegrationOutput};
|
||||
pub use common_sense_ratio::CommonSenseRatio;
|
||||
pub use composite_profile::{CompositeProfile, CompositeProfileOutput};
|
||||
pub use concealing_baby_swallow::ConcealingBabySwallow;
|
||||
pub use conditional_value_at_risk::ConditionalValueAtRisk;
|
||||
@@ -661,6 +672,7 @@ pub use funding_rate::FundingRate;
|
||||
pub use funding_rate_mean::FundingRateMean;
|
||||
pub use funding_rate_zscore::FundingRateZScore;
|
||||
pub use gain_loss_ratio::GainLossRatio;
|
||||
pub use gain_to_pain_ratio::GainToPainRatio;
|
||||
pub use gap_side_by_side_white::GapSideBySideWhite;
|
||||
pub use garch11::Garch11;
|
||||
pub use garman_klass::GarmanKlassVolatility;
|
||||
@@ -712,6 +724,7 @@ pub use inverted_hammer::InvertedHammer;
|
||||
pub use jarque_bera::JarqueBera;
|
||||
pub use jma::Jma;
|
||||
pub use jump_indicator::JumpIndicator;
|
||||
pub use k_ratio::KRatio;
|
||||
pub use kagi_bars::{KagiBar, KagiBars};
|
||||
pub use kalman_hedge_ratio::{KalmanHedgeRatio, KalmanHedgeRatioOutput};
|
||||
pub use kama::Kama;
|
||||
@@ -739,6 +752,7 @@ pub use log_return::LogReturn;
|
||||
pub use long_legged_doji::LongLeggedDoji;
|
||||
pub use long_line::LongLine;
|
||||
pub use long_short_ratio::LongShortRatio;
|
||||
pub use m2_measure::M2Measure;
|
||||
pub use ma_envelope::{MaEnvelope, MaEnvelopeOutput};
|
||||
pub use macd::{MacdIndicator, MacdOutput};
|
||||
pub use macd_ext::{MaType, MacdExt};
|
||||
@@ -746,6 +760,7 @@ pub use macd_fix::MacdFix;
|
||||
pub use macd_histogram::MacdHistogram;
|
||||
pub use mama::{Mama, MamaOutput};
|
||||
pub use market_facilitation_index::MarketFacilitationIndex;
|
||||
pub use martin_ratio::MartinRatio;
|
||||
pub use marubozu::Marubozu;
|
||||
pub use mass_index::MassIndex;
|
||||
pub use mat_hold::MatHold;
|
||||
@@ -887,6 +902,7 @@ pub use starc_bands::{StarcBands, StarcBandsOutput};
|
||||
pub use stc::Stc;
|
||||
pub use std_dev::StdDev;
|
||||
pub use step_trailing_stop::StepTrailingStop;
|
||||
pub use sterling_ratio::SterlingRatio;
|
||||
pub use stick_sandwich::StickSandwich;
|
||||
pub use stoch_rsi::StochRsi;
|
||||
pub use stochastic::{Stochastic, StochasticOutput};
|
||||
@@ -894,6 +910,7 @@ pub use stochastic_cci::StochasticCci;
|
||||
pub use super_smoother::SuperSmoother;
|
||||
pub use super_trend::{SuperTrend, SuperTrendOutput};
|
||||
pub use t3::T3;
|
||||
pub use tail_ratio::TailRatio;
|
||||
pub use taker_buy_sell_ratio::TakerBuySellRatio;
|
||||
pub use takuri::Takuri;
|
||||
pub use tasuki_gap::TasukiGap;
|
||||
@@ -964,6 +981,7 @@ pub use universal_oscillator::UniversalOscillator;
|
||||
pub use up_down_volume_ratio::UpDownVolumeRatio;
|
||||
pub use upside_gap_three_methods::UpsideGapThreeMethods;
|
||||
pub use upside_gap_two_crows::UpsideGapTwoCrows;
|
||||
pub use upside_potential_ratio::UpsidePotentialRatio;
|
||||
pub use value_area::{ValueArea, ValueAreaOutput};
|
||||
pub use value_at_risk::ValueAtRisk;
|
||||
pub use variance::Variance;
|
||||
@@ -1542,6 +1560,15 @@ pub const FAMILIES: &[(&str, &[&str])] = &[
|
||||
"Alpha",
|
||||
"WinRate",
|
||||
"Expectancy",
|
||||
"SterlingRatio",
|
||||
"BurkeRatio",
|
||||
"MartinRatio",
|
||||
"TailRatio",
|
||||
"KRatio",
|
||||
"CommonSenseRatio",
|
||||
"GainToPainRatio",
|
||||
"UpsidePotentialRatio",
|
||||
"M2Measure",
|
||||
],
|
||||
),
|
||||
(
|
||||
@@ -1654,6 +1681,6 @@ mod family_tests {
|
||||
// the actual indicator count is the early-warning signal that an
|
||||
// indicator was added without being assigned a family.
|
||||
let total: usize = FAMILIES.iter().map(|(_, ns)| ns.len()).sum();
|
||||
assert_eq!(total, 498, "FAMILIES total drifted from indicator count");
|
||||
assert_eq!(total, 507, "FAMILIES total drifted from indicator count");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,216 @@
|
||||
//! Sterling Ratio — mean return over the average drawdown of the equity curve.
|
||||
|
||||
use std::collections::VecDeque;
|
||||
|
||||
use crate::error::{Error, Result};
|
||||
use crate::traits::Indicator;
|
||||
|
||||
/// Sterling Ratio over a trailing window of `period` returns.
|
||||
///
|
||||
/// ```text
|
||||
/// equity_t = Π_{i<=t} (1 + return_i) (compounded curve)
|
||||
/// peak_t = max_{s<=t} equity_s
|
||||
/// dd_t = (peak_t − equity_t) / peak_t (fractional drawdown, >= 0)
|
||||
/// Sterling = mean(returns) / mean(dd_t)
|
||||
/// ```
|
||||
///
|
||||
/// The Sterling Ratio rewards return per unit of *typical* pain: it divides the
|
||||
/// average per-period return by the **average drawdown** experienced along the
|
||||
/// compounded equity curve. Of the three drawdown-based ratios Wickra ships it is
|
||||
/// the gentlest on outliers — averaging the drawdowns means one deep crater does
|
||||
/// not dominate the way it does in the [`BurkeRatio`](crate::BurkeRatio) (which
|
||||
/// sums squared drawdowns) or the [`MartinRatio`](crate::MartinRatio) (which uses
|
||||
/// the root-mean-square percentage drawdown). A window that never draws down has
|
||||
/// zero average drawdown and the indicator reports `0.0`.
|
||||
///
|
||||
/// The first value lands after `period` returns; each `update` rebuilds the equity
|
||||
/// curve over the window (O(period)), which is O(1) in the length of the overall
|
||||
/// series.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```
|
||||
/// use wickra_core::{Indicator, SterlingRatio};
|
||||
///
|
||||
/// let mut indicator = SterlingRatio::new(12).unwrap();
|
||||
/// let mut last = None;
|
||||
/// for i in 0..24 {
|
||||
/// last = indicator.update((f64::from(i) * 0.5).sin() * 0.05);
|
||||
/// }
|
||||
/// assert!(last.is_some());
|
||||
/// ```
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct SterlingRatio {
|
||||
period: usize,
|
||||
window: VecDeque<f64>,
|
||||
}
|
||||
|
||||
impl SterlingRatio {
|
||||
/// Construct a Sterling Ratio over `period` returns.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// Returns [`Error::InvalidPeriod`] if `period < 2`.
|
||||
pub fn new(period: usize) -> Result<Self> {
|
||||
if period < 2 {
|
||||
return Err(Error::InvalidPeriod {
|
||||
message: "sterling ratio needs period >= 2",
|
||||
});
|
||||
}
|
||||
Ok(Self {
|
||||
period,
|
||||
window: VecDeque::with_capacity(period),
|
||||
})
|
||||
}
|
||||
|
||||
/// Configured window of returns.
|
||||
pub const fn period(&self) -> usize {
|
||||
self.period
|
||||
}
|
||||
|
||||
fn compute(&self) -> f64 {
|
||||
#[allow(clippy::cast_precision_loss)]
|
||||
let length = self.window.len() as f64;
|
||||
let mut sum_return = 0.0;
|
||||
let mut sum_drawdown = 0.0;
|
||||
let mut equity = 1.0;
|
||||
let mut peak: f64 = 1.0;
|
||||
for ret in &self.window {
|
||||
sum_return += *ret;
|
||||
equity *= 1.0 + *ret;
|
||||
peak = peak.max(equity);
|
||||
sum_drawdown += (peak - equity) / peak;
|
||||
}
|
||||
let avg_drawdown = sum_drawdown / length;
|
||||
if avg_drawdown > 0.0 {
|
||||
(sum_return / length) / avg_drawdown
|
||||
} else {
|
||||
0.0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Indicator for SterlingRatio {
|
||||
type Input = f64;
|
||||
type Output = f64;
|
||||
|
||||
fn update(&mut self, ret: f64) -> Option<f64> {
|
||||
if !ret.is_finite() {
|
||||
return None;
|
||||
}
|
||||
if self.window.len() == self.period {
|
||||
self.window.pop_front();
|
||||
}
|
||||
self.window.push_back(ret);
|
||||
if self.window.len() < self.period {
|
||||
return None;
|
||||
}
|
||||
Some(self.compute())
|
||||
}
|
||||
|
||||
fn reset(&mut self) {
|
||||
self.window.clear();
|
||||
}
|
||||
|
||||
fn warmup_period(&self) -> usize {
|
||||
self.period
|
||||
}
|
||||
|
||||
fn is_ready(&self) -> bool {
|
||||
self.window.len() == self.period
|
||||
}
|
||||
|
||||
fn name(&self) -> &'static str {
|
||||
"SterlingRatio"
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::traits::BatchExt;
|
||||
use approx::assert_relative_eq;
|
||||
|
||||
#[test]
|
||||
fn rejects_period_less_than_two() {
|
||||
assert!(matches!(
|
||||
SterlingRatio::new(1),
|
||||
Err(Error::InvalidPeriod { .. })
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn accessors_and_metadata() {
|
||||
let sr = SterlingRatio::new(12).unwrap();
|
||||
assert_eq!(sr.period(), 12);
|
||||
assert_eq!(sr.warmup_period(), 12);
|
||||
assert_eq!(sr.name(), "SterlingRatio");
|
||||
assert!(!sr.is_ready());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reference_value() {
|
||||
// returns [0.1, -0.1, 0.1]:
|
||||
// equity 1.1, 0.99, 1.089; peak stays 1.1.
|
||||
// dd = [0, 0.1, 0.01]; avg_dd = 0.11/3; mean_return = 0.1/3.
|
||||
// Sterling = (0.1/3) / (0.11/3) = 0.1/0.11.
|
||||
let mut sr = SterlingRatio::new(3).unwrap();
|
||||
let out = sr.batch(&[0.1, -0.1, 0.1]);
|
||||
assert_relative_eq!(out[2].unwrap(), 0.1_f64 / 0.11, epsilon = 1e-9);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn no_drawdown_is_zero() {
|
||||
// Monotonically rising equity never draws down.
|
||||
let mut sr = SterlingRatio::new(3).unwrap();
|
||||
let last = sr
|
||||
.batch(&[0.01, 0.02, 0.03])
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.last()
|
||||
.unwrap();
|
||||
assert_relative_eq!(last, 0.0, epsilon = 1e-12);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn losing_window_is_negative() {
|
||||
let mut sr = SterlingRatio::new(3).unwrap();
|
||||
let last = sr
|
||||
.batch(&[-0.05, -0.02, -0.03])
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.last()
|
||||
.unwrap();
|
||||
assert!(last < 0.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ignores_non_finite_input() {
|
||||
let mut sr = SterlingRatio::new(3).unwrap();
|
||||
assert_eq!(sr.update(0.1), None);
|
||||
assert_eq!(sr.update(f64::NAN), None);
|
||||
assert_eq!(sr.update(-0.1), None);
|
||||
assert!(sr.update(0.1).is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reset_clears_state() {
|
||||
let mut sr = SterlingRatio::new(3).unwrap();
|
||||
sr.batch(&[0.1, -0.1, 0.1]);
|
||||
assert!(sr.is_ready());
|
||||
sr.reset();
|
||||
assert!(!sr.is_ready());
|
||||
assert_eq!(sr.update(0.1), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn batch_equals_streaming() {
|
||||
let rets: Vec<f64> = (0..60)
|
||||
.map(|i| (f64::from(i) * 0.25).sin() * 0.05)
|
||||
.collect();
|
||||
let batch = SterlingRatio::new(12).unwrap().batch(&rets);
|
||||
let mut streamer = SterlingRatio::new(12).unwrap();
|
||||
let streamed: Vec<_> = rets.iter().map(|r| streamer.update(*r)).collect();
|
||||
assert_eq!(batch, streamed);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,224 @@
|
||||
//! Tail Ratio — the right tail (95th percentile) over the absolute left tail (5th percentile).
|
||||
|
||||
use std::collections::VecDeque;
|
||||
|
||||
use crate::error::{Error, Result};
|
||||
use crate::traits::Indicator;
|
||||
|
||||
/// Tail Ratio over a trailing window of `period` returns.
|
||||
///
|
||||
/// ```text
|
||||
/// TailRatio = P95(returns) / |P5(returns)|
|
||||
/// ```
|
||||
///
|
||||
/// The Tail Ratio contrasts the magnitude of the best outcomes against the worst:
|
||||
/// the 95th percentile of the return distribution divided by the absolute value of
|
||||
/// the 5th percentile. A value above `1.0` means the right tail (upside surprises)
|
||||
/// is fatter than the left tail (downside surprises); below `1.0` means crashes are
|
||||
/// larger than rallies. It is a distribution-shape statistic, distinct from the
|
||||
/// average-based [`SharpeRatio`](crate::SharpeRatio): two series with the same mean
|
||||
/// and variance can have very different tail ratios.
|
||||
///
|
||||
/// Percentiles are computed by linear interpolation over the sorted window
|
||||
/// (the same rule `NumPy` uses by default). A window whose 5th percentile is exactly
|
||||
/// zero has no measurable left tail and the indicator reports `0.0` rather than
|
||||
/// dividing by zero.
|
||||
///
|
||||
/// The first value lands after `period` returns; each `update` re-sorts the window
|
||||
/// (O(period log period)), which is O(1) in the length of the overall series.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```
|
||||
/// use wickra_core::{Indicator, TailRatio};
|
||||
///
|
||||
/// let mut indicator = TailRatio::new(20).unwrap();
|
||||
/// let mut last = None;
|
||||
/// for i in 0..40 {
|
||||
/// last = indicator.update((f64::from(i) * 0.3).sin() * 0.02);
|
||||
/// }
|
||||
/// assert!(last.is_some());
|
||||
/// ```
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct TailRatio {
|
||||
period: usize,
|
||||
window: VecDeque<f64>,
|
||||
}
|
||||
|
||||
impl TailRatio {
|
||||
/// Construct a Tail Ratio over `period` returns.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// Returns [`Error::InvalidPeriod`] if `period < 2` (percentiles need at least
|
||||
/// two observations to interpolate).
|
||||
pub fn new(period: usize) -> Result<Self> {
|
||||
if period < 2 {
|
||||
return Err(Error::InvalidPeriod {
|
||||
message: "tail ratio needs period >= 2",
|
||||
});
|
||||
}
|
||||
Ok(Self {
|
||||
period,
|
||||
window: VecDeque::with_capacity(period),
|
||||
})
|
||||
}
|
||||
|
||||
/// Configured window of returns.
|
||||
pub const fn period(&self) -> usize {
|
||||
self.period
|
||||
}
|
||||
|
||||
fn compute(&self) -> f64 {
|
||||
let mut sorted: Vec<f64> = self.window.iter().copied().collect();
|
||||
sorted.sort_unstable_by(f64::total_cmp);
|
||||
let upper = percentile(&sorted, 95.0);
|
||||
let lower = percentile(&sorted, 5.0).abs();
|
||||
if lower > 0.0 {
|
||||
upper / lower
|
||||
} else {
|
||||
0.0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Linear-interpolation percentile of an ascending, non-empty slice.
|
||||
fn percentile(sorted: &[f64], pct: f64) -> f64 {
|
||||
let last_index = sorted.len() - 1;
|
||||
#[allow(clippy::cast_precision_loss)]
|
||||
let rank = pct / 100.0 * last_index as f64;
|
||||
let floor = rank.floor();
|
||||
// `rank` lies in `[0, last_index]`, so its floor is a valid in-bounds index.
|
||||
#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
|
||||
let lower = floor as usize;
|
||||
if lower >= last_index {
|
||||
return sorted[last_index];
|
||||
}
|
||||
let frac = rank - floor;
|
||||
sorted[lower] + frac * (sorted[lower + 1] - sorted[lower])
|
||||
}
|
||||
|
||||
impl Indicator for TailRatio {
|
||||
type Input = f64;
|
||||
type Output = f64;
|
||||
|
||||
fn update(&mut self, ret: f64) -> Option<f64> {
|
||||
if !ret.is_finite() {
|
||||
return None;
|
||||
}
|
||||
if self.window.len() == self.period {
|
||||
self.window.pop_front();
|
||||
}
|
||||
self.window.push_back(ret);
|
||||
if self.window.len() < self.period {
|
||||
return None;
|
||||
}
|
||||
Some(self.compute())
|
||||
}
|
||||
|
||||
fn reset(&mut self) {
|
||||
self.window.clear();
|
||||
}
|
||||
|
||||
fn warmup_period(&self) -> usize {
|
||||
self.period
|
||||
}
|
||||
|
||||
fn is_ready(&self) -> bool {
|
||||
self.window.len() == self.period
|
||||
}
|
||||
|
||||
fn name(&self) -> &'static str {
|
||||
"TailRatio"
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::traits::BatchExt;
|
||||
use approx::assert_relative_eq;
|
||||
|
||||
#[test]
|
||||
fn rejects_period_less_than_two() {
|
||||
assert!(matches!(
|
||||
TailRatio::new(1),
|
||||
Err(Error::InvalidPeriod { .. })
|
||||
));
|
||||
assert!(matches!(
|
||||
TailRatio::new(0),
|
||||
Err(Error::InvalidPeriod { .. })
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn accessors_and_metadata() {
|
||||
let tr = TailRatio::new(20).unwrap();
|
||||
assert_eq!(tr.period(), 20);
|
||||
assert_eq!(tr.warmup_period(), 20);
|
||||
assert_eq!(tr.name(), "TailRatio");
|
||||
assert!(!tr.is_ready());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reference_value() {
|
||||
// sorted window [-0.04, -0.02, 0.0, 0.02, 0.04], last_index = 4.
|
||||
// P95: rank 3.8 -> 0.02 + 0.8*(0.04-0.02) = 0.036.
|
||||
// P5: rank 0.2 -> -0.04 + 0.2*(0.02) = -0.036, abs 0.036.
|
||||
// ratio = 0.036 / 0.036 = 1.0.
|
||||
let mut tr = TailRatio::new(5).unwrap();
|
||||
let out = tr.batch(&[-0.04, -0.02, 0.0, 0.02, 0.04]);
|
||||
assert_relative_eq!(out[4].unwrap(), 1.0, epsilon = 1e-9);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fatter_right_tail_exceeds_one() {
|
||||
let mut tr = TailRatio::new(5).unwrap();
|
||||
let out = tr.batch(&[-0.01, 0.0, 0.01, 0.02, 0.10]);
|
||||
assert!(out[4].unwrap() > 1.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn flat_window_is_zero() {
|
||||
let mut tr = TailRatio::new(4).unwrap();
|
||||
let last = tr.batch(&[0.0; 4]).into_iter().flatten().last().unwrap();
|
||||
assert_relative_eq!(last, 0.0, epsilon = 1e-12);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ignores_non_finite_input() {
|
||||
let mut tr = TailRatio::new(3).unwrap();
|
||||
assert_eq!(tr.update(0.01), None);
|
||||
assert_eq!(tr.update(f64::NAN), None);
|
||||
assert_eq!(tr.update(0.02), None);
|
||||
assert!(tr.update(0.03).is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reset_clears_state() {
|
||||
let mut tr = TailRatio::new(3).unwrap();
|
||||
tr.batch(&[-0.01, 0.0, 0.02]);
|
||||
assert!(tr.is_ready());
|
||||
tr.reset();
|
||||
assert!(!tr.is_ready());
|
||||
assert_eq!(tr.update(0.01), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn batch_equals_streaming() {
|
||||
let rets: Vec<f64> = (0..60)
|
||||
.map(|i| (f64::from(i) * 0.25).sin() * 0.02)
|
||||
.collect();
|
||||
let batch = TailRatio::new(15).unwrap().batch(&rets);
|
||||
let mut streamer = TailRatio::new(15).unwrap();
|
||||
let streamed: Vec<_> = rets.iter().map(|r| streamer.update(*r)).collect();
|
||||
assert_eq!(batch, streamed);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn percentile_at_top_returns_last() {
|
||||
// When the rank floor reaches the final index (the 100th percentile), the
|
||||
// helper returns the largest element without interpolating past the end.
|
||||
assert_relative_eq!(percentile(&[1.0, 2.0, 3.0], 100.0), 3.0, epsilon = 1e-12);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,226 @@
|
||||
//! Upside Potential Ratio (Sortino, van der Meer & Plantinga) — upside mean over downside deviation.
|
||||
|
||||
use std::collections::VecDeque;
|
||||
|
||||
use crate::error::{Error, Result};
|
||||
use crate::traits::Indicator;
|
||||
|
||||
/// Upside Potential Ratio over a trailing window of `period` returns, measured
|
||||
/// relative to a minimal acceptable return (`mar`).
|
||||
///
|
||||
/// ```text
|
||||
/// upside = mean( max(r − mar, 0) ) over the window
|
||||
/// downside = sqrt( mean( min(r − mar, 0)² ) ) over the window
|
||||
/// UPR = upside / downside
|
||||
/// ```
|
||||
///
|
||||
/// Where the [`SharpeRatio`](crate::SharpeRatio) divides excess return by *total*
|
||||
/// volatility (penalising upside and downside symmetrically), the Upside Potential
|
||||
/// Ratio rewards only the average outperformance above the threshold while
|
||||
/// penalising solely the downside deviation below it. It is the purest expression
|
||||
/// of the Sortino philosophy: investors do not dislike upside variance, only
|
||||
/// shortfall risk.
|
||||
///
|
||||
/// `mar` (minimal acceptable return) is the per-period hurdle the caller supplies
|
||||
/// (e.g. `0.0` for break-even, or a target rate matching the return frequency). A
|
||||
/// window that never breaches the threshold has zero downside deviation; the
|
||||
/// indicator then reports `0.0` rather than dividing by zero.
|
||||
///
|
||||
/// Each `update` is O(1) — running sums maintain the upside total and the
|
||||
/// downside sum-of-squares as the window slides.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```
|
||||
/// use wickra_core::{Indicator, UpsidePotentialRatio};
|
||||
///
|
||||
/// let mut indicator = UpsidePotentialRatio::new(20, 0.0).unwrap();
|
||||
/// let mut last = None;
|
||||
/// for i in 0..40 {
|
||||
/// last = indicator.update((f64::from(i) * 0.3).sin() * 0.02);
|
||||
/// }
|
||||
/// assert!(last.is_some());
|
||||
/// ```
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct UpsidePotentialRatio {
|
||||
period: usize,
|
||||
mar: f64,
|
||||
window: VecDeque<f64>,
|
||||
sum_upside: f64,
|
||||
sum_downside_sq: f64,
|
||||
}
|
||||
|
||||
impl UpsidePotentialRatio {
|
||||
/// Construct an Upside Potential Ratio over `period` returns with minimal
|
||||
/// acceptable return `mar`.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// Returns [`Error::InvalidPeriod`] if `period < 2`, or
|
||||
/// [`Error::InvalidParameter`] if `mar` is not finite.
|
||||
pub fn new(period: usize, mar: f64) -> Result<Self> {
|
||||
if period < 2 {
|
||||
return Err(Error::InvalidPeriod {
|
||||
message: "upside potential ratio needs period >= 2",
|
||||
});
|
||||
}
|
||||
if !mar.is_finite() {
|
||||
return Err(Error::InvalidParameter {
|
||||
message: "mar must be finite",
|
||||
});
|
||||
}
|
||||
Ok(Self {
|
||||
period,
|
||||
mar,
|
||||
window: VecDeque::with_capacity(period),
|
||||
sum_upside: 0.0,
|
||||
sum_downside_sq: 0.0,
|
||||
})
|
||||
}
|
||||
|
||||
/// Configured window of returns.
|
||||
pub const fn period(&self) -> usize {
|
||||
self.period
|
||||
}
|
||||
|
||||
/// Configured minimal acceptable return.
|
||||
pub const fn mar(&self) -> f64 {
|
||||
self.mar
|
||||
}
|
||||
}
|
||||
|
||||
impl Indicator for UpsidePotentialRatio {
|
||||
type Input = f64;
|
||||
type Output = f64;
|
||||
|
||||
fn update(&mut self, ret: f64) -> Option<f64> {
|
||||
if !ret.is_finite() {
|
||||
return None;
|
||||
}
|
||||
if self.window.len() == self.period {
|
||||
let old = self.window.pop_front().expect("non-empty");
|
||||
let excess = old - self.mar;
|
||||
self.sum_upside -= excess.max(0.0);
|
||||
self.sum_downside_sq -= excess.min(0.0).powi(2);
|
||||
}
|
||||
let excess = ret - self.mar;
|
||||
self.sum_upside += excess.max(0.0);
|
||||
self.sum_downside_sq += excess.min(0.0).powi(2);
|
||||
self.window.push_back(ret);
|
||||
if self.window.len() < self.period {
|
||||
return None;
|
||||
}
|
||||
let n = self.period as f64;
|
||||
let upside_mean = self.sum_upside / n;
|
||||
let downside_dev = (self.sum_downside_sq / n).sqrt();
|
||||
if downside_dev > 0.0 {
|
||||
Some(upside_mean / downside_dev)
|
||||
} else {
|
||||
Some(0.0)
|
||||
}
|
||||
}
|
||||
|
||||
fn reset(&mut self) {
|
||||
self.window.clear();
|
||||
self.sum_upside = 0.0;
|
||||
self.sum_downside_sq = 0.0;
|
||||
}
|
||||
|
||||
fn warmup_period(&self) -> usize {
|
||||
self.period
|
||||
}
|
||||
|
||||
fn is_ready(&self) -> bool {
|
||||
self.window.len() == self.period
|
||||
}
|
||||
|
||||
fn name(&self) -> &'static str {
|
||||
"UpsidePotentialRatio"
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::traits::BatchExt;
|
||||
use approx::assert_relative_eq;
|
||||
|
||||
#[test]
|
||||
fn rejects_period_less_than_two() {
|
||||
assert!(matches!(
|
||||
UpsidePotentialRatio::new(1, 0.0),
|
||||
Err(Error::InvalidPeriod { .. })
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_non_finite_mar() {
|
||||
assert!(matches!(
|
||||
UpsidePotentialRatio::new(10, f64::NAN),
|
||||
Err(Error::InvalidParameter { .. })
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn accessors_and_metadata() {
|
||||
let upr = UpsidePotentialRatio::new(20, 0.001).unwrap();
|
||||
assert_eq!(upr.period(), 20);
|
||||
assert_relative_eq!(upr.mar(), 0.001, epsilon = 1e-12);
|
||||
assert_eq!(upr.warmup_period(), 20);
|
||||
assert_eq!(upr.name(), "UpsidePotentialRatio");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reference_value() {
|
||||
// returns [0.02, -0.01, 0.03, -0.02], mar = 0.
|
||||
// upside = (0.02 + 0 + 0.03 + 0)/4 = 0.0125.
|
||||
// downside = sqrt((0 + 0.0001 + 0 + 0.0004)/4) = sqrt(0.000125).
|
||||
// UPR = 0.0125 / sqrt(0.000125).
|
||||
let mut upr = UpsidePotentialRatio::new(4, 0.0).unwrap();
|
||||
let out = upr.batch(&[0.02, -0.01, 0.03, -0.02]);
|
||||
let expected = 0.0125_f64 / (0.000_125_f64).sqrt();
|
||||
assert_relative_eq!(out[3].unwrap(), expected, epsilon = 1e-9);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn no_downside_is_zero() {
|
||||
let mut upr = UpsidePotentialRatio::new(3, 0.0).unwrap();
|
||||
let last = upr
|
||||
.batch(&[0.01, 0.02, 0.03])
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.last()
|
||||
.unwrap();
|
||||
assert_relative_eq!(last, 0.0, epsilon = 1e-12);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ignores_non_finite_input() {
|
||||
let mut upr = UpsidePotentialRatio::new(3, 0.0).unwrap();
|
||||
assert_eq!(upr.update(0.01), None);
|
||||
assert_eq!(upr.update(f64::INFINITY), None);
|
||||
assert_eq!(upr.update(-0.02), None);
|
||||
assert!(upr.update(0.03).is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reset_clears_state() {
|
||||
let mut upr = UpsidePotentialRatio::new(2, 0.0).unwrap();
|
||||
upr.batch(&[0.02, -0.01]);
|
||||
assert!(upr.is_ready());
|
||||
upr.reset();
|
||||
assert!(!upr.is_ready());
|
||||
assert_eq!(upr.update(0.01), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn batch_equals_streaming() {
|
||||
let rets: Vec<f64> = (0..60)
|
||||
.map(|i| (f64::from(i) * 0.25).sin() * 0.02)
|
||||
.collect();
|
||||
let batch = UpsidePotentialRatio::new(12, 0.0).unwrap().batch(&rets);
|
||||
let mut streamer = UpsidePotentialRatio::new(12, 0.0).unwrap();
|
||||
let streamed: Vec<_> = rets.iter().map(|r| streamer.update(*r)).collect();
|
||||
assert_eq!(batch, streamed);
|
||||
}
|
||||
}
|
||||
@@ -66,30 +66,31 @@ pub use indicators::{
|
||||
AverageDrawdown, AvgPrice, AwesomeOscillator, AwesomeOscillatorHistogram, BalanceOfPower,
|
||||
BandpassFilter, Bat, BeltHold, Beta, BetaNeutralSpread, BetterVolume, BipowerVariation,
|
||||
BodySizePct, BollingerBands, BollingerBandwidth, BollingerOutput, BomarBands, BomarBandsOutput,
|
||||
BreadthThrust, Breakaway, BullishPercentIndex, Butterfly, CalendarSpread, CalmarRatio,
|
||||
Camarilla, CamarillaPivotsOutput, CandleVolume, CandleVolumeOutput, Cci, CenterOfGravity,
|
||||
CentralPivotRange, CentralPivotRangeOutput, Cfo, ChaikinMoneyFlow, ChaikinOscillator,
|
||||
ChaikinVolatility, ChandeKrollStop, ChandeKrollStopOutput, ChandelierExit,
|
||||
BreadthThrust, Breakaway, BullishPercentIndex, BurkeRatio, Butterfly, CalendarSpread,
|
||||
CalmarRatio, Camarilla, CamarillaPivotsOutput, CandleVolume, CandleVolumeOutput, Cci,
|
||||
CenterOfGravity, CentralPivotRange, CentralPivotRangeOutput, Cfo, ChaikinMoneyFlow,
|
||||
ChaikinOscillator, ChaikinVolatility, ChandeKrollStop, ChandeKrollStopOutput, ChandelierExit,
|
||||
ChandelierExitOutput, ChoppinessIndex, ClassicPivots, ClassicPivotsOutput, CloseVsOpen,
|
||||
ClosingMarubozu, Cmo, CoefficientOfVariation, Cointegration, CointegrationOutput,
|
||||
CompositeProfile, CompositeProfileOutput, ConcealingBabySwallow, ConditionalValueAtRisk,
|
||||
ConnorsRsi, Coppock, CorrelationTrendIndicator, Counterattack, Crab, CumulativeVolumeDelta,
|
||||
CumulativeVolumeIndex, CupAndHandle, CyberneticCycle, Cypher, DayOfWeekProfile,
|
||||
DayOfWeekProfileOutput, Decycler, DecyclerOscillator, Dema, DemandIndex, DemarkPivots,
|
||||
DemarkPivotsOutput, DepthSlope, DerivativeOscillator, DetrendedStdDev, DisparityIndex,
|
||||
DistanceSsd, Doji, DojiStar, Donchian, DonchianOutput, DonchianStop, DonchianStopOutput,
|
||||
DoubleBollinger, DoubleBollingerOutput, DoubleTopBottom, DownsideGapThreeMethods, Dpo,
|
||||
DragonflyDoji, DrawdownDuration, DumplingTop, Dx, DynamicMomentumIndex, EaseOfMovement,
|
||||
EffectiveSpread, EhlersStochastic, Ehma, ElderImpulse, ElderRay, ElderRayOutput, ElderSafeZone,
|
||||
ElderSafeZoneOutput, Ema, EmpiricalModeDecomposition, Engulfing, Equivolume, EquivolumeOutput,
|
||||
EstimatedLeverageRatio, EvenBetterSinewave, EveningDojiStar, Evwma, EwmaVolatility, Expectancy,
|
||||
FallingThreeMethods, Fama, FibArcs, FibArcsOutput, FibChannel, FibChannelOutput, FibConfluence,
|
||||
FibConfluenceOutput, FibExtension, FibExtensionOutput, FibFan, FibFanOutput, FibProjection,
|
||||
FibProjectionOutput, FibRetracement, FibRetracementOutput, FibTimeZones, FibTimeZonesOutput,
|
||||
FibonacciPivots, FibonacciPivotsOutput, FisherRsi, FisherTransform, FlagPennant, Footprint,
|
||||
FootprintOutput, ForceIndex, FractalChaosBands, FractalChaosBandsOutput, Frama, FryPanBottom,
|
||||
FundingBasis, FundingImpliedApr, FundingRate, FundingRateMean, FundingRateZScore,
|
||||
GainLossRatio, GapSideBySideWhite, Garch11, GarmanKlassVolatility, Gartley, GatorOscillator,
|
||||
CommonSenseRatio, CompositeProfile, CompositeProfileOutput, ConcealingBabySwallow,
|
||||
ConditionalValueAtRisk, ConnorsRsi, Coppock, CorrelationTrendIndicator, Counterattack, Crab,
|
||||
CumulativeVolumeDelta, CumulativeVolumeIndex, CupAndHandle, CyberneticCycle, Cypher,
|
||||
DayOfWeekProfile, DayOfWeekProfileOutput, Decycler, DecyclerOscillator, Dema, DemandIndex,
|
||||
DemarkPivots, DemarkPivotsOutput, DepthSlope, DerivativeOscillator, DetrendedStdDev,
|
||||
DisparityIndex, DistanceSsd, Doji, DojiStar, Donchian, DonchianOutput, DonchianStop,
|
||||
DonchianStopOutput, DoubleBollinger, DoubleBollingerOutput, DoubleTopBottom,
|
||||
DownsideGapThreeMethods, Dpo, DragonflyDoji, DrawdownDuration, DumplingTop, Dx,
|
||||
DynamicMomentumIndex, EaseOfMovement, EffectiveSpread, EhlersStochastic, Ehma, ElderImpulse,
|
||||
ElderRay, ElderRayOutput, ElderSafeZone, ElderSafeZoneOutput, Ema, EmpiricalModeDecomposition,
|
||||
Engulfing, Equivolume, EquivolumeOutput, EstimatedLeverageRatio, EvenBetterSinewave,
|
||||
EveningDojiStar, Evwma, EwmaVolatility, Expectancy, FallingThreeMethods, Fama, FibArcs,
|
||||
FibArcsOutput, FibChannel, FibChannelOutput, FibConfluence, FibConfluenceOutput, FibExtension,
|
||||
FibExtensionOutput, FibFan, FibFanOutput, FibProjection, FibProjectionOutput, FibRetracement,
|
||||
FibRetracementOutput, FibTimeZones, FibTimeZonesOutput, FibonacciPivots, FibonacciPivotsOutput,
|
||||
FisherRsi, FisherTransform, FlagPennant, Footprint, FootprintOutput, ForceIndex,
|
||||
FractalChaosBands, FractalChaosBandsOutput, Frama, FryPanBottom, FundingBasis,
|
||||
FundingImpliedApr, FundingRate, FundingRateMean, FundingRateZScore, GainLossRatio,
|
||||
GainToPainRatio, GapSideBySideWhite, Garch11, GarmanKlassVolatility, Gartley, GatorOscillator,
|
||||
GatorOscillatorOutput, GeneralizedDema, GeometricMa, GoldenPocket, GoldenPocketOutput,
|
||||
GrangerCausality, GravestoneDoji, Hammer, HangingMan, Harami, HaramiCross,
|
||||
HasbrouckInformationShare, HeadAndShoulders, HeikinAshi, HeikinAshiOscillator,
|
||||
@@ -100,22 +101,22 @@ pub use indicators::{
|
||||
Ichimoku, IchimokuOutput, IdenticalThreeCrows, InNeck, Inertia, InformationRatio,
|
||||
InitialBalance, InitialBalanceOutput, InstantaneousTrendline, IntradayIntensity,
|
||||
IntradayMomentumIndex, IntradayVolatilityProfile, IntradayVolatilityProfileOutput,
|
||||
InverseFisherTransform, InvertedHammer, JarqueBera, Jma, JumpIndicator, KagiBars,
|
||||
InverseFisherTransform, InvertedHammer, JarqueBera, Jma, JumpIndicator, KRatio, KagiBars,
|
||||
KalmanHedgeRatio, KalmanHedgeRatioOutput, Kama, KaseDevStop, KaseDevStopOutput,
|
||||
KasePermissionStochastic, KasePermissionStochasticOutput, KellyCriterion, Keltner,
|
||||
KeltnerOutput, KendallTau, Kicking, KickingByLength, Kst, KstOutput, Kurtosis, Kvo,
|
||||
KylesLambda, LadderBottom, LaguerreRsi, LeadLagCrossCorrelation, LeadLagCrossCorrelationOutput,
|
||||
LinRegAngle, LinRegChannel, LinRegChannelOutput, LinRegIntercept, LinRegSlope,
|
||||
LinearRegression, LiquidationFeatures, LiquidationFeaturesOutput, LogReturn, LongLeggedDoji,
|
||||
LongLine, LongShortRatio, MaEnvelope, MaEnvelopeOutput, MacdExt, MacdFix, MacdHistogram,
|
||||
MacdIndicator, MacdOutput, Mama, MamaOutput, MarketFacilitationIndex, Marubozu, MassIndex,
|
||||
MatHold, MatchingLow, MaxDrawdown, McClellanOscillator, McClellanSummationIndex,
|
||||
McGinleyDynamic, MedianAbsoluteDeviation, MedianChannel, MedianChannelOutput, MedianMa,
|
||||
MedianPrice, Mfi, Microprice, MidPoint, MidPrice, MinusDi, MinusDm, ModifiedMaStop,
|
||||
ModifiedMaStopOutput, Mom, MorningDojiStar, MorningEveningStar, MurreyMathLines,
|
||||
MurreyMathLinesOutput, NakedPoc, Natr, NewHighsNewLows, NewPriceLines, Nrtr, NrtrOutput, Nvi,
|
||||
OIPriceDivergence, OIWeighted, Obv, OiToVolumeRatio, OmegaRatio, OnNeck, OpenInterestDelta,
|
||||
OpenInterestMomentum, OpeningMarubozu, OpeningRange, OpeningRangeOutput,
|
||||
LongLine, LongShortRatio, M2Measure, MaEnvelope, MaEnvelopeOutput, MacdExt, MacdFix,
|
||||
MacdHistogram, MacdIndicator, MacdOutput, Mama, MamaOutput, MarketFacilitationIndex,
|
||||
MartinRatio, Marubozu, MassIndex, MatHold, MatchingLow, MaxDrawdown, McClellanOscillator,
|
||||
McClellanSummationIndex, McGinleyDynamic, MedianAbsoluteDeviation, MedianChannel,
|
||||
MedianChannelOutput, MedianMa, MedianPrice, Mfi, Microprice, MidPoint, MidPrice, MinusDi,
|
||||
MinusDm, ModifiedMaStop, ModifiedMaStopOutput, Mom, MorningDojiStar, MorningEveningStar,
|
||||
MurreyMathLines, MurreyMathLinesOutput, NakedPoc, Natr, NewHighsNewLows, NewPriceLines, Nrtr,
|
||||
NrtrOutput, Nvi, OIPriceDivergence, OIWeighted, Obv, OiToVolumeRatio, OmegaRatio, OnNeck,
|
||||
OpenInterestDelta, OpenInterestMomentum, OpeningMarubozu, OpeningRange, OpeningRangeOutput,
|
||||
OrderBookImbalanceFull, OrderBookImbalanceTop1, OrderBookImbalanceTopN, OrderFlowImbalance,
|
||||
OuHalfLife, OvernightGap, OvernightIntradayReturn, OvernightIntradayReturnOutput, PainIndex,
|
||||
PairSpreadZScore, PairwiseBeta, ParkinsonVolatility, PearsonCorrelation, PercentAboveMa,
|
||||
@@ -135,11 +136,11 @@ pub use indicators::{
|
||||
SmoothedHeikinAshiOutput, SortinoRatio, SpearmanCorrelation, SpinningTop, SpreadAr1Coefficient,
|
||||
SpreadBollingerBands, SpreadBollingerBandsOutput, SpreadHurst, StalledPattern, StandardError,
|
||||
StandardErrorBands, StandardErrorBandsOutput, StarcBands, StarcBandsOutput, Stc, StdDev,
|
||||
StepTrailingStop, StickSandwich, StochRsi, Stochastic, StochasticCci, StochasticOutput,
|
||||
SuperSmoother, SuperTrend, SuperTrendOutput, TakerBuySellRatio, Takuri, TasukiGap,
|
||||
TdCamouflage, TdClop, TdClopwin, TdCombo, TdCountdown, TdDWave, TdDeMarker, TdDifferential,
|
||||
TdLines, TdLinesOutput, TdMovingAverage, TdMovingAverageOutput, TdOpen, TdPressure,
|
||||
TdPropulsion, TdRangeProjection, TdRangeProjectionOutput, TdRei, TdRiskLevel,
|
||||
StepTrailingStop, SterlingRatio, StickSandwich, StochRsi, Stochastic, StochasticCci,
|
||||
StochasticOutput, SuperSmoother, SuperTrend, SuperTrendOutput, TailRatio, TakerBuySellRatio,
|
||||
Takuri, TasukiGap, TdCamouflage, TdClop, TdClopwin, TdCombo, TdCountdown, TdDWave, TdDeMarker,
|
||||
TdDifferential, TdLines, TdLinesOutput, TdMovingAverage, TdMovingAverageOutput, TdOpen,
|
||||
TdPressure, TdPropulsion, TdRangeProjection, TdRangeProjectionOutput, TdRei, TdRiskLevel,
|
||||
TdRiskLevelOutput, TdSequential, TdSequentialOutput, TdSetup, TdTrap, Tema, TermStructureBasis,
|
||||
ThreeDrives, ThreeInside, ThreeLineBreak, ThreeLineStrike, ThreeOutside, ThreeSoldiersOrCrows,
|
||||
ThreeStarsInSouth, Thrusting, TickIndex, Tii, TimeBasedStop, TimeOfDayReturnProfile,
|
||||
@@ -148,16 +149,16 @@ pub use indicators::{
|
||||
TreynorRatio, Triangle, Trima, Trin, TripleTopBottom, Tristar, Trix, TrueRange, Tsf,
|
||||
TsfOscillator, Tsi, Tsv, TtmSqueeze, TtmSqueezeOutput, TtmTrend, TurnOfMonth, Tweezer,
|
||||
TwiggsMoneyFlow, TwoCrows, TypicalPrice, UlcerIndex, UltimateOscillator, UniqueThreeRiver,
|
||||
UniversalOscillator, UpDownVolumeRatio, UpsideGapThreeMethods, UpsideGapTwoCrows, ValueArea,
|
||||
ValueAreaOutput, ValueAtRisk, Variance, VarianceRatio, VerticalHorizontalFilter, Vidya,
|
||||
VolatilityCone, VolatilityConeOutput, VolatilityOfVolatility, VolatilityRatio, VoltyStop,
|
||||
VolumeByTimeProfile, VolumeByTimeProfileOutput, VolumeOscillator, VolumePriceTrend,
|
||||
VolumeProfile, VolumeProfileOutput, VolumeRsi, VolumeWeightedMacd, VolumeWeightedMacdOutput,
|
||||
VolumeWeightedSr, VolumeWeightedSrOutput, Vortex, VortexOutput, Vpin, Vwap, VwapStdDevBands,
|
||||
VwapStdDevBandsOutput, Vwma, Vzo, Wad, WavePm, WaveTrend, WaveTrendOutput, Wedge,
|
||||
WeightedClose, WickRatio, WilliamsFractals, WilliamsFractalsOutput, WilliamsR, WinRate, Wma,
|
||||
WoodiePivots, WoodiePivotsOutput, YangZhangVolatility, YoyoExit, ZScore, ZeroLagMacd,
|
||||
ZeroLagMacdOutput, ZigZag, ZigZagOutput, Zlema, FAMILIES, T3,
|
||||
UniversalOscillator, UpDownVolumeRatio, UpsideGapThreeMethods, UpsideGapTwoCrows,
|
||||
UpsidePotentialRatio, ValueArea, ValueAreaOutput, ValueAtRisk, Variance, VarianceRatio,
|
||||
VerticalHorizontalFilter, Vidya, VolatilityCone, VolatilityConeOutput, VolatilityOfVolatility,
|
||||
VolatilityRatio, VoltyStop, VolumeByTimeProfile, VolumeByTimeProfileOutput, VolumeOscillator,
|
||||
VolumePriceTrend, VolumeProfile, VolumeProfileOutput, VolumeRsi, VolumeWeightedMacd,
|
||||
VolumeWeightedMacdOutput, VolumeWeightedSr, VolumeWeightedSrOutput, Vortex, VortexOutput, Vpin,
|
||||
Vwap, VwapStdDevBands, VwapStdDevBandsOutput, Vwma, Vzo, Wad, WavePm, WaveTrend,
|
||||
WaveTrendOutput, Wedge, WeightedClose, WickRatio, WilliamsFractals, WilliamsFractalsOutput,
|
||||
WilliamsR, WinRate, Wma, WoodiePivots, WoodiePivotsOutput, YangZhangVolatility, YoyoExit,
|
||||
ZScore, ZeroLagMacd, ZeroLagMacdOutput, ZigZag, ZigZagOutput, Zlema, FAMILIES, T3,
|
||||
};
|
||||
// `FootprintLevel` is a row element of `FootprintOutput`, re-exported on its own
|
||||
// line so the indicator-count tooling (which scans the braced block above and
|
||||
|
||||
Reference in New Issue
Block a user