quantwave 0.4.0__tar.gz → 0.5.1__tar.gz

{quantwave-0.4.0 → quantwave-0.5.1}/Cargo.lock

@@ -2125,15 +2125,30 @@ dependencies = [
 
 [[package]]
 name = "quantwave"
-version = "0.4.0"
+version = "0.5.1"
 dependencies = [
  "quantwave-core",
  "quantwave-polars",
 ]
 
+[[package]]
+name = "quantwave-backtest"
+version = "0.5.1"
+dependencies = [
+ "approx",
+ "chrono",
+ "polars",
+ "proptest",
+ "quantwave-core",
+ "rand 0.8.6",
+ "serde",
+ "serde_json",
+ "thiserror 1.0.69",
+]
+
 [[package]]
 name = "quantwave-core"
-version = "0.4.0"
+version = "0.5.1"
 dependencies = [
  "approx",
  "chrono",
@@ -2151,7 +2166,7 @@ dependencies = [
 
 [[package]]
 name = "quantwave-plugins"
-version = "0.4.0"
+version = "0.5.1"
 dependencies = [
  "polars",
  "polars-arrow",
@@ -2162,7 +2177,7 @@ dependencies = [
 
 [[package]]
 name = "quantwave-polars"
-version = "0.4.0"
+version = "0.5.1"
 dependencies = [
  "polars",
  "quantwave-core",
@@ -2172,7 +2187,7 @@ dependencies = [
 
 [[package]]
 name = "quantwave-python"
-version = "0.4.0"
+version = "0.5.1"
 dependencies = [
  "paste",
  "quantwave-core",
@@ -2181,7 +2196,7 @@ dependencies = [
 
 [[package]]
 name = "quantwave-xtask"
-version = "0.4.0"
+version = "0.5.1"
 dependencies = [
  "anyhow",
  "quick-xml",

{quantwave-0.4.0 → quantwave-0.5.1}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["quantwave-core", "quantwave-python"]
 resolver = "2"
 
 [workspace.package]
-version = "0.4.0"
+version = "0.5.1"
 edition = "2024"
 license = "MIT"
 repository = "https://github.com/lavs9/quantwave"
@@ -30,9 +30,10 @@ thiserror = "1.0"
 chrono = { version = "0.4", features = ["serde"] }
 nalgebra = { version = "0.33", features = ["serde-serialize"] }
 statrs = "0.18"
-quantwave-core = { path = "quantwave-core", version = "0.4.0" }
-quantwave-polars = { path = "quantwave-polars", version = "0.4.0" }
-quantwave-plugins = { path = "quantwave-plugins", version = "0.4.0" }
+quantwave-core = { path = "quantwave-core", version = "0.5.1" }
+quantwave-polars = { path = "quantwave-polars", version = "0.5.1" }
+quantwave-plugins = { path = "quantwave-plugins", version = "0.5.1" }
+quantwave-backtest = { path = "quantwave-backtest", version = "0.5.1" }
 
 [profile.dev]
 opt-level = 0

{quantwave-0.4.0 → quantwave-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantwave
-Version: 0.4.0
+Version: 0.5.1
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Financial and Insurance Industry

{quantwave-0.4.0 → quantwave-0.5.1}/python/quantwave/__init__.py

@@ -125,6 +125,16 @@ class ta:
     rocket_rsi = rocketrsi
     trendflex = trendflex
     truncated_bandpass = truncatedbandpass
+    # ML features (gw7s notebook + harness + 4ps/gwx cross-epic deliverable)
+    cyber_cycle_feature_extractor = CyberCycleFeatureExtractor
+    hurst_feature_extractor = HurstFeatureExtractor
+    instantaneous_trendline_feature_extractor = InstantaneousTrendlineFeatureExtractor
+    trendflex_feature_extractor = TrendflexFeatureExtractor
+    regime_to_features = regime_to_features
+    # Newly wired for the E2E notebook (trivial parallel to above; completes the locked .ta.features.* surface in Python)
+    griffiths_dominant_cycle_feature_extractor = GriffithsDominantCycleFeatureExtractor
+    bull_bear_hmm = BullBearHMM
+    griffiths_dominant_cycle_features = griffiths_dominant_cycle_features  # batch helper
     volume_profile = volumeprofile
 
 class options_india:
@@ -170,5 +180,9 @@ __all__ = [
     "HtDcPeriod", "HtPhasor", "HtDcPhase", "HtSine", "HtTrendMode",
     "HurstExponent", "KalmanFilter", "MarketState", "RecursiveMedian",
     "RecursiveMedianOscillator", "Reflex", "RocketRsi", "Trendflex",
-    "TruncatedBandpass", "VolumeProfile"
+    "TruncatedBandpass", "VolumeProfile",
+    # ML feature toolkit (quantwave-gw7s)
+    "CyberCycleFeatureExtractor", "HurstFeatureExtractor",
+    "InstantaneousTrendlineFeatureExtractor", "TrendflexFeatureExtractor",
+    "regime_to_features"
 ]

quantwave-0.5.1/quantwave-core/README.md

@@ -0,0 +1,101 @@
+# QuantWave
+
+**High-performance, Polars-native technical analysis — in Python and Rust**
+
+150+ indicators · Full Ehlers DSP suite · Regime Detection · Complete Options India stack · Bit-identical streaming & batch
+
+**Python** `pip install quantwave` **Rust** `cargo add quantwave`
+
+[📖 Documentation](https://lavs9.github.io/quantwave/) • [⭐ GitHub](https://github.com/lavs9/quantwave) • [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/lavs9/quantwave)
+
+**150+ indicators • Polars-native • Streaming & batch parity • MIT licensed**
+
+---
+
+## Why QuantWave?
+
+Most quantitative libraries force an uncomfortable compromise.
+
+**Python-first libraries** (pandas-ta, TA-Lib Python wrappers, etc.) are convenient but fall apart on large datasets, recursive indicators, or live streaming — often becoming 10-100x slower than native code.
+
+**Pure Rust libraries** are fast, but they rarely integrate cleanly with modern Polars-based research pipelines and lack the breadth of advanced techniques (Ehlers DSP, regime detection, full Options India analytics).
+
+**QuantWave removes the tradeoff.**
+
+It delivers **institutional-grade Rust performance** through zero-copy Polars expressions, while offering a first-class, productive experience in both Python and Rust. Every indicator is built on a single mathematical source of truth — the `Next<T>` trait — guaranteeing that batch results (Polars) and real-time streaming results are **bit-identical**.
+
+### How We Compare
+
+| Approach                  | Speed on large data | Polars-native | Streaming parity | Breadth (Ehlers + Regimes + Options) |
+|---------------------------|---------------------|---------------|------------------|--------------------------------------|
+| pandas-ta / TA-Lib (Python) | Poor–Average       | Partial      | Rare             | Limited                              |
+| Other Rust TA crates      | Excellent           | Poor         | Rare             | Limited                              |
+| **QuantWave**             | **Excellent**       | **Native**   | **Guaranteed**   | **Strong**                           |
+
+## What We’ve Built
+
+QuantWave is no longer early-stage. It ships with production-ready depth across several domains:
+
+- **150+ Technical Indicators** with TA-Lib parity and extensive Ehlers DSP coverage
+- **Full Regime Detection Suite** (HMM, GMM, PELT, clustering, conditioned risk metrics)
+- **Complete Options India Stack** — Black-Scholes Greeks, IV solvers, chain analytics (Max Pain, PCR, GEX, OI Zones), and NSE utilities, all exposed as native Polars expressions
+- **Streaming & Batch Parity** — The same mathematical logic powers both high-speed Polars pipelines and low-latency streaming via the universal `Next<T>` trait
+- **Gold-Standard Validation** — Every indicator is tested against reference implementations for correctness
+
+## Core Strengths
+
+- **Performance** — Rust core with zero-copy Polars expressions
+- **Correctness** — Validated against gold-standard reference vectors
+- **Parity** — Bit-identical results between batch and streaming
+- **Breadth** — Classic indicators + advanced Ehlers DSP + regime detection + Options India
+- **Developer Experience** — Clean Python API (`from quantwave import ta`) and idiomatic Rust
+
+## Real-World Performance
+
+We don’t just claim to be fast — here’s what the numbers show on 1 million rows of realistic OHLCV data:
+
+- **SuperTrend**: 7.4 ms (QuantWave) vs >200 ms (Pandas) → **~27× faster**
+- **CyberCycle** (Ehlers): 5.0 ms vs >500 ms (Pandas) → **~100× faster**
+- **Instantaneous Trendline**: 74 ms vs >2,000 ms (Pandas) → **~27× faster**
+- **Memory footprint** on realistic multi-ticker data: **2–5× lower** than Pandas
+
+Complex recursive indicators (the ones that matter most for real strategies) are where the gap becomes dramatic.
+
+→ [Full benchmarks & methodology](https://lavs9.github.io/quantwave/benchmarks/)
+
+## Quickstart (Python)
+
+```bash
+pip install quantwave
+```
+
+```python
+import polars as pl
+from quantwave import ta
+
+df = pl.read_parquet("ohlcv.parquet")
+
+df = df.with_columns(
+    ta.rsi("close", 14).alias("rsi"),
+    ta.mama("close").alias("mama"),
+    ta.supertrend("high", "low", "close", period=10, multiplier=3.0).alias("supertrend"),
+)
+```
+
+[More examples → Documentation](https://lavs9.github.io/quantwave/examples/batch-streaming/)
+
+## Get Started
+
+**Primary paths**
+- [Get Started with Python](https://lavs9.github.io/quantwave/getting-started/python/)
+- [Get Started with Rust](https://lavs9.github.io/quantwave/getting-started/rust/)
+
+**Explore further**
+- [Browse All Indicators](https://lavs9.github.io/quantwave/guides/indicators/)
+- [See Real Benchmarks](https://lavs9.github.io/quantwave/benchmarks/)
+- [v0.4.0 Release Notes](https://github.com/lavs9/quantwave/releases/tag/v0.4.0)
+- [Ask DeepWiki](https://deepwiki.com/lavs9/quantwave)
+
+---
+
+**Made with ❤️ for the quant community.**

quantwave-0.5.1/quantwave-core/proptest-regressions/features/mod.txt

@@ -0,0 +1,7 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc 572d6eab56f4d50d39de44b76ecc8fd7a47740a359e835979a56784a3afd2818 # shrinks to data = [0.0, 0.0, 0.0, 0.0, 0.0]

quantwave-0.5.1/quantwave-core/src/features/cyber_cycle.rs

@@ -0,0 +1,76 @@
+//! Cyber Cycle feature extractor wrapper.
+//!
+//! Wraps the existing `CyberCycle` to expose both the cycle value and trigger line
+//! plus a few derived features useful for ML (momentum, zero-cross signal, etc.).
+//!
+//! Primary source: quantwave-core/src/indicators/cyber_cycle.rs:35
+//! (returns (CyberCycle, Trigger) per Ehlers "Cybernetic Analysis for Stocks and Futures")
+
+use crate::indicators::cyber_cycle::CyberCycle;
+use crate::traits::Next;
+
+/// Rich multi-dimensional output for Cyber Cycle features.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct CyberCycleFeatures {
+    pub cycle: f64,
+    pub trigger: f64,
+    /// Simple momentum of the cycle (cycle - previous cycle)
+    pub cycle_momentum: f64,
+    /// Sign of (cycle - trigger) as a basic oscillator signal
+    pub trigger_signal: f64,
+}
+
+#[derive(Debug, Clone)]
+pub struct CyberCycleFeatureExtractor {
+    inner: CyberCycle,
+    prev_cycle: f64,
+}
+
+impl CyberCycleFeatureExtractor {
+    pub fn new(length: usize) -> Self {
+        Self {
+            inner: CyberCycle::new(length),
+            prev_cycle: 0.0,
+        }
+    }
+}
+
+impl Next<f64> for CyberCycleFeatureExtractor {
+    type Output = CyberCycleFeatures;
+
+    fn next(&mut self, input: f64) -> Self::Output {
+        let (cycle, trigger) = self.inner.next(input);
+
+        let momentum = if self.prev_cycle == 0.0 { 0.0 } else { cycle - self.prev_cycle };
+        let trigger_signal = (cycle - trigger).signum();
+
+        self.prev_cycle = cycle;
+
+        CyberCycleFeatures {
+            cycle,
+            trigger,
+            cycle_momentum: momentum,
+            trigger_signal,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use approx::assert_relative_eq;
+
+    #[test]
+    fn test_cyber_cycle_features_basic() {
+        let mut extractor = CyberCycleFeatureExtractor::new(14);
+
+        // Feed some oscillatory data
+        for i in 0..50 {
+            let val = 100.0 + 5.0 * (i as f64 * 0.3).sin();
+            let f = extractor.next(val);
+            if !f.cycle.is_nan() {
+                assert!(f.cycle.abs() < 20.0); // sanity
+            }
+        }
+    }
+}

quantwave-0.5.1/quantwave-core/src/features/ehlers_autocorrelation.rs

@@ -0,0 +1,63 @@
+//! Ehlers Autocorrelation feature extractor wrapper.
+//!
+//! Wraps the lag correlation vector. For ML, we expose the full vector (or top lags)
+//! plus a "dominant lag" summary – excellent cycle feature.
+//!
+//! Source: quantwave-core/src/indicators/ehlers_autocorrelation.rs (returns Vec<f64> correlations)
+
+use crate::indicators::ehlers_autocorrelation::EhlersAutocorrelation;
+use crate::traits::Next;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct EhlersAutocorrelationFeatures {
+    pub correlations: Vec<f64>,
+    pub dominant_lag: usize,
+    pub max_correlation: f64,
+}
+
+#[derive(Debug, Clone)]
+pub struct EhlersAutocorrelationFeatureExtractor {
+    inner: EhlersAutocorrelation,
+}
+
+impl EhlersAutocorrelationFeatureExtractor {
+    pub fn new(length: usize, num_lags: usize) -> Self {
+        Self {
+            inner: EhlersAutocorrelation::new(length, num_lags),
+        }
+    }
+}
+
+impl Next<f64> for EhlersAutocorrelationFeatureExtractor {
+    type Output = EhlersAutocorrelationFeatures;
+
+    fn next(&mut self, input: f64) -> Self::Output {
+        let corrs = self.inner.next(input);
+        let (dominant_lag, &max_correlation) = corrs
+            .iter()
+            .enumerate()
+            .max_by(|a, b| a.1.partial_cmp(b.1).unwrap_or(std::cmp::Ordering::Equal))
+            .unwrap_or((0, &0.0));
+
+        EhlersAutocorrelationFeatures {
+            correlations: corrs,
+            dominant_lag,
+            max_correlation,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_autocorr_wrapper_basic() {
+        let mut ext = EhlersAutocorrelationFeatureExtractor::new(30, 10);
+        for i in 0..100 {
+            let val = 100.0 + 5.0 * (i as f64 * 0.2).sin();
+            let f = ext.next(val);
+            assert_eq!(f.correlations.len(), 10);
+        }
+    }
+}

quantwave-0.5.1/quantwave-core/src/features/griffiths_dominant_cycle.rs

@@ -0,0 +1,53 @@
+//! Griffiths Dominant Cycle feature extractor wrapper.
+//!
+//! Wraps the Griffiths spectral estimation dominant cycle detector.
+//! Returns the estimated dominant cycle length — a high-value stationary cycle feature for ML.
+//!
+//! Source: quantwave-core/src/indicators/griffiths_dominant_cycle.rs (returns f64 dominant cycle estimate)
+
+use crate::indicators::griffiths_dominant_cycle::GriffithsDominantCycle;
+use crate::traits::Next;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct GriffithsDominantCycleFeatures {
+    pub dominant_cycle: f64,
+}
+
+#[derive(Debug, Clone)]
+pub struct GriffithsDominantCycleFeatureExtractor {
+    inner: GriffithsDominantCycle,
+}
+
+impl GriffithsDominantCycleFeatureExtractor {
+    pub fn new(lower_bound: usize, upper_bound: usize, length: usize) -> Self {
+        Self {
+            inner: GriffithsDominantCycle::new(lower_bound, upper_bound, length),
+        }
+    }
+}
+
+impl Next<f64> for GriffithsDominantCycleFeatureExtractor {
+    type Output = GriffithsDominantCycleFeatures;
+
+    fn next(&mut self, input: f64) -> Self::Output {
+        let dc = self.inner.next(input);
+        GriffithsDominantCycleFeatures { dominant_cycle: dc }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_griffiths_wrapper_basic() {
+        let mut ext = GriffithsDominantCycleFeatureExtractor::new(10, 40, 30);
+        for i in 0..100 {
+            let val = 100.0 + 5.0 * (i as f64 * 0.25).sin();
+            let f = ext.next(val);
+            if !f.dominant_cycle.is_nan() {
+                assert!(f.dominant_cycle > 5.0 && f.dominant_cycle < 50.0);
+            }
+        }
+    }
+}

quantwave-0.5.1/quantwave-core/src/features/hurst.rs

@@ -0,0 +1,108 @@
+//! Hurst Exponent feature extractor wrapper.
+//!
+//! Wraps the existing `HurstExponent` to provide a clean ML feature interface
+//! (persistence value + optional regime classification).
+//!
+//! This is one of the highest-ROI single features for ML/regime work:
+//! - H < 0.5 → mean-reverting (anti-persistent)
+//! - H ≈ 0.5 → random walk
+//! - H > 0.5 → trending (persistent)
+//!
+//! Source: quantwave-core/src/indicators/hurst.rs (Rescaled Range implementation)
+
+use crate::indicators::hurst::HurstExponent;
+use crate::traits::Next;
+
+/// Rich output for Hurst-based features.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct HurstFeatures {
+    pub persistence: f64,
+    /// Optional discrete regime label for convenience in ML pipelines.
+    /// -1 = mean-reverting, 0 = random, +1 = trending (thresholds configurable later).
+    pub regime_label: Option<i8>,
+}
+
+impl HurstFeatures {
+    pub fn new(persistence: f64, regime_label: Option<i8>) -> Self {
+        Self { persistence, regime_label }
+    }
+}
+
+/// Wrapper that turns the existing HurstExponent into a feature-rich extractor.
+#[derive(Debug, Clone)]
+pub struct HurstFeatureExtractor {
+    inner: HurstExponent,
+    /// Thresholds for regime classification (can be made configurable later).
+    mean_reverting_threshold: f64,
+    trending_threshold: f64,
+}
+
+impl HurstFeatureExtractor {
+    pub fn new(period: usize) -> Self {
+        Self {
+            inner: HurstExponent::new(period),
+            mean_reverting_threshold: 0.45,
+            trending_threshold: 0.55,
+        }
+    }
+
+    pub fn with_thresholds(mut self, mean_rev: f64, trending: f64) -> Self {
+        self.mean_reverting_threshold = mean_rev;
+        self.trending_threshold = trending;
+        self
+    }
+}
+
+impl Next<f64> for HurstFeatureExtractor {
+    type Output = HurstFeatures;
+
+    fn next(&mut self, input: f64) -> Self::Output {
+        let persistence = self.inner.next(input);
+
+        let regime_label = if persistence.is_nan() {
+            None
+        } else if persistence < self.mean_reverting_threshold {
+            Some(-1)
+        } else if persistence > self.trending_threshold {
+            Some(1)
+        } else {
+            Some(0)
+        };
+
+        HurstFeatures::new(persistence, regime_label)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use approx::assert_relative_eq;
+
+    #[test]
+    fn test_hurst_feature_basic() {
+        let mut extractor = HurstFeatureExtractor::new(20);
+
+        // Feed trending data
+        for i in 0..30 {
+            let val = 100.0 + (i as f64) * 0.5;
+            let f = extractor.next(val);
+            if !f.persistence.is_nan() {
+                assert!(f.persistence > 0.5, "Expected trending persistence, got {}", f.persistence);
+            }
+        }
+    }
+
+    #[test]
+    fn test_hurst_feature_regime_labels() {
+        let mut extractor = HurstFeatureExtractor::new(10)
+            .with_thresholds(0.4, 0.6);
+
+        // Force a high persistence value via dummy (real impl will vary)
+        // This is a smoke test for the wrapper logic
+        let f = extractor.next(100.0);
+        // After warmup it should produce a label
+        if !f.persistence.is_nan() {
+            assert!(f.regime_label.is_some());
+        }
+    }
+}

quantwave-0.5.1/quantwave-core/src/features/instantaneous_trendline.rs

@@ -0,0 +1,39 @@
+//! Instantaneous Trendline feature extractor wrapper.
+//!
+//! Wraps the zero-lag trendline. For richer ML use we expose the trend value
+//! + a simple derived "trend strength" (placeholder for phase/power in future).
+//!
+//! Source: quantwave-core/src/indicators/instantaneous_trendline.rs (returns f64 trend)
+
+use crate::indicators::instantaneous_trendline::InstantaneousTrendline;
+use crate::traits::Next;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct InstantaneousTrendlineFeatures {
+    pub trend: f64,
+    /// Placeholder for future phase/power derived features (0.0 for now)
+    pub strength: f64,
+}
+
+#[derive(Debug, Clone)]
+pub struct InstantaneousTrendlineFeatureExtractor {
+    inner: InstantaneousTrendline,
+}
+
+impl InstantaneousTrendlineFeatureExtractor {
+    pub fn new() -> Self {
+        Self {
+            inner: InstantaneousTrendline::new(),
+        }
+    }
+}
+
+impl Next<f64> for InstantaneousTrendlineFeatureExtractor {
+    type Output = InstantaneousTrendlineFeatures;
+
+    fn next(&mut self, input: f64) -> Self::Output {
+        let trend = self.inner.next(input);
+        // For MVP, strength is 0.0. Real phase/power can be added later from the indicator internals if exposed.
+        InstantaneousTrendlineFeatures { trend, strength: 0.0 }
+    }
+}