@ebowwa/quant-rust 0.1.0

package/src/indicators/ma.rs

@@ -0,0 +1,222 @@
+//! Moving Average Indicators
+//!
+//! Various moving average implementations for trend analysis.
+
+use crate::utils::{mean, rolling};
+
+/// Simple Moving Average (SMA)
+///
+/// Calculates the unweighted mean of the previous `period` data points.
+///
+/// # Arguments
+/// * `data` - Price data slice
+/// * `period` - Number of periods to average
+///
+/// # Returns
+/// A vector of SMA values. Returns empty vector if data length < period.
+///
+/// # Example
+/// ```
+/// use quant_rust::indicators::sma;
+/// let prices = vec![10.0, 12.0, 14.0, 16.0, 18.0];
+/// let result = sma(&prices, 3);
+/// assert_eq!(result, vec![12.0, 14.0, 16.0]);
+/// ```
+pub fn sma(data: &[f64], period: usize) -> Vec<f64> {
+    if data.len() < period || period == 0 {
+        return Vec::new();
+    }
+    rolling(data, period, |slice| mean(slice))
+}
+
+/// Exponential Moving Average (EMA)
+///
+/// A weighted moving average that gives more weight to recent prices.
+/// Uses the formula: EMA = (Price - prev_EMA) * multiplier + prev_EMA
+/// where multiplier = 2 / (period + 1)
+///
+/// # Arguments
+/// * `data` - Price data slice
+/// * `period` - EMA period
+///
+/// # Returns
+/// A vector of EMA values. First value is SMA of initial period.
+pub fn ema(data: &[f64], period: usize) -> Vec<f64> {
+    if data.len() < period || period == 0 {
+        return Vec::new();
+    }
+
+    let multiplier = 2.0 / (period + 1) as f64;
+    let mut result = Vec::with_capacity(data.len() - period + 1);
+
+    // First EMA value is SMA
+    let mut prev_ema = mean(&data[0..period]);
+    result.push(prev_ema);
+
+    // Calculate EMA for remaining values
+    for i in period..data.len() {
+        let current_ema = (data[i] - prev_ema) * multiplier + prev_ema;
+        result.push(current_ema);
+        prev_ema = current_ema;
+    }
+
+    result
+}
+
+/// Weighted Moving Average (WMA)
+///
+/// A moving average where each data point is multiplied by a weight factor.
+/// More recent data points have higher weights.
+///
+/// # Arguments
+/// * `data` - Price data slice
+/// * `period` - WMA period
+///
+/// # Returns
+/// A vector of WMA values.
+pub fn wma(data: &[f64], period: usize) -> Vec<f64> {
+    if data.len() < period || period == 0 {
+        return Vec::new();
+    }
+
+    rolling(data, period, |slice| {
+        let n = slice.len();
+        let weighted_sum: f64 = slice
+            .iter()
+            .enumerate()
+            .map(|(i, &val)| val * (i + 1) as f64)
+            .sum();
+        let weight_sum: f64 = (1..=n).map(|i| i as f64).sum();
+        weighted_sum / weight_sum
+    })
+}
+
+/// Hull Moving Average (HMA)
+///
+/// Developed by Alan Hull to reduce lag while maintaining smoothness.
+/// Uses weighted moving averages of different periods to achieve this.
+///
+/// # Arguments
+/// * `data` - Price data slice
+/// * `period` - HMA period
+///
+/// # Returns
+/// A vector of HMA values.
+pub fn hma(data: &[f64], period: usize) -> Vec<f64> {
+    if data.len() < period || period == 0 {
+        return Vec::new();
+    }
+
+    let half_period = period / 2;
+    let sqrt_period = (period as f64).sqrt().floor() as usize;
+
+    if half_period == 0 || sqrt_period == 0 {
+        return Vec::new();
+    }
+
+    let wma_half = wma(data, half_period);
+    let wma_full = wma(data, period);
+
+    // Calculate raw HMA: 2 * WMA(half) - WMA(full)
+    let offset = period - half_period;
+    let mut raw_hma = Vec::new();
+
+    for i in 0..wma_half.len() {
+        if i + offset < wma_full.len() {
+            raw_hma.push(2.0 * wma_half[i] - wma_full[i + offset]);
+        }
+    }
+
+    // Apply WMA with sqrt(period) to smooth
+    wma(&raw_hma, sqrt_period)
+}
+
+/// Volume Weighted Moving Average (VWMA)
+///
+/// A moving average that incorporates volume into the calculation.
+/// VWMA = Sum(Price * Volume) / Sum(Volume)
+///
+/// # Arguments
+/// * `prices` - Price data slice
+/// * `volumes` - Volume data slice
+/// * `period` - VWMA period
+///
+/// # Returns
+/// A vector of VWMA values.
+pub fn vwma(prices: &[f64], volumes: &[f64], period: usize) -> Vec<f64> {
+    if prices.len() < period || volumes.len() < period || period == 0 {
+        return Vec::new();
+    }
+
+    let mut result = Vec::new();
+
+    for i in (period - 1)..prices.len() {
+        let start = i + 1 - period;
+        let end = i + 1;
+
+        let pv_sum: f64 = prices[start..end]
+            .iter()
+            .zip(volumes[start..end].iter())
+            .map(|(&p, &v)| p * v)
+            .sum();
+        let v_sum: f64 = volumes[start..end].iter().sum();
+
+        result.push(if v_sum > 0.0 {
+            pv_sum / v_sum
+        } else {
+            prices[i]
+        });
+    }
+
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_sma() {
+        let prices = vec![10.0, 12.0, 14.0, 16.0, 18.0];
+        let result = sma(&prices, 3);
+        assert_eq!(result.len(), 3);
+        assert!((result[0] - 12.0).abs() < 1e-10);
+        assert!((result[1] - 14.0).abs() < 1e-10);
+        assert!((result[2] - 16.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_sma_empty() {
+        let prices = vec![10.0, 12.0];
+        let result = sma(&prices, 5);
+        assert!(result.is_empty());
+    }
+
+    #[test]
+    fn test_ema() {
+        let prices = vec![10.0, 12.0, 14.0, 16.0, 18.0, 20.0];
+        let result = ema(&prices, 3);
+        assert_eq!(result.len(), 4);
+        // First EMA should be SMA of first 3 values
+        assert!((result[0] - 12.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_wma() {
+        let prices = vec![10.0, 20.0, 30.0];
+        let result = wma(&prices, 3);
+        assert_eq!(result.len(), 1);
+        // WMA = (10*1 + 20*2 + 30*3) / (1+2+3) = 140/6 = 23.333...
+        assert!((result[0] - 23.333333333333332).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_vwma() {
+        let prices = vec![10.0, 12.0, 14.0, 16.0];
+        let volumes = vec![100.0, 200.0, 100.0, 150.0];
+        let result = vwma(&prices, &volumes, 3);
+        assert_eq!(result.len(), 2);
+        // VWMA for first window: (10*100 + 12*200 + 14*100) / (100+200+100) = 4800/400 = 12.0
+        assert!((result[0] - 12.0).abs() < 1e-10);
+    }
+}

package/src/indicators/mod.rs

@@ -0,0 +1,18 @@
+//! Technical Indicators
+//!
+//! Implementations of classic and modern technical indicators for price analysis.
+
+pub mod ma;
+pub mod momentum;
+pub mod volatility;
+pub mod trend;
+pub mod sr;
+pub mod volume;
+
+// Re-export all types and functions
+pub use ma::*;
+pub use momentum::*;
+pub use volatility::*;
+pub use trend::*;
+pub use sr::*;
+pub use volume::*;

package/src/indicators/momentum.rs

@@ -0,0 +1,353 @@
+//! Momentum Indicators
+//!
+//! Indicators that measure the speed and strength of price movements.
+
+use crate::utils::{mean, max, min};
+
+/// MACD (Moving Average Convergence Divergence) result
+#[derive(Debug, Clone, PartialEq)]
+pub struct MACDResult {
+    /// MACD line (fast EMA - slow EMA)
+    pub macd: Vec<f64>,
+    /// Signal line (EMA of MACD)
+    pub signal: Vec<f64>,
+    /// Histogram (MACD - Signal)
+    pub histogram: Vec<f64>,
+}
+
+/// Stochastic Oscillator result
+#[derive(Debug, Clone, PartialEq)]
+pub struct StochasticResult {
+    /// %K line (fast stochastic)
+    pub k: Vec<f64>,
+    /// %D line (SMA of %K)
+    pub d: Vec<f64>,
+}
+
+/// Relative Strength Index (RSI)
+///
+/// Measures the speed and magnitude of recent price changes.
+/// RSI ranges from 0 to 100, with readings above 70 indicating overbought
+/// and below 30 indicating oversold conditions.
+///
+/// # Arguments
+/// * `data` - Price data slice
+/// * `period` - RSI period (default: 14)
+///
+/// # Returns
+/// A vector of RSI values (0-100).
+pub fn rsi(data: &[f64], period: usize) -> Vec<f64> {
+    if data.len() < period + 1 || period == 0 {
+        return Vec::new();
+    }
+
+    let mut gains: Vec<f64> = Vec::with_capacity(data.len() - 1);
+    let mut losses: Vec<f64> = Vec::with_capacity(data.len() - 1);
+
+    // Calculate price changes
+    for i in 1..data.len() {
+        let change = data[i] - data[i - 1];
+        gains.push(if change > 0.0 { change } else { 0.0 });
+        losses.push(if change < 0.0 { change.abs() } else { 0.0 });
+    }
+
+    // First average
+    let mut avg_gain = mean(&gains[0..period]);
+    let mut avg_loss = mean(&losses[0..period]);
+
+    let mut result = Vec::new();
+
+    // First RSI
+    if avg_loss == 0.0 {
+        result.push(100.0);
+    } else {
+        let rs = avg_gain / avg_loss;
+        result.push(100.0 - 100.0 / (1.0 + rs));
+    }
+
+    // Subsequent values using smoothed average
+    for i in period..gains.len() {
+        avg_gain = (avg_gain * (period - 1) as f64 + gains[i]) / period as f64;
+        avg_loss = (avg_loss * (period - 1) as f64 + losses[i]) / period as f64;
+
+        if avg_loss == 0.0 {
+            result.push(100.0);
+        } else {
+            let rs = avg_gain / avg_loss;
+            result.push(100.0 - 100.0 / (1.0 + rs));
+        }
+    }
+
+    result
+}
+
+/// MACD (Moving Average Convergence Divergence)
+///
+/// A trend-following momentum indicator showing the relationship
+/// between two EMAs of price.
+///
+/// # Arguments
+/// * `data` - Price data slice
+/// * `fast` - Fast EMA period (default: 12)
+/// * `slow` - Slow EMA period (default: 26)
+/// * `signal` - Signal line period (default: 9)
+///
+/// # Returns
+/// A MACDResult containing MACD line, signal line, and histogram.
+pub fn macd(data: &[f64], fast: usize, slow: usize, signal: usize) -> MACDResult {
+    if data.len() < slow || fast == 0 || slow == 0 || signal == 0 {
+        return MACDResult {
+            macd: Vec::new(),
+            signal: Vec::new(),
+            histogram: Vec::new(),
+        };
+    }
+
+    let fast_ema = super::ema(data, fast);
+    let slow_ema = super::ema(data, slow);
+
+    // Align arrays (slow EMA starts later)
+    let offset = slow - fast;
+    let mut macd_line: Vec<f64> = Vec::with_capacity(slow_ema.len());
+
+    for i in 0..slow_ema.len() {
+        if i + offset < fast_ema.len() {
+            macd_line.push(fast_ema[i + offset] - slow_ema[i]);
+        }
+    }
+
+    let signal_line = super::ema(&macd_line, signal);
+
+    // Align histogram with signal
+    let signal_offset = signal - 1;
+    let mut histogram: Vec<f64> = Vec::new();
+
+    for i in 0..signal_line.len() {
+        if i + signal_offset < macd_line.len() {
+            histogram.push(macd_line[i + signal_offset] - signal_line[i]);
+        }
+    }
+
+    // Align all outputs
+    let aligned_macd = macd_line[signal_offset..signal_offset + histogram.len()].to_vec();
+
+    MACDResult {
+        macd: aligned_macd,
+        signal: signal_line,
+        histogram,
+    }
+}
+
+/// Stochastic Oscillator
+///
+/// A momentum indicator comparing a particular closing price
+/// to a range of its prices over a certain period.
+///
+/// # Arguments
+/// * `high` - High prices
+/// * `low` - Low prices
+/// * `close` - Close prices
+/// * `k_period` - %K period (default: 14)
+/// * `d_period` - %D period (default: 3)
+///
+/// # Returns
+/// A StochasticResult containing %K and %D lines.
+pub fn stochastic(
+    high: &[f64],
+    low: &[f64],
+    close: &[f64],
+    k_period: usize,
+    d_period: usize,
+) -> StochasticResult {
+    if high.len() < k_period || k_period == 0 || d_period == 0 {
+        return StochasticResult {
+            k: Vec::new(),
+            d: Vec::new(),
+        };
+    }
+
+    let mut k_values: Vec<f64> = Vec::new();
+
+    for i in (k_period - 1)..close.len() {
+        let start = i + 1 - k_period;
+        let end = i + 1;
+
+        let highest_high = max(&high[start..end]);
+        let lowest_low = min(&low[start..end]);
+
+        if highest_high.is_nan() || lowest_low.is_nan() {
+            k_values.push(50.0);
+            continue;
+        }
+
+        if (highest_high - lowest_low).abs() < 1e-10 {
+            k_values.push(50.0); // Neutral if range is 0
+        } else {
+            k_values.push((close[i] - lowest_low) / (highest_high - lowest_low) * 100.0);
+        }
+    }
+
+    let d_values = super::sma(&k_values, d_period);
+
+    // Align K with D
+    let offset = d_period - 1;
+    let aligned_k = if offset < k_values.len() && d_values.len() > 0 {
+        k_values[offset..offset + d_values.len()].to_vec()
+    } else {
+        Vec::new()
+    };
+
+    StochasticResult {
+        k: aligned_k,
+        d: d_values,
+    }
+}
+
+/// Williams %R
+///
+/// A momentum indicator measuring overbought/oversold levels.
+/// Ranges from -100 to 0, with readings above -20 overbought
+/// and below -80 oversold.
+///
+/// # Arguments
+/// * `high` - High prices
+/// * `low` - Low prices
+/// * `close` - Close prices
+/// * `period` - Lookback period (default: 14)
+///
+/// # Returns
+/// A vector of Williams %R values (-100 to 0).
+pub fn williams_r(high: &[f64], low: &[f64], close: &[f64], period: usize) -> Vec<f64> {
+    if high.len() < period || period == 0 {
+        return Vec::new();
+    }
+
+    let mut result = Vec::new();
+
+    for i in (period - 1)..close.len() {
+        let start = i + 1 - period;
+        let end = i + 1;
+
+        let highest_high = max(&high[start..end]);
+        let lowest_low = min(&low[start..end]);
+
+        if (highest_high - lowest_low).abs() < 1e-10 {
+            result.push(-50.0);
+        } else {
+            result.push((highest_high - close[i]) / (highest_high - lowest_low) * -100.0);
+        }
+    }
+
+    result
+}
+
+/// Rate of Change (ROC)
+///
+/// Measures the percentage change in price from a previous period.
+///
+/// # Arguments
+/// * `data` - Price data slice
+/// * `period` - Lookback period (default: 14)
+///
+/// # Returns
+/// A vector of ROC values (percentage).
+pub fn roc(data: &[f64], period: usize) -> Vec<f64> {
+    if data.len() < period + 1 || period == 0 {
+        return Vec::new();
+    }
+
+    data[period..]
+        .iter()
+        .enumerate()
+        .map(|(i, &val)| {
+            let old_val = data[i];
+            if old_val != 0.0 {
+                ((val - old_val) / old_val) * 100.0
+            } else {
+                0.0
+            }
+        })
+        .collect()
+}
+
+/// Momentum
+///
+/// Measures the rate of price change.
+/// Momentum = Current Price - Price N periods ago
+///
+/// # Arguments
+/// * `data` - Price data slice
+/// * `period` - Lookback period (default: 14)
+///
+/// # Returns
+/// A vector of momentum values.
+pub fn momentum(data: &[f64], period: usize) -> Vec<f64> {
+    if data.len() < period + 1 || period == 0 {
+        return Vec::new();
+    }
+
+    data[period..]
+        .iter()
+        .enumerate()
+        .map(|(i, &val)| val - data[i])
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_rsi() {
+        // RSI with all gains should be 100
+        let prices = vec![10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0];
+        let result = rsi(&prices, 14);
+        assert!(!result.is_empty());
+        // All upward moves should give very high RSI
+        assert!(result[0] > 99.0);
+    }
+
+    #[test]
+    fn test_macd() {
+        let prices: Vec<f64> = (1..=50).map(|x| x as f64).collect();
+        let result = macd(&prices, 12, 26, 9);
+        // MACD line should have values
+        assert!(!result.macd.is_empty());
+    }
+
+    #[test]
+    fn test_stochastic() {
+        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,
+                        33.0, 32.0, 34.0, 36.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,
+                       29.0, 28.0, 30.0, 32.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,
+                         32.0, 30.0, 33.0, 35.0];
+
+        let result = stochastic(&high, &low, &close, 14, 3);
+        assert!(!result.k.is_empty());
+        assert!(!result.d.is_empty());
+    }
+
+    #[test]
+    fn test_roc() {
+        let prices = vec![100.0, 110.0, 105.0, 115.0];
+        let result = roc(&prices, 1);
+        assert_eq!(result.len(), 3);
+        assert!((result[0] - 10.0).abs() < 1e-10); // (110-100)/100 * 100
+        assert!((result[1] - (-4.5454)).abs() < 0.01); // (105-110)/110 * 100
+    }
+
+    #[test]
+    fn test_momentum() {
+        let prices = vec![100.0, 110.0, 105.0, 115.0];
+        let result = momentum(&prices, 1);
+        assert_eq!(result.len(), 3);
+        assert_eq!(result[0], 10.0);
+        assert_eq!(result[1], -5.0);
+        assert_eq!(result[2], 10.0);
+    }
+}