Add v0.8 analytics: indicators, stats, CV, extended metrics

- Technical indicators (RSI, MACD, Bollinger Bands, ATR) replacing ta-lib
- Statistics module (Spearman correlation, quintile spread) replacing scipy
- Time-series cross-validation replacing sklearn
- Extended portfolio metrics (CVaR, win rate, profit factor, payoff ratio, Kelly)
- Rolling Sharpe and rolling volatility
- Python bindings for all new functions
- Property tests and reference tests against numpy/scipy/sklearn

Author: ricardofrantz

python/src/cv.rs

@@ -0,0 +1,28 @@
+use nanobook::cv;
+use pyo3::prelude::*;
+
+/// Expanding-window time series cross-validation splits.
+///
+/// Drop-in replacement for ``sklearn.model_selection.TimeSeriesSplit``.
+///
+/// Args:
+///     n_samples: Total number of observations.
+///     n_splits: Number of folds.
+///
+/// Returns:
+///     List of (train_indices, test_indices) tuples.
+///
+/// Example::
+///
+///     for train_idx, test_idx in nanobook.py_time_series_split(100, 5):
+///         train_data = data[train_idx]
+///         test_data = data[test_idx]
+///
+#[pyfunction]
+#[pyo3(signature = (n_samples, n_splits=5))]
+pub fn py_time_series_split(
+    n_samples: usize,
+    n_splits: usize,
+) -> Vec<(Vec<usize>, Vec<usize>)> {
+    cv::time_series_split(n_samples, n_splits)
+}

python/src/indicators.rs

@@ -0,0 +1,102 @@
+use nanobook::indicators;
+use pyo3::prelude::*;
+
+/// Compute RSI (Relative Strength Index) using Wilder's smoothing.
+///
+/// Drop-in replacement for ``talib.RSI(close, timeperiod)``.
+///
+/// Args:
+///     close: List of closing prices.
+///     period: Lookback period (default 14).
+///
+/// Returns:
+///     List of RSI values. NaN for the lookback period.
+///
+/// Example::
+///
+///     rsi = nanobook.py_rsi([44.0, 44.25, 44.5, ...], 14)
+///
+#[pyfunction]
+#[pyo3(signature = (close, period=14))]
+pub fn py_rsi(close: Vec<f64>, period: usize) -> Vec<f64> {
+    indicators::rsi(&close, period)
+}
+
+/// Compute MACD (Moving Average Convergence Divergence).
+///
+/// Drop-in replacement for ``talib.MACD(close, fast, slow, signal)``.
+///
+/// Args:
+///     close: List of closing prices.
+///     fast_period: Fast EMA period (default 12).
+///     slow_period: Slow EMA period (default 26).
+///     signal_period: Signal line EMA period (default 9).
+///
+/// Returns:
+///     Tuple of (macd_line, signal_line, histogram).
+///
+/// Example::
+///
+///     macd, signal, hist = nanobook.py_macd(closes, 12, 26, 9)
+///
+#[pyfunction]
+#[pyo3(signature = (close, fast_period=12, slow_period=26, signal_period=9))]
+pub fn py_macd(
+    close: Vec<f64>,
+    fast_period: usize,
+    slow_period: usize,
+    signal_period: usize,
+) -> (Vec<f64>, Vec<f64>, Vec<f64>) {
+    indicators::macd(&close, fast_period, slow_period, signal_period)
+}
+
+/// Compute Bollinger Bands (SMA +/- k * standard deviation).
+///
+/// Drop-in replacement for ``talib.BBANDS(close, period, nbdevup, nbdevdn)``.
+///
+/// Args:
+///     close: List of closing prices.
+///     period: SMA/stddev period (default 20).
+///     num_std_up: Standard deviations above SMA (default 2.0).
+///     num_std_dn: Standard deviations below SMA (default 2.0).
+///
+/// Returns:
+///     Tuple of (upper_band, middle_band, lower_band).
+///
+/// Example::
+///
+///     upper, middle, lower = nanobook.py_bbands(closes, 20, 2.0, 2.0)
+///
+#[pyfunction]
+#[pyo3(signature = (close, period=20, num_std_up=2.0, num_std_dn=2.0))]
+pub fn py_bbands(
+    close: Vec<f64>,
+    period: usize,
+    num_std_up: f64,
+    num_std_dn: f64,
+) -> (Vec<f64>, Vec<f64>, Vec<f64>) {
+    indicators::bbands(&close, period, num_std_up, num_std_dn)
+}
+
+/// Compute ATR (Average True Range) using Wilder's smoothing.
+///
+/// Drop-in replacement for ``talib.ATR(high, low, close, timeperiod)``.
+///
+/// Args:
+///     high: List of high prices.
+///     low: List of low prices.
+///     close: List of closing prices.
+///     period: Lookback period (default 14).
+///
+/// Returns:
+///     List of ATR values. NaN for the lookback period.
+///
+/// Example::
+///
+///     atr = nanobook.py_atr(highs, lows, closes, 14)
+///
+#[pyfunction]
+#[pyo3(signature = (high, low, close, period=14))]
+pub fn py_atr(high: Vec<f64>, low: Vec<f64>, close: Vec<f64>, period: usize) -> Vec<f64> {
+    indicators::atr(&high, &low, &close, period)
+}

python/src/lib.rs

@@ -1,7 +1,9 @@
 mod backtest_bridge;
 mod broker;
+mod cv;
 mod event;
 mod exchange;
+mod indicators;
 #[cfg(feature = "itch")]
 mod itch;
 mod metrics;
@@ -11,6 +13,7 @@ mod portfolio;
 mod position;
 mod results;
 mod risk;
+mod stats;
 mod strategy;
 mod sweep;
 mod types;
@@ -21,7 +24,7 @@ use pyo3::prelude::*;
 /// and matching engine for testing trading algorithms.
 #[pymodule]
 fn nanobook(m: &Bound<'_, PyModule>) -> PyResult<()> {
-    m.add("__version__", "0.7.0")?;
+    m.add("__version__", "0.8.0")?;
 
     // Broker types
     m.add_class::<broker::PyIbkrBroker>()?;
@@ -52,13 +55,30 @@ fn nanobook(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<position::PyPosition>()?;
     m.add_class::<metrics::PyMetrics>()?;
 
-    // Functions
+    // v0.7 functions
     m.add_function(wrap_pyfunction!(metrics::py_compute_metrics, m)?)?;
     m.add_function(wrap_pyfunction!(sweep::py_sweep_equal_weight, m)?)?;
     m.add_function(wrap_pyfunction!(strategy::py_run_backtest, m)?)?;
     m.add_function(wrap_pyfunction!(backtest_bridge::py_backtest_weights, m)?)?;
     #[cfg(feature = "itch")]
     m.add_function(wrap_pyfunction!(itch::parse_itch, m)?)?;
 
+    // v0.8 — Technical indicators (ta-lib replacements)
+    m.add_function(wrap_pyfunction!(indicators::py_rsi, m)?)?;
+    m.add_function(wrap_pyfunction!(indicators::py_macd, m)?)?;
+    m.add_function(wrap_pyfunction!(indicators::py_bbands, m)?)?;
+    m.add_function(wrap_pyfunction!(indicators::py_atr, m)?)?;
+
+    // v0.8 — Statistics (scipy replacements)
+    m.add_function(wrap_pyfunction!(stats::py_spearman, m)?)?;
+    m.add_function(wrap_pyfunction!(stats::py_quintile_spread, m)?)?;
+
+    // v0.8 — Cross-validation (sklearn replacement)
+    m.add_function(wrap_pyfunction!(cv::py_time_series_split, m)?)?;
+
+    // v0.8 — Rolling metrics (quantstats replacements)
+    m.add_function(wrap_pyfunction!(metrics::py_rolling_sharpe, m)?)?;
+    m.add_function(wrap_pyfunction!(metrics::py_rolling_volatility, m)?)?;
+
     Ok(())
 }

python/src/metrics.rs

@@ -1,4 +1,4 @@
-use nanobook::portfolio::{Metrics, compute_metrics};
+use nanobook::portfolio::metrics::{compute_metrics, rolling_sharpe, rolling_volatility, Metrics};
 use pyo3::prelude::*;
 
 /// Performance metrics for a return series.
@@ -25,16 +25,29 @@ pub struct PyMetrics {
     pub winning_periods: usize,
     #[pyo3(get)]
     pub losing_periods: usize,
+
+    // v0.8 extended metrics
+    #[pyo3(get)]
+    pub cvar_95: f64,
+    #[pyo3(get)]
+    pub win_rate: f64,
+    #[pyo3(get)]
+    pub profit_factor: f64,
+    #[pyo3(get)]
+    pub payoff_ratio: f64,
+    #[pyo3(get)]
+    pub kelly: f64,
 }
 
 #[pymethods]
 impl PyMetrics {
     fn __repr__(&self) -> String {
         format!(
-            "Metrics(total_return={:.2}%, sharpe={:.2}, max_drawdown={:.2}%)",
+            "Metrics(total_return={:.2}%, sharpe={:.2}, max_drawdown={:.2}%, win_rate={:.1}%)",
             self.total_return * 100.0,
             self.sharpe,
             self.max_drawdown * 100.0,
+            self.win_rate * 100.0,
         )
     }
 }
@@ -52,6 +65,11 @@ impl From<Metrics> for PyMetrics {
             num_periods: m.num_periods,
             winning_periods: m.winning_periods,
             losing_periods: m.losing_periods,
+            cvar_95: m.cvar_95,
+            win_rate: m.win_rate,
+            profit_factor: m.profit_factor,
+            payoff_ratio: m.payoff_ratio,
+            kelly: m.kelly,
         }
     }
 }
@@ -68,8 +86,8 @@ impl From<Metrics> for PyMetrics {
 ///
 /// Example::
 ///
-///     m = compute_metrics([0.01, -0.005, 0.02], 252.0, 0.0)
-///     print(m.sharpe)
+///     m = nanobook.py_compute_metrics([0.01, -0.005, 0.02], 252.0, 0.0)
+///     print(m.sharpe, m.cvar_95, m.kelly)
 ///
 #[pyfunction]
 #[pyo3(signature = (returns, periods_per_year=252.0, risk_free=0.0))]
@@ -80,3 +98,47 @@ pub fn py_compute_metrics(
 ) -> Option<PyMetrics> {
     compute_metrics(&returns, periods_per_year, risk_free).map(PyMetrics::from)
 }
+
+/// Compute rolling Sharpe ratio over a sliding window.
+///
+/// Args:
+///     returns: List of periodic returns.
+///     window: Window size (e.g., 63 for quarterly).
+///     periods_per_year: Annualization factor (default 252).
+///
+/// Returns:
+///     List of rolling Sharpe values. NaN for incomplete windows.
+///
+/// Example::
+///
+///     rolling = nanobook.py_rolling_sharpe(daily_returns, 63, 252)
+///
+#[pyfunction]
+#[pyo3(signature = (returns, window, periods_per_year=252))]
+pub fn py_rolling_sharpe(returns: Vec<f64>, window: usize, periods_per_year: usize) -> Vec<f64> {
+    rolling_sharpe(&returns, window, periods_per_year)
+}
+
+/// Compute rolling annualized volatility over a sliding window.
+///
+/// Args:
+///     returns: List of periodic returns.
+///     window: Window size (e.g., 63 for quarterly).
+///     periods_per_year: Annualization factor (default 252).
+///
+/// Returns:
+///     List of rolling volatility values. NaN for incomplete windows.
+///
+/// Example::
+///
+///     rolling = nanobook.py_rolling_volatility(daily_returns, 63, 252)
+///
+#[pyfunction]
+#[pyo3(signature = (returns, window, periods_per_year=252))]
+pub fn py_rolling_volatility(
+    returns: Vec<f64>,
+    window: usize,
+    periods_per_year: usize,
+) -> Vec<f64> {
+    rolling_volatility(&returns, window, periods_per_year)
+}

python/src/stats.rs

@@ -0,0 +1,46 @@
+use nanobook::stats;
+use pyo3::prelude::*;
+
+/// Compute Spearman rank correlation with two-tailed p-value.
+///
+/// Drop-in replacement for ``scipy.stats.spearmanr(x, y)``.
+/// Uses average-rank tie-breaking, matching scipy's default.
+///
+/// Args:
+///     x: First variable (list of floats).
+///     y: Second variable (list of floats, same length as x).
+///
+/// Returns:
+///     Tuple of (correlation, p_value). Returns (NaN, NaN) if len < 3.
+///
+/// Example::
+///
+///     corr, p = nanobook.py_spearman(scores, returns)
+///
+#[pyfunction]
+pub fn py_spearman(x: Vec<f64>, y: Vec<f64>) -> (f64, f64) {
+    stats::spearman(&x, &y)
+}
+
+/// Compute quintile spread (top quintile mean - bottom quintile mean).
+///
+/// Sorts by ``scores``, splits into ``n_quantiles`` groups, returns the
+/// difference between the top group's mean return and the bottom group's.
+///
+/// Args:
+///     scores: Factor scores (list of floats).
+///     returns: Realized returns (list of floats, same length as scores).
+///     n_quantiles: Number of groups (default 5).
+///
+/// Returns:
+///     Float: top_mean - bottom_mean. NaN if inputs are invalid.
+///
+/// Example::
+///
+///     spread = nanobook.py_quintile_spread(scores, returns, 5)
+///
+#[pyfunction]
+#[pyo3(signature = (scores, returns, n_quantiles=5))]
+pub fn py_quintile_spread(scores: Vec<f64>, returns: Vec<f64>, n_quantiles: usize) -> f64 {
+    stats::quintile_spread(&scores, &returns, n_quantiles)
+}