@ebowwa/quant-rust 0.1.0

package/src/stats/timeseries.rs

@@ -0,0 +1,263 @@
+//! Time Series Analysis Module
+//!
+//! Autocorrelation, partial autocorrelation, and exponential smoothing
+
+use crate::utils::mean;
+
+/// Calculate autocorrelation function (ACF)
+pub fn autocorrelation(data: &[f64], max_lag: usize) -> Vec<f64> {
+    if data.is_empty() || max_lag == 0 {
+        return Vec::new();
+    }
+
+    let n = data.len();
+    let avg = mean(data);
+    let variance_val: f64 = data.iter()
+        .map(|x| (x - avg).powi(2))
+        .sum::<f64>() / n as f64;
+
+    if variance_val == 0.0 {
+        return vec![0.0; max_lag + 1];
+    }
+
+    let max_lag = max_lag.min(n - 1);
+    let mut acf = Vec::with_capacity(max_lag + 1);
+
+    for lag in 0..=max_lag {
+        if lag == 0 {
+            acf.push(1.0);
+        } else {
+            let mut sum = 0.0;
+            for i in 0..(n - lag) {
+                sum += (data[i] - avg) * (data[i + lag] - avg);
+            }
+            acf.push(sum / ((n - lag) as f64 * variance_val));
+        }
+    }
+
+    acf
+}
+
+/// Calculate partial autocorrelation function (PACF)
+/// Using Levinson-Durbin recursion
+pub fn partial_autocorrelation(data: &[f64], max_lag: usize) -> Vec<f64> {
+    if data.is_empty() || max_lag == 0 {
+        return Vec::new();
+    }
+
+    let acf = autocorrelation(data, max_lag);
+    if acf.is_empty() {
+        return Vec::new();
+    }
+
+    let mut pacf = vec![acf[0]]; // Lag 0 is always 1
+
+    // Levinson-Durbin recursion for lags 1 to max_lag
+    for k in 1..=max_lag.min(acf.len() - 1) {
+        // Simplified Yule-Walker approach
+        let mut phi = acf[k];
+        for j in 1..k {
+            if j - 1 < pacf.len() {
+                phi -= pacf[j] * acf[k - j];
+            }
+        }
+        pacf.push(phi);
+    }
+
+    pacf
+}
+
+/// Simple exponential smoothing (SES)
+pub fn exponential_smoothing(data: &[f64], alpha: f64) -> Vec<f64> {
+    if data.is_empty() {
+        return Vec::new();
+    }
+
+    let alpha = alpha.clamp(0.0, 1.0);
+    let mut result = Vec::with_capacity(data.len());
+    result.push(data[0]);
+
+    for i in 1..data.len() {
+        let smoothed = alpha * data[i] + (1.0 - alpha) * result[i - 1];
+        result.push(smoothed);
+    }
+
+    result
+}
+
+/// Double exponential smoothing (Holt's method)
+pub fn double_exponential_smoothing(
+    data: &[f64],
+    alpha: f64,
+    beta: f64,
+) -> DoubleExponentialResult {
+    if data.len() < 2 {
+        return DoubleExponentialResult {
+            level: Vec::new(),
+            trend: Vec::new(),
+            forecast: Vec::new(),
+        };
+    }
+
+    let alpha = alpha.clamp(0.0, 1.0);
+    let beta = beta.clamp(0.0, 1.0);
+
+    let mut level = Vec::with_capacity(data.len());
+    let mut trend = Vec::with_capacity(data.len());
+    let mut forecast = Vec::with_capacity(data.len());
+
+    // Initial values
+    level.push(data[0]);
+    trend.push(data[1] - data[0]);
+    forecast.push(data[0]);
+
+    for i in 1..data.len() {
+        let new_level = alpha * data[i] + (1.0 - alpha) * (level[i - 1] + trend[i - 1]);
+        let new_trend = beta * (new_level - level[i - 1]) + (1.0 - beta) * trend[i - 1];
+
+        level.push(new_level);
+        trend.push(new_trend);
+        forecast.push(new_level + new_trend);
+    }
+
+    DoubleExponentialResult {
+        level,
+        trend,
+        forecast,
+    }
+}
+
+/// Double exponential smoothing result
+#[derive(Debug, Clone)]
+pub struct DoubleExponentialResult {
+    /// Level component
+    pub level: Vec<f64>,
+    /// Trend component
+    pub trend: Vec<f64>,
+    /// Forecast (level + trend)
+    pub forecast: Vec<f64>,
+}
+
+/// Triple exponential smoothing (Holt-Winters)
+pub fn triple_exponential_smoothing(
+    data: &[f64],
+    alpha: f64,
+    beta: f64,
+    gamma: f64,
+    period: usize,
+) -> TripleExponentialResult {
+    if data.len() < period * 2 {
+        return TripleExponentialResult {
+            level: Vec::new(),
+            trend: Vec::new(),
+            seasonal: Vec::new(),
+            forecast: Vec::new(),
+        };
+    }
+
+    let alpha = alpha.clamp(0.0, 1.0);
+    let beta = beta.clamp(0.0, 1.0);
+    let gamma = gamma.clamp(0.0, 1.0);
+
+    let n = data.len();
+    let mut level = vec![0.0; n];
+    let mut trend = vec![0.0; n];
+    let mut seasonal = vec![0.0; n + period];
+    let mut forecast = vec![0.0; n];
+
+    // Initialize seasonal factors
+    let mut sum_seasonal = 0.0;
+    for i in 0..period {
+        seasonal[i] = data[i];
+        sum_seasonal += data[i];
+    }
+    let avg_seasonal = sum_seasonal / period as f64;
+
+    for i in 0..period {
+        seasonal[i] /= avg_seasonal;
+    }
+
+    // Initialize level and trend
+    level[period - 1] = data[period - 1] / seasonal[period - 1];
+    trend[period - 1] = (data[period] / seasonal[0] - data[period - 1] / seasonal[period - 1]) / period as f64;
+
+    // Calculate smoothed values
+    for i in period..n {
+        level[i] = alpha * data[i] / seasonal[i] + (1.0 - alpha) * (level[i - 1] + trend[i - 1]);
+        trend[i] = beta * (level[i] - level[i - 1]) + (1.0 - beta) * trend[i - 1];
+        seasonal[i + period] = gamma * data[i] / level[i] + (1.0 - gamma) * seasonal[i];
+        forecast[i] = (level[i - 1] + trend[i - 1]) * seasonal[i];
+    }
+
+    // Set initial forecasts to actuals
+    for i in 0..period {
+        forecast[i] = data[i];
+    }
+
+    TripleExponentialResult {
+        level,
+        trend,
+        seasonal: seasonal[..n].to_vec(),
+        forecast,
+    }
+}
+
+/// Triple exponential smoothing result
+#[derive(Debug, Clone)]
+pub struct TripleExponentialResult {
+    /// Level component
+    pub level: Vec<f64>,
+    /// Trend component
+    pub trend: Vec<f64>,
+    /// Seasonal component
+    pub seasonal: Vec<f64>,
+    /// Forecast
+    pub forecast: Vec<f64>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_autocorrelation() {
+        let data = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0];
+        let acf = autocorrelation(&data, 3);
+
+        assert_eq!(acf.len(), 4);
+        assert!((acf[0] - 1.0).abs() < 1e-10); // Lag 0 is always 1
+    }
+
+    #[test]
+    fn test_partial_autocorrelation() {
+        let data = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0];
+        let pacf = partial_autocorrelation(&data, 3);
+
+        assert_eq!(pacf.len(), 4);
+        assert!((pacf[0] - 1.0).abs() < 1e-10); // Lag 0 is always 1
+    }
+
+    #[test]
+    fn test_exponential_smoothing() {
+        let data = [10.0, 12.0, 14.0, 16.0, 18.0];
+        let smoothed = exponential_smoothing(&data, 0.5);
+
+        assert_eq!(smoothed.len(), 5);
+        assert!((smoothed[0] - 10.0).abs() < 1e-10);
+        // Second value: 0.5 * 12 + 0.5 * 10 = 11
+        assert!((smoothed[1] - 11.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_double_exponential_smoothing() {
+        let data = [10.0, 12.0, 14.0, 16.0, 18.0];
+        let result = double_exponential_smoothing(&data, 0.5, 0.5);
+
+        assert_eq!(result.level.len(), 5);
+        assert_eq!(result.trend.len(), 5);
+        assert_eq!(result.forecast.len(), 5);
+
+        // Initial trend should be 2 (12 - 10)
+        assert!((result.trend[0] - 2.0).abs() < 1e-10);
+    }
+}

package/src/types.rs

@@ -0,0 +1,224 @@
+//! Core types for quantitative finance computations
+
+use serde::{Deserialize, Serialize};
+
+/// OHLCV candlestick data
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+pub struct OHLCV {
+    /// Unix timestamp in milliseconds
+    pub timestamp: i64,
+    /// Opening price
+    pub open: f64,
+    /// High price
+    pub high: f64,
+    /// Low price
+    pub low: f64,
+    /// Closing price
+    pub close: f64,
+    /// Volume
+    pub volume: f64,
+}
+
+impl OHLCV {
+    pub fn new(timestamp: i64, open: f64, high: f64, low: f64, close: f64, volume: f64) -> Self {
+        Self { timestamp, open, high, low, close, volume }
+    }
+
+    /// Calculate the typical price (HLC/3)
+    pub fn typical_price(&self) -> f64 {
+        (self.high + self.low + self.close) / 3.0
+    }
+
+    /// Calculate the range (high - low)
+    pub fn range(&self) -> f64 {
+        self.high - self.low
+    }
+
+    /// Calculate the body size |close - open|
+    pub fn body_size(&self) -> f64 {
+        (self.close - self.open).abs()
+    }
+
+    /// Check if bullish (close > open)
+    pub fn is_bullish(&self) -> bool {
+        self.close > self.open
+    }
+
+    /// Check if bearish (close < open)
+    pub fn is_bearish(&self) -> bool {
+        self.close < self.open
+    }
+}
+
+/// AMM (Automated Market Maker) state for constant-product AMMs
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+pub struct AMMState {
+    /// YES pool reserves
+    pub pool_yes: f64,
+    /// NO pool reserves
+    pub pool_no: f64,
+    /// Constant product k = pool_yes * pool_no
+    pub k: f64,
+    /// LP token total supply
+    pub lp_token_supply: f64,
+    /// Fee as decimal (e.g., 0.003 for 0.3%)
+    pub fee: f64,
+}
+
+impl AMMState {
+    pub fn new(pool_yes: f64, pool_no: f64, fee: f64) -> Self {
+        let k = pool_yes * pool_no;
+        Self { pool_yes, pool_no, k, lp_token_supply: 0.0, fee }
+    }
+
+    /// Get the current YES price
+    pub fn yes_price(&self) -> f64 {
+        let total = self.pool_yes + self.pool_no;
+        if total == 0.0 { return 0.5; }
+        self.pool_no / total
+    }
+
+    /// Get the current NO price
+    pub fn no_price(&self) -> f64 {
+        1.0 - self.yes_price()
+    }
+}
+
+/// LMSR (Logarithmic Market Scoring Rule) state
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+pub struct LMSRState {
+    /// YES shares outstanding
+    pub yes_shares: f64,
+    /// NO shares outstanding
+    pub no_shares: f64,
+    /// Liquidity parameter (controls price sensitivity)
+    pub b: f64,
+}
+
+impl LMSRState {
+    pub fn new(yes_shares: f64, no_shares: f64, b: f64) -> Self {
+        Self { yes_shares, no_shares, b }
+    }
+
+    /// Calculate the current YES price using LMSR formula
+    pub fn yes_price(&self) -> f64 {
+        use std::f64::consts::E;
+        let exp_yes = E.powf(self.yes_shares / self.b);
+        let exp_no = E.powf(self.no_shares / self.b);
+        exp_yes / (exp_yes + exp_no)
+    }
+
+    /// Calculate the current NO price
+    pub fn no_price(&self) -> f64 {
+        1.0 - self.yes_price()
+    }
+}
+
+/// Result of Kelly criterion calculation
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+pub struct KellyResult {
+    /// Full Kelly fraction (0-1)
+    pub kelly_fraction: f64,
+    /// Half Kelly fraction (more conservative)
+    pub half_kelly: f64,
+    /// Quarter Kelly fraction (most conservative)
+    pub quarter_kelly: f64,
+    /// Full bet size in currency units
+    pub full_bet_size: f64,
+    /// Half bet size in currency units
+    pub half_bet_size: f64,
+    /// Quarter bet size in currency units
+    pub quarter_bet_size: f64,
+    /// Expected edge (your_prob - market_price)
+    pub edge: f64,
+    /// Decimal odds
+    pub odds: f64,
+}
+
+/// Result of VaR (Value at Risk) calculation
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+pub struct VaRResult {
+    /// Value at Risk at the given confidence level
+    pub var: f64,
+    /// Conditional VaR (Expected Shortfall)
+    pub cvar: f64,
+    /// Confidence level used
+    pub confidence_level: f64,
+}
+
+/// Result of Brier score calculation
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+pub struct BrierScore {
+    /// The Brier score (lower is better, 0 = perfect)
+    pub score: f64,
+    /// Number of predictions evaluated
+    pub count: usize,
+}
+
+/// Trading signal
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+pub enum Signal {
+    StrongBuy = 2,
+    Buy = 1,
+    Neutral = 0,
+    Sell = -1,
+    StrongSell = -2,
+}
+
+impl Default for Signal {
+    fn default() -> Self {
+        Signal::Neutral
+    }
+}
+
+/// Indicator result with value and signal
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+pub struct IndicatorResult {
+    /// The indicator value
+    pub value: f64,
+    /// Trading signal derived from the indicator
+    pub signal: Signal,
+    /// Optional upper band (for Bollinger, etc.)
+    pub upper_band: Option<f64>,
+    /// Optional lower band
+    pub lower_band: Option<f64>,
+}
+
+impl IndicatorResult {
+    pub fn new(value: f64, signal: Signal) -> Self {
+        Self { value, signal, upper_band: None, lower_band: None }
+    }
+
+    pub fn with_bands(value: f64, signal: Signal, upper: f64, lower: f64) -> Self {
+        Self { value, signal, upper_band: Some(upper), lower_band: Some(lower) }
+    }
+}
+
+/// Candlestick pattern type
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+pub enum CandlePattern {
+    Doji,
+    Hammer,
+    InvertedHammer,
+    BullishEngulfing,
+    BearishEngulfing,
+    MorningStar,
+    EveningStar,
+    ThreeWhiteSoldiers,
+    ThreeBlackCrows,
+    ShootingStar,
+    HangingMan,
+}
+
+/// Pattern recognition result
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PatternResult {
+    /// The detected pattern
+    pub pattern: CandlePattern,
+    /// Confidence level (0-1)
+    pub confidence: f64,
+    /// Index in the data where pattern was found
+    pub index: usize,
+    /// Whether the pattern is bullish
+    pub is_bullish: bool,
+}

package/src/utils/mod.rs

@@ -0,0 +1,215 @@
+//! Utility Functions Module
+//!
+//! Common utility functions for quantitative analysis.
+//! This module provides statistical functions, rolling operations,
+//! price extraction, return calculations, normalization, and quantile functions.
+
+pub mod normalize;
+pub mod price;
+pub mod quantiles;
+pub mod returns;
+pub mod rolling;
+pub mod stats;
+
+// Re-export all public functions for convenient access
+pub use normalize::{
+    decimal_scale,
+    normalize_min_max,
+    normalize_to_range,
+    normalize_z_score,
+    percent_change,
+    robust_scale,
+    softmax,
+};
+
+pub use price::{
+    extract_close,
+    extract_high,
+    extract_low,
+    extract_ohlcv,
+    extract_open,
+    extract_timestamps,
+    extract_typical_price,
+    extract_volume,
+    extract_weighted_close,
+};
+
+pub use quantiles::{
+    deciles,
+    detect_outliers_iqr,
+    five_number_summary,
+    iqr,
+    percentile,
+    quantile,
+    quartiles,
+    remove_outliers_iqr,
+};
+
+pub use returns::{
+    absolute_returns,
+    annualize_return,
+    cumulative_returns,
+    deannualize_return,
+    log_returns,
+    returns_to_prices,
+    simple_returns,
+};
+
+pub use rolling::{
+    rolling,
+    rolling_max,
+    rolling_mean,
+    rolling_min,
+    rolling_std_dev,
+    rolling_sum,
+    rolling_variance,
+};
+
+pub use stats::{
+    max,
+    mean,
+    median,
+    min,
+    mode,
+    range,
+    std_dev,
+    sum,
+    variance,
+};
+
+// Additional utility functions from TypeScript source
+
+/// Pad array at the beginning (for indicator alignment)
+pub fn pad_front<T: Clone>(arr: &[T], padding_length: usize, fill_value: T) -> Vec<T> {
+    let mut result = Vec::with_capacity(arr.len() + padding_length);
+    for _ in 0..padding_length {
+        result.push(fill_value.clone());
+    }
+    result.extend_from_slice(arr);
+    result
+}
+
+/// Linear interpolation
+pub fn lerp(a: f64, b: f64, t: f64) -> f64 {
+    a + (b - a) * t
+}
+
+/// Interpolate missing values (NaN) in array
+pub fn interpolate_nan(arr: &[f64]) -> Vec<f64> {
+    let mut result = arr.to_vec();
+
+    for i in 0..result.len() {
+        if result[i].is_nan() {
+            let prev_index = (0..i).rev().find(|&j| !result[j].is_nan());
+            let next_index = (i + 1..result.len()).find(|&j| !result[j].is_nan());
+
+            match (prev_index, next_index) {
+                (Some(prev), Some(next)) => {
+                    let t = (i - prev) as f64 / (next - prev) as f64;
+                    result[i] = lerp(result[prev], result[next], t);
+                }
+                (Some(prev), None) => {
+                    result[i] = result[prev];
+                }
+                (None, Some(next)) => {
+                    result[i] = result[next];
+                }
+                (None, None) => {
+                    // No valid values to interpolate from
+                }
+            }
+        }
+    }
+
+    result
+}
+
+/// Check if array contains valid numbers (no NaN)
+pub fn is_valid_array(arr: &[f64]) -> bool {
+    !arr.is_empty() && arr.iter().all(|&v| !v.is_nan() && !v.is_infinite())
+}
+
+/// Round to specific decimal places
+pub fn round_to(value: f64, decimals: u32) -> f64 {
+    let factor = 10_f64.powi(decimals as i32);
+    (value * factor).round() / factor
+}
+
+/// Clamp value within range
+pub fn clamp(value: f64, min_val: f64, max_val: f64) -> f64 {
+    value.clamp(min_val, max_val)
+}
+
+/// Check if two numbers are approximately equal
+pub fn approx_equal(a: f64, b: f64, epsilon: f64) -> bool {
+    (a - b).abs() < epsilon
+}
+
+/// Calculate percentage difference
+pub fn percent_diff(a: f64, b: f64) -> f64 {
+    if a == 0.0 && b == 0.0 {
+        return 0.0;
+    }
+    if a == 0.0 {
+        return if b > 0.0 { f64::INFINITY } else { f64::NEG_INFINITY };
+    }
+    ((b - a) / a.abs()) * 100.0
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_pad_front() {
+        let arr = [1.0, 2.0, 3.0];
+        let padded = pad_front(&arr, 2, 0.0);
+        assert_eq!(padded, vec![0.0, 0.0, 1.0, 2.0, 3.0]);
+    }
+
+    #[test]
+    fn test_lerp() {
+        assert!((lerp(0.0, 10.0, 0.5) - 5.0).abs() < 1e-10);
+        assert!((lerp(0.0, 10.0, 0.0) - 0.0).abs() < 1e-10);
+        assert!((lerp(0.0, 10.0, 1.0) - 10.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_interpolate_nan() {
+        let arr = [1.0, f64::NAN, 3.0];
+        let result = interpolate_nan(&arr);
+        assert!((result[1] - 2.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_is_valid_array() {
+        assert!(is_valid_array(&[1.0, 2.0, 3.0]));
+        assert!(!is_valid_array(&[1.0, f64::NAN, 3.0]));
+        assert!(!is_valid_array(&[]));
+    }
+
+    #[test]
+    fn test_round_to() {
+        assert!((round_to(3.14159, 2) - 3.14).abs() < 1e-10);
+        assert!((round_to(3.14159, 4) - 3.1416).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_clamp() {
+        assert_eq!(clamp(5.0, 0.0, 10.0), 5.0);
+        assert_eq!(clamp(-5.0, 0.0, 10.0), 0.0);
+        assert_eq!(clamp(15.0, 0.0, 10.0), 10.0);
+    }
+
+    #[test]
+    fn test_approx_equal() {
+        assert!(approx_equal(1.0, 1.0000000001, 1e-9));
+        assert!(!approx_equal(1.0, 1.1, 1e-9));
+    }
+
+    #[test]
+    fn test_percent_diff() {
+        assert!((percent_diff(100.0, 110.0) - 10.0).abs() < 1e-10);
+        assert!((percent_diff(100.0, 90.0) - (-10.0)).abs() < 1e-10);
+    }
+}