@ebowwa/quant-rust 0.1.0

package/src/indicators/volatility.rs

@@ -0,0 +1,270 @@
+//! Volatility Indicators
+//!
+//! Indicators that measure the rate and magnitude of price changes.
+
+use crate::utils::{mean, rolling};
+
+/// Average True Range (ATR) result
+#[derive(Debug, Clone, PartialEq)]
+pub struct ATRResult {
+    /// ATR values (smoothed TR)
+    pub atr: Vec<f64>,
+    /// True Range values
+    pub tr: Vec<f64>,
+}
+
+/// Bollinger Bands result
+#[derive(Debug, Clone, PartialEq)]
+pub struct BollingerBandsResult {
+    /// Upper band (middle + std_dev * multiplier)
+    pub upper: Vec<f64>,
+    /// Middle band (SMA)
+    pub middle: Vec<f64>,
+    /// Lower band (middle - std_dev * multiplier)
+    pub lower: Vec<f64>,
+    /// Bandwidth ((upper - lower) / middle * 100)
+    pub bandwidth: Vec<f64>,
+    /// %B (position within bands: (price - lower) / (upper - lower))
+    pub percent_b: Vec<f64>,
+}
+
+/// Keltner Channels result
+#[derive(Debug, Clone, PartialEq)]
+pub struct KeltnerChannelsResult {
+    /// Upper channel
+    pub upper: Vec<f64>,
+    /// Middle channel (EMA)
+    pub middle: Vec<f64>,
+    /// Lower channel
+    pub lower: Vec<f64>,
+}
+
+/// Average True Range (ATR)
+///
+/// Measures market volatility by decomposing the entire range
+/// of an asset price for a period.
+///
+/// True Range = max(H-L, |H-PrevC|, |L-PrevC|)
+/// ATR = EMA of True Range
+///
+/// # Arguments
+/// * `high` - High prices
+/// * `low` - Low prices
+/// * `close` - Close prices
+/// * `period` - ATR period (default: 14)
+///
+/// # Returns
+/// An ATRResult containing ATR and True Range values.
+pub fn atr(high: &[f64], low: &[f64], close: &[f64], period: usize) -> ATRResult {
+    if high.len() < 2 || period == 0 {
+        return ATRResult {
+            atr: Vec::new(),
+            tr: Vec::new(),
+        };
+    }
+
+    // Calculate True Range
+    let mut tr: Vec<f64> = vec![high[0] - low[0]]; // First TR is just H-L
+
+    for i in 1..high.len() {
+        let hl = high[i] - low[i];
+        let hpc = (high[i] - close[i - 1]).abs();
+        let lpc = (low[i] - close[i - 1]).abs();
+        tr.push(hl.max(hpc).max(lpc));
+    }
+
+    // Calculate ATR using EMA
+    let atr_values = super::ema(&tr, period);
+
+    ATRResult { atr: atr_values, tr }
+}
+
+/// Bollinger Bands
+///
+/// A volatility indicator consisting of a middle band (SMA)
+/// and two outer bands (standard deviations away).
+///
+/// # Arguments
+/// * `data` - Price data slice
+/// * `period` - SMA period (default: 20)
+/// * `std_dev_mult` - Standard deviation multiplier (default: 2.0)
+///
+/// # Returns
+/// A BollingerBandsResult containing upper, middle, lower bands, bandwidth, and %B.
+pub fn bollinger_bands(data: &[f64], period: usize, std_dev_mult: f64) -> BollingerBandsResult {
+    if data.len() < period || period == 0 {
+        return BollingerBandsResult {
+            upper: Vec::new(),
+            middle: Vec::new(),
+            lower: Vec::new(),
+            bandwidth: Vec::new(),
+            percent_b: Vec::new(),
+        };
+    }
+
+    let middle = super::sma(data, period);
+
+    // Calculate rolling standard deviation
+    let std_devs: Vec<f64> = rolling(data, period, |slice| {
+        let avg = mean(slice);
+        let variance: f64 = slice.iter().map(|v| (v - avg).powi(2)).sum::<f64>()
+            / (slice.len() - 1) as f64;
+        variance.sqrt()
+    });
+
+    let mut upper: Vec<f64> = Vec::new();
+    let mut lower: Vec<f64> = Vec::new();
+    let mut bandwidth: Vec<f64> = Vec::new();
+    let mut percent_b: Vec<f64> = Vec::new();
+
+    for i in 0..middle.len() {
+        let mid = middle[i];
+        let sd = std_devs[i];
+        let up = mid + std_dev_mult * sd;
+        let low = mid - std_dev_mult * sd;
+
+        upper.push(up);
+        lower.push(low);
+        bandwidth.push(if mid > 0.0 { ((up - low) / mid) * 100.0 } else { 0.0 });
+
+        // Percent B: where is price relative to bands
+        let price_index = data.len() - middle.len() + i;
+        if (up - low).abs() > 1e-10 {
+            percent_b.push((data[price_index] - low) / (up - low));
+        } else {
+            percent_b.push(0.5);
+        }
+    }
+
+    BollingerBandsResult {
+        upper,
+        middle,
+        lower,
+        bandwidth,
+        percent_b,
+    }
+}
+
+/// Keltner Channels
+///
+/// A volatility-based envelope using ATR above and below an EMA.
+///
+/// # Arguments
+/// * `high` - High prices
+/// * `low` - Low prices
+/// * `close` - Close prices
+/// * `ema_period` - EMA period (default: 20)
+/// * `atr_period` - ATR period (default: 10)
+/// * `mult` - ATR multiplier (default: 2.0)
+///
+/// # Returns
+/// A KeltnerChannelsResult containing upper, middle, and lower channels.
+pub fn keltner_channels(
+    high: &[f64],
+    low: &[f64],
+    close: &[f64],
+    ema_period: usize,
+    atr_period: usize,
+    mult: f64,
+) -> KeltnerChannelsResult {
+    if close.len() < ema_period.max(atr_period) || ema_period == 0 || atr_period == 0 {
+        return KeltnerChannelsResult {
+            upper: Vec::new(),
+            middle: Vec::new(),
+            lower: Vec::new(),
+        };
+    }
+
+    let middle = super::ema(close, ema_period);
+    let atr_result = atr(high, low, close, atr_period);
+    let atr_values = atr_result.atr;
+
+    // Align ATR with EMA
+    let atr_offset = close.len() - atr_values.len();
+    let ema_offset = close.len() - middle.len();
+
+    let upper: Vec<f64> = middle
+        .iter()
+        .enumerate()
+        .filter_map(|(i, &mid)| {
+            let atr_idx = i + (ema_offset - atr_offset);
+            if atr_idx < atr_values.len() {
+                Some(mid + mult * atr_values[atr_idx])
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    let lower: Vec<f64> = middle
+        .iter()
+        .enumerate()
+        .filter_map(|(i, &mid)| {
+            let atr_idx = i + (ema_offset - atr_offset);
+            if atr_idx < atr_values.len() {
+                Some(mid - mult * atr_values[atr_idx])
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    // Ensure all three arrays have the same length
+    let min_len = upper.len().min(lower.len());
+
+    KeltnerChannelsResult {
+        upper: upper[..min_len].to_vec(),
+        middle: middle[..min_len].to_vec(),
+        lower: lower[..min_len].to_vec(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_atr() {
+        let high = vec![10.0, 12.0, 14.0, 16.0, 18.0];
+        let low = vec![8.0, 10.0, 11.0, 13.0, 15.0];
+        let close = vec![9.0, 11.0, 13.0, 15.0, 17.0];
+
+        let result = atr(&high, &low, &close, 3);
+        assert!(!result.tr.is_empty());
+        assert!(!result.atr.is_empty());
+
+        // First TR should be high[0] - low[0]
+        assert!((result.tr[0] - 2.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_bollinger_bands() {
+        let prices: Vec<f64> = (1..=30).map(|x| x as f64).collect();
+        let result = bollinger_bands(&prices, 20, 2.0);
+
+        assert!(!result.upper.is_empty());
+        assert!(!result.middle.is_empty());
+        assert!(!result.lower.is_empty());
+
+        // Upper should be above middle, lower should be below
+        for i in 0..result.middle.len() {
+            assert!(result.upper[i] > result.middle[i]);
+            assert!(result.lower[i] < result.middle[i]);
+        }
+    }
+
+    #[test]
+    fn test_keltner_channels() {
+        let high = vec![10.0, 12.0, 15.0, 14.0, 16.0, 18.0, 17.0, 19.0, 21.0, 20.0,
+                        22.0, 24.0, 23.0, 25.0, 27.0, 26.0, 28.0, 30.0, 29.0, 31.0];
+        let low = vec![8.0, 9.0, 11.0, 10.0, 12.0, 14.0, 13.0, 15.0, 17.0, 16.0,
+                       18.0, 20.0, 19.0, 21.0, 23.0, 22.0, 24.0, 26.0, 25.0, 27.0];
+        let close = vec![9.0, 11.0, 14.0, 12.0, 15.0, 17.0, 15.0, 18.0, 20.0, 18.0,
+                         21.0, 23.0, 21.0, 24.0, 26.0, 24.0, 27.0, 29.0, 27.0, 30.0];
+
+        let result = keltner_channels(&high, &low, &close, 10, 10, 2.0);
+        assert!(!result.upper.is_empty());
+        assert!(!result.middle.is_empty());
+        assert!(!result.lower.is_empty());
+    }
+}

package/src/indicators/volume.rs

@@ -0,0 +1,213 @@
+//! Volume Indicators
+//!
+//! Indicators based on trading volume analysis.
+
+use crate::utils::{max, min};
+
+/// On-Balance Volume (OBV)
+///
+/// A cumulative indicator that adds volume on up days and subtracts
+/// volume on down days, used to detect divergences with price.
+///
+/// # Arguments
+/// * `close` - Close prices
+/// * `volume` - Volume data
+///
+/// # Returns
+/// A vector of OBV values.
+pub fn obv(close: &[f64], volume: &[f64]) -> Vec<f64> {
+    if close.len() < 2 || volume.len() < 2 {
+        return Vec::new();
+    }
+
+    let mut result: Vec<f64> = vec![0.0];
+
+    for i in 1..close.len().min(volume.len()) {
+        if close[i] > close[i - 1] {
+            result.push(result[i - 1] + volume[i]);
+        } else if close[i] < close[i - 1] {
+            result.push(result[i - 1] - volume[i]);
+        } else {
+            result.push(result[i - 1]);
+        }
+    }
+
+    result
+}
+
+/// Money Flow Index (MFI)
+///
+/// A momentum indicator using price and volume to identify
+/// overbought/oversold conditions. Also known as Volume RSI.
+///
+/// # Arguments
+/// * `high` - High prices
+/// * `low` - Low prices
+/// * `close` - Close prices
+/// * `volume` - Volume data
+/// * `period` - MFI period (default: 14)
+///
+/// # Returns
+/// A vector of MFI values (0-100).
+pub fn mfi(
+    high: &[f64],
+    low: &[f64],
+    close: &[f64],
+    volume: &[f64],
+    period: usize,
+) -> Vec<f64> {
+    if close.len() < period + 1 || period == 0 {
+        return Vec::new();
+    }
+
+    // Calculate typical prices and money flows
+    let typical_prices: Vec<f64> = close
+        .iter()
+        .enumerate()
+        .map(|(i, &c)| (high[i] + low[i] + c) / 3.0)
+        .collect();
+
+    let money_flows: Vec<f64> = typical_prices
+        .iter()
+        .enumerate()
+        .map(|(i, &tp)| tp * volume[i])
+        .collect();
+
+    let mut result: Vec<f64> = Vec::new();
+
+    for i in period..close.len() {
+        let mut positive_flow = 0.0;
+        let mut negative_flow = 0.0;
+
+        for j in (i + 1 - period)..=i {
+            if typical_prices[j] > typical_prices[j - 1] {
+                positive_flow += money_flows[j];
+            } else {
+                negative_flow += money_flows[j];
+            }
+        }
+
+        if negative_flow == 0.0 {
+            result.push(100.0);
+        } else {
+            let mf_ratio = positive_flow / negative_flow;
+            result.push(100.0 - 100.0 / (1.0 + mf_ratio));
+        }
+    }
+
+    result
+}
+
+/// Volume Profile
+///
+/// Analyzes trading activity at specific price levels to identify
+/// areas of high volume (support/resistance zones).
+///
+/// # Arguments
+/// * `high` - High prices
+/// * `low` - Low prices
+/// * `close` - Close prices
+/// * `volume` - Volume data
+/// * `levels` - Number of price levels to analyze
+///
+/// # Returns
+/// A vector of (price_level, volume) tuples.
+pub fn volume_profile(
+    high: &[f64],
+    low: &[f64],
+    close: &[f64],
+    volume: &[f64],
+    levels: usize,
+) -> Vec<(f64, f64)> {
+    if high.is_empty() || low.is_empty() || levels == 0 {
+        return Vec::new();
+    }
+
+    let max_high = max(high);
+    let min_low = min(low);
+
+    if max_high.is_nan() || min_low.is_nan() {
+        return Vec::new();
+    }
+
+    let price_range = max_high - min_low;
+    let level_size = price_range / levels as f64;
+
+    // Initialize price levels with zero volume
+    let mut profile: Vec<(f64, f64)> = (0..=levels)
+        .map(|i| (min_low + i as f64 * level_size, 0.0))
+        .collect();
+
+    // Distribute volume across price levels
+    for i in 0..close.len().min(high.len()).min(low.len()).min(volume.len()) {
+        let h = high[i];
+        let l = low[i];
+        let v = volume[i];
+        let range = h - l;
+
+        if range > 0.0 {
+            // Distribute volume proportionally across levels within the candle's range
+            for (level, vol) in profile.iter_mut() {
+                if *level >= l && *level <= h {
+                    *vol += v / levels as f64;
+                }
+            }
+        }
+    }
+
+    profile
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_obv() {
+        let close = vec![10.0, 11.0, 10.5, 12.0, 11.5];
+        let volume = vec![100.0, 150.0, 120.0, 200.0, 180.0];
+
+        let result = obv(&close, &volume);
+
+        assert_eq!(result.len(), 5);
+        assert_eq!(result[0], 0.0); // Starting point
+        assert_eq!(result[1], 150.0); // Up day: +150
+        assert_eq!(result[2], 30.0); // Down day: 150 - 120
+        assert_eq!(result[3], 230.0); // Up day: 30 + 200
+        assert_eq!(result[4], 50.0); // Down day: 230 - 180
+    }
+
+    #[test]
+    fn test_mfi() {
+        let high = vec![10.0, 12.0, 14.0, 16.0, 18.0, 17.0, 19.0, 21.0, 20.0, 22.0,
+                        24.0, 23.0, 25.0, 27.0, 26.0, 28.0, 30.0, 29.0, 31.0, 33.0];
+        let low = vec![8.0, 9.0, 11.0, 13.0, 15.0, 14.0, 16.0, 18.0, 17.0, 19.0,
+                       21.0, 20.0, 22.0, 24.0, 23.0, 25.0, 27.0, 26.0, 28.0, 30.0];
+        let close = vec![9.0, 11.0, 13.0, 15.0, 17.0, 15.0, 18.0, 20.0, 18.0, 21.0,
+                         23.0, 21.0, 24.0, 26.0, 24.0, 27.0, 29.0, 27.0, 30.0, 32.0];
+        let volume = vec![100.0, 150.0, 120.0, 200.0, 180.0, 160.0, 220.0, 190.0, 170.0, 240.0,
+                          210.0, 180.0, 260.0, 230.0, 200.0, 280.0, 250.0, 220.0, 300.0, 270.0];
+
+        let result = mfi(&high, &low, &close, &volume, 14);
+
+        assert!(!result.is_empty());
+        // MFI should be between 0 and 100
+        for &val in &result {
+            assert!(val >= 0.0 && val <= 100.0);
+        }
+    }
+
+    #[test]
+    fn test_volume_profile() {
+        let high = vec![10.0, 12.0, 14.0];
+        let low = vec![8.0, 10.0, 12.0];
+        let close = vec![9.0, 11.0, 13.0];
+        let volume = vec![100.0, 150.0, 120.0];
+
+        let result = volume_profile(&high, &low, &close, &volume, 5);
+
+        assert!(!result.is_empty());
+        // Should have 6 levels (0 to 5 inclusive)
+        assert_eq!(result.len(), 6);
+    }
+}

package/src/lib.rs

@@ -0,0 +1,130 @@
+//! # Quant Rust - High-Performance Quantitative Finance Library
+//!
+//! A Rust library providing quantitative finance computations with FFI bindings for Bun/TypeScript.
+//!
+//! ## Modules
+//! - `prediction`: Prediction market calculations (AMM, LMSR, Kelly criterion)
+//! - `indicators`: Technical indicators (RSI, MACD, Bollinger Bands, etc.)
+//! - `risk`: Risk management (VaR, CVaR, Sharpe ratio, etc.)
+//! - `stats`: Statistical analysis (correlation, regression, distributions)
+//! - `patterns`: Pattern recognition (candlestick, chart patterns, support/resistance)
+//! - `utils`: Utility functions and helpers
+
+pub mod types;
+pub mod ffi;
+pub mod utils;
+
+#[cfg(feature = "prediction")]
+pub mod prediction;
+
+#[cfg(feature = "indicators")]
+pub mod indicators;
+
+#[cfg(feature = "risk")]
+pub mod risk;
+
+#[cfg(feature = "stats")]
+pub mod stats;
+
+#[cfg(feature = "patterns")]
+pub mod patterns;
+
+// Re-export types first (these are the primary definitions)
+pub use types::{OHLCV, Signal, IndicatorResult, CandlePattern, PatternResult};
+
+// Re-export utils
+pub use utils::{sum, mean, median, variance, std_dev, min, max, rolling, round_to, clamp};
+
+#[cfg(feature = "prediction")]
+pub use prediction::{
+    Outcome,
+    odds::*,
+    kelly::KellyResult,
+    amm::AMMState,
+    lmsr::LMSRState,
+};
+
+#[cfg(feature = "indicators")]
+pub use indicators::*;
+
+#[cfg(feature = "risk")]
+pub use risk::{VaRResult, DrawdownResult, SharpeResult, calculate_var, calculate_drawdown, calculate_sharpe_ratio, calculate_sortino_ratio, calculate_beta_alpha};
+
+#[cfg(feature = "stats")]
+pub use stats::{
+    // Types
+    RegressionResult,
+    MultipleRegressionResult,
+    DistributionStats,
+    Moments,
+    CorrelationResult,
+    RollingStats,
+    RollingRegressionResult,
+    TTestResult,
+    ADFResult,
+    AutocorrelationResult,
+    DoubleExponentialResult,
+    TripleExponentialResult,
+    // Correlation functions
+    correlation,
+    covariance,
+    pearson_correlation,
+    spearman_correlation,
+    correlation_with_p_value,
+    correlation_matrix,
+    // Regression functions
+    linear_regression,
+    multiple_regression,
+    // Distribution functions
+    distribution_stats,
+    moments,
+    distribution_statistics,
+    // Rolling statistics
+    rolling_stats,
+    rolling_correlation,
+    rolling_regression,
+    rolling_z_score,
+    // Hypothesis testing
+    one_sample_t_test,
+    two_sample_t_test,
+    adf_test,
+    // Distribution functions (CDF)
+    normal_cdf,
+    t_cdf,
+    gamma,
+    beta,
+    incomplete_beta,
+    // Time series
+    autocorrelation,
+    partial_autocorrelation,
+    exponential_smoothing,
+    double_exponential_smoothing,
+    triple_exponential_smoothing,
+    // Matrix operations
+    transpose,
+    matrix_multiply,
+    matrix_vector_multiply,
+    matrix_inverse,
+    determinant,
+    solve_linear_system,
+    percentile,
+};
+
+#[cfg(feature = "patterns")]
+pub use patterns::{
+    // Config and candlestick detection
+    PatternConfig, detect_patterns,
+    // Support/Resistance
+    find_support_resistance, find_trend_lines,
+    SupportResistanceLevel, LevelType, TrendLine,
+    // Chart patterns
+    detect_all_patterns, detect_double_top, detect_double_bottom,
+    detect_head_and_shoulders, detect_inverse_head_and_shoulders,
+    detect_triangles, detect_gaps, detect_channels,
+    PatternMatch, PatternType, PatternDirection,
+    // Breakouts
+    detect_breakouts, detect_breakouts_from_levels,
+    detect_all_time_high_breakouts, detect_all_time_low_breakouts,
+    detect_consolidation_breakouts,
+    Breakout, BreakoutDirection,
+};