@devanshhq/indica 0.1.0 → 0.2.0

package/src/indicators/trend/adx.rs

@@ -0,0 +1,168 @@
+use crate::core::traits::Indicator;
+use crate::core::types::Candle;
+use crate::core::utils::{round, wilders_step};
+
+/// Streaming ADX (Average Directional Index).
+/// Measures trend strength regardless of direction.
+pub struct Adx {
+    period: usize,
+    count: usize,
+    prev_high: f64,
+    prev_low: f64,
+    prev_close: f64,
+    plus_dm_sum: f64,
+    minus_dm_sum: f64,
+    tr_sum: f64,
+    smooth_plus_dm: f64,
+    smooth_minus_dm: f64,
+    smooth_tr: f64,
+    dx_sum: f64,
+    dx_count: usize,
+    adx: f64,
+}
+
+impl Adx {
+    pub fn new(period: usize) -> Self {
+        Self {
+            period,
+            count: 0,
+            prev_high: 0.0,
+            prev_low: 0.0,
+            prev_close: 0.0,
+            plus_dm_sum: 0.0,
+            minus_dm_sum: 0.0,
+            tr_sum: 0.0,
+            smooth_plus_dm: 0.0,
+            smooth_minus_dm: 0.0,
+            smooth_tr: 0.0,
+            dx_sum: 0.0,
+            dx_count: 0,
+            adx: 0.0,
+        }
+    }
+}
+
+impl Indicator for Adx {
+    type Output = f64;
+
+    fn update(&mut self, candle: &Candle) -> Option<f64> {
+        self.count += 1;
+
+        if self.count == 1 {
+            self.prev_high = candle.high;
+            self.prev_low = candle.low;
+            self.prev_close = candle.close;
+            return None;
+        }
+
+        let plus_dm = (candle.high - self.prev_high).max(0.0);
+        let minus_dm = (self.prev_low - candle.low).max(0.0);
+        let (plus_dm, minus_dm) = if plus_dm > minus_dm {
+            (plus_dm, 0.0)
+        } else {
+            (0.0, minus_dm)
+        };
+
+        let tr = (candle.high - candle.low)
+            .max((candle.high - self.prev_close).abs())
+            .max((candle.low - self.prev_close).abs());
+
+        self.prev_high = candle.high;
+        self.prev_low = candle.low;
+        self.prev_close = candle.close;
+
+        let idx = self.count - 1; // 1-based data index
+
+        if idx <= self.period {
+            self.plus_dm_sum += plus_dm;
+            self.minus_dm_sum += minus_dm;
+            self.tr_sum += tr;
+
+            if idx == self.period {
+                self.smooth_plus_dm = self.plus_dm_sum;
+                self.smooth_minus_dm = self.minus_dm_sum;
+                self.smooth_tr = self.tr_sum;
+            } else {
+                return None;
+            }
+        } else {
+            self.smooth_plus_dm = wilders_step(self.smooth_plus_dm, plus_dm, self.period);
+            self.smooth_minus_dm = wilders_step(self.smooth_minus_dm, minus_dm, self.period);
+            self.smooth_tr = wilders_step(self.smooth_tr, tr, self.period);
+        }
+
+        if self.smooth_tr < f64::EPSILON {
+            return None;
+        }
+
+        let plus_di = 100.0 * self.smooth_plus_dm / self.smooth_tr;
+        let minus_di = 100.0 * self.smooth_minus_dm / self.smooth_tr;
+        let di_sum = plus_di + minus_di;
+
+        if di_sum < f64::EPSILON {
+            return None;
+        }
+
+        let dx = 100.0 * (plus_di - minus_di).abs() / di_sum;
+
+        self.dx_count += 1;
+        if self.dx_count < self.period {
+            self.dx_sum += dx;
+            None
+        } else if self.dx_count == self.period {
+            self.dx_sum += dx;
+            self.adx = self.dx_sum / self.period as f64;
+            Some(round(self.adx, 2))
+        } else {
+            self.adx = wilders_step(self.adx, dx, self.period);
+            Some(round(self.adx, 2))
+        }
+    }
+
+    fn reset(&mut self) {
+        *self = Self::new(self.period);
+    }
+}
+
+/// Convenience function: ADX from slices.
+#[must_use]
+pub fn adx(highs: &[f64], lows: &[f64], closes: &[f64], period: usize) -> Option<f64> {
+    let len = closes.len();
+    if len < 2 * period + 1 || highs.len() < len || lows.len() < len || period == 0 {
+        return None;
+    }
+    let candles: Vec<Candle> = (0..len)
+        .map(|i| Candle {
+            open: closes[i],
+            high: highs[i],
+            low: lows[i],
+            close: closes[i],
+            volume: 0.0,
+        })
+        .collect();
+    let mut ind = Adx::new(period);
+    ind.compute_last(&candles)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn adx_strong_trend() {
+        let closes: Vec<f64> = (0..50).map(|i| 100.0 + i as f64 * 2.0).collect();
+        let highs: Vec<f64> = closes.iter().map(|c| c + 1.0).collect();
+        let lows: Vec<f64> = closes.iter().map(|c| c - 1.0).collect();
+        let result = adx(&highs, &lows, &closes, 14).unwrap();
+        assert!(
+            result > 20.0,
+            "ADX should be high in strong trend: {}",
+            result
+        );
+    }
+
+    #[test]
+    fn adx_insufficient() {
+        assert!(adx(&[1.0; 10], &[1.0; 10], &[1.0; 10], 14).is_none());
+    }
+}

package/src/indicators/trend/ema.rs

@@ -0,0 +1,110 @@
+use crate::core::traits::Indicator;
+use crate::core::types::Candle;
+use crate::core::utils::{ema_k, ema_step};
+
+/// Streaming Exponential Moving Average.
+pub struct Ema {
+    period: usize,
+    k: f64,
+    count: usize,
+    sum: f64,
+    value: f64,
+}
+
+impl Ema {
+    pub fn new(period: usize) -> Self {
+        Self {
+            period,
+            k: ema_k(period),
+            count: 0,
+            sum: 0.0,
+            value: 0.0,
+        }
+    }
+}
+
+impl Indicator for Ema {
+    type Output = f64;
+
+    fn update(&mut self, candle: &Candle) -> Option<f64> {
+        self.count += 1;
+        if self.count < self.period {
+            self.sum += candle.close;
+            None
+        } else if self.count == self.period {
+            self.sum += candle.close;
+            self.value = self.sum / self.period as f64; // Seed with SMA
+            Some(self.value)
+        } else {
+            self.value = ema_step(self.value, candle.close, self.k);
+            Some(self.value)
+        }
+    }
+
+    fn reset(&mut self) {
+        self.count = 0;
+        self.sum = 0.0;
+        self.value = 0.0;
+    }
+}
+
+/// Convenience function: EMA of close values.
+#[must_use]
+pub fn ema(values: &[f64], period: usize) -> Option<f64> {
+    if values.len() < period || period == 0 {
+        return None;
+    }
+    let candles: Vec<Candle> = values.iter().map(|&c| Candle::from_close(c)).collect();
+    let mut ind = Ema::new(period);
+    ind.compute_last(&candles)
+}
+
+/// Full EMA series (used internally by MACD).
+pub(crate) fn ema_series(values: &[f64], period: usize) -> Option<Vec<f64>> {
+    if values.len() < period || period == 0 {
+        return None;
+    }
+    let candles: Vec<Candle> = values.iter().map(|&c| Candle::from_close(c)).collect();
+    let mut ind = Ema::new(period);
+    let results: Vec<f64> = ind.compute(&candles).into_iter().flatten().collect();
+    if results.is_empty() {
+        None
+    } else {
+        Some(results)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn ema_fn_basic() {
+        let data = vec![10.0, 11.0, 12.0, 13.0, 14.0, 15.0];
+        let result = ema(&data, 3).unwrap();
+        assert!((result - 14.0).abs() < 0.01);
+    }
+
+    #[test]
+    fn ema_fn_insufficient() {
+        assert_eq!(ema(&[1.0], 5), None);
+    }
+
+    #[test]
+    fn ema_streaming() {
+        let mut ind = Ema::new(3);
+        assert_eq!(ind.update(&Candle::from_close(10.0)), None);
+        assert_eq!(ind.update(&Candle::from_close(11.0)), None);
+        let seed = ind.update(&Candle::from_close(12.0)).unwrap();
+        assert!((seed - 11.0).abs() < 0.01); // SMA seed
+        let next = ind.update(&Candle::from_close(13.0)).unwrap();
+        assert!((next - 12.0).abs() < 0.01); // 13*0.5 + 11*0.5
+    }
+
+    #[test]
+    fn ema_series_works() {
+        let data = vec![10.0, 11.0, 12.0, 13.0, 14.0, 15.0];
+        let series = ema_series(&data, 3).unwrap();
+        assert_eq!(series.len(), 4);
+    }
+}

package/src/indicators/trend/mod.rs

@@ -0,0 +1,4 @@
+pub mod adx;
+pub mod ema;
+pub mod sma;
+pub mod supertrend;

package/src/indicators/trend/sma.rs

@@ -0,0 +1,75 @@
+use crate::core::traits::Indicator;
+use crate::core::types::Candle;
+use std::collections::VecDeque;
+
+/// Streaming Simple Moving Average.
+pub struct Sma {
+    period: usize,
+    window: VecDeque<f64>,
+}
+
+impl Sma {
+    pub fn new(period: usize) -> Self {
+        Self {
+            period,
+            window: VecDeque::with_capacity(period),
+        }
+    }
+}
+
+impl Indicator for Sma {
+    type Output = f64;
+
+    fn update(&mut self, candle: &Candle) -> Option<f64> {
+        self.window.push_back(candle.close);
+        if self.window.len() > self.period {
+            self.window.pop_front();
+        }
+        if self.window.len() == self.period {
+            Some(self.window.iter().sum::<f64>() / self.period as f64)
+        } else {
+            None
+        }
+    }
+
+    fn reset(&mut self) {
+        self.window.clear();
+    }
+}
+
+/// Convenience function: SMA of the last `period` close values.
+#[must_use]
+pub fn sma(closes: &[f64], period: usize) -> Option<f64> {
+    if closes.len() < period || period == 0 {
+        return None;
+    }
+    let slice = &closes[closes.len() - period..];
+    Some(slice.iter().sum::<f64>() / period as f64)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn sma_fn_basic() {
+        assert_eq!(sma(&[1.0, 2.0, 3.0, 4.0, 5.0], 3), Some(4.0));
+        assert_eq!(sma(&[10.0, 20.0, 30.0], 3), Some(20.0));
+    }
+
+    #[test]
+    fn sma_fn_insufficient() {
+        assert_eq!(sma(&[1.0, 2.0], 5), None);
+        assert_eq!(sma(&[], 1), None);
+    }
+
+    #[test]
+    fn sma_streaming() {
+        let mut ind = Sma::new(3);
+        assert_eq!(ind.update(&Candle::from_close(1.0)), None);
+        assert_eq!(ind.update(&Candle::from_close(2.0)), None);
+        assert_eq!(ind.update(&Candle::from_close(3.0)), Some(2.0));
+        assert_eq!(ind.update(&Candle::from_close(4.0)), Some(3.0));
+        assert_eq!(ind.update(&Candle::from_close(5.0)), Some(4.0));
+    }
+}

package/src/indicators/trend/supertrend.rs

@@ -0,0 +1,193 @@
+use crate::core::traits::Indicator;
+use crate::core::types::Candle;
+use crate::core::utils::{round, wilders_step};
+
+/// Supertrend result.
+#[derive(Debug, Clone, Copy)]
+pub struct SupertrendResult {
+    pub value: f64,
+    pub direction: SupertrendDirection,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SupertrendDirection {
+    Up,
+    Down,
+}
+
+impl std::fmt::Display for SupertrendDirection {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Up => write!(f, "up"),
+            Self::Down => write!(f, "down"),
+        }
+    }
+}
+
+/// Streaming Supertrend indicator.
+pub struct Supertrend {
+    atr_period: usize,
+    multiplier: f64,
+    count: usize,
+    // ATR state
+    prev_close: f64,
+    tr_sum: f64,
+    atr: f64,
+    // Supertrend state
+    prev_upper: f64,
+    prev_lower: f64,
+    prev_st: f64,
+    prev_direction: SupertrendDirection,
+}
+
+impl Supertrend {
+    pub fn new(atr_period: usize, multiplier: f64) -> Self {
+        Self {
+            atr_period,
+            multiplier,
+            count: 0,
+            prev_close: 0.0,
+            tr_sum: 0.0,
+            atr: 0.0,
+            prev_upper: 0.0,
+            prev_lower: 0.0,
+            prev_st: 0.0,
+            prev_direction: SupertrendDirection::Up,
+        }
+    }
+}
+
+impl Indicator for Supertrend {
+    type Output = SupertrendResult;
+
+    fn update(&mut self, candle: &Candle) -> Option<SupertrendResult> {
+        self.count += 1;
+
+        if self.count == 1 {
+            self.prev_close = candle.close;
+            return None;
+        }
+
+        // True Range
+        let tr = (candle.high - candle.low)
+            .max((candle.high - self.prev_close).abs())
+            .max((candle.low - self.prev_close).abs());
+
+        if self.count <= self.atr_period + 1 {
+            self.tr_sum += tr;
+            if self.count == self.atr_period + 1 {
+                self.atr = self.tr_sum / self.atr_period as f64;
+            } else {
+                self.prev_close = candle.close;
+                return None;
+            }
+        } else {
+            self.atr = wilders_step(self.atr, tr, self.atr_period);
+        }
+
+        let hl2 = (candle.high + candle.low) / 2.0;
+        let basic_upper = hl2 + self.multiplier * self.atr;
+        let basic_lower = hl2 - self.multiplier * self.atr;
+
+        let upper = if basic_upper < self.prev_upper || self.prev_close > self.prev_upper {
+            basic_upper
+        } else {
+            self.prev_upper
+        };
+
+        let lower = if basic_lower > self.prev_lower || self.prev_close < self.prev_lower {
+            basic_lower
+        } else {
+            self.prev_lower
+        };
+
+        let (st, direction) = if self.prev_st == self.prev_upper {
+            if candle.close <= upper {
+                (upper, SupertrendDirection::Down)
+            } else {
+                (lower, SupertrendDirection::Up)
+            }
+        } else if candle.close >= lower {
+            (lower, SupertrendDirection::Up)
+        } else {
+            (upper, SupertrendDirection::Down)
+        };
+
+        self.prev_upper = upper;
+        self.prev_lower = lower;
+        self.prev_st = st;
+        self.prev_direction = direction;
+        self.prev_close = candle.close;
+
+        Some(SupertrendResult {
+            value: round(st, 2),
+            direction,
+        })
+    }
+
+    fn reset(&mut self) {
+        self.count = 0;
+        self.prev_close = 0.0;
+        self.tr_sum = 0.0;
+        self.atr = 0.0;
+        self.prev_upper = 0.0;
+        self.prev_lower = 0.0;
+        self.prev_st = 0.0;
+        self.prev_direction = SupertrendDirection::Up;
+    }
+}
+
+/// Convenience function: Supertrend from slices.
+#[must_use]
+pub fn supertrend(
+    highs: &[f64],
+    lows: &[f64],
+    closes: &[f64],
+    atr_period: usize,
+    multiplier: f64,
+) -> Option<SupertrendResult> {
+    let len = closes.len();
+    if len < atr_period + 1 || highs.len() < len || lows.len() < len || atr_period == 0 {
+        return None;
+    }
+    let candles: Vec<Candle> = (0..len)
+        .map(|i| Candle {
+            open: closes[i],
+            high: highs[i],
+            low: lows[i],
+            close: closes[i],
+            volume: 0.0,
+        })
+        .collect();
+    let mut ind = Supertrend::new(atr_period, multiplier);
+    ind.compute_last(&candles)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn supertrend_uptrend() {
+        let closes: Vec<f64> = (0..30).map(|i| 100.0 + i as f64).collect();
+        let highs: Vec<f64> = closes.iter().map(|c| c + 1.0).collect();
+        let lows: Vec<f64> = closes.iter().map(|c| c - 1.0).collect();
+        let result = supertrend(&highs, &lows, &closes, 10, 3.0).unwrap();
+        assert_eq!(result.direction, SupertrendDirection::Up);
+        assert!(result.value < *closes.last().unwrap());
+    }
+
+    #[test]
+    fn supertrend_downtrend() {
+        let closes: Vec<f64> = (0..30).map(|i| 200.0 - i as f64).collect();
+        let highs: Vec<f64> = closes.iter().map(|c| c + 1.0).collect();
+        let lows: Vec<f64> = closes.iter().map(|c| c - 1.0).collect();
+        let result = supertrend(&highs, &lows, &closes, 10, 3.0).unwrap();
+        assert_eq!(result.direction, SupertrendDirection::Down);
+    }
+
+    #[test]
+    fn supertrend_insufficient() {
+        assert!(supertrend(&[1.0; 5], &[1.0; 5], &[1.0; 5], 10, 3.0).is_none());
+    }
+}

package/src/indicators/volatility/atr.rs

@@ -0,0 +1,51 @@
+use crate::core::utils::{round, wilders_step};
+
+/// Average True Range using Wilder's smoothing.
+#[must_use]
+pub fn atr(highs: &[f64], lows: &[f64], closes: &[f64], period: usize) -> Option<f64> {
+    let len = closes.len();
+    if len < period + 1 || highs.len() < len || lows.len() < len || period == 0 {
+        return None;
+    }
+    let true_ranges: Vec<f64> = (1..len)
+        .map(|i| {
+            (highs[i] - lows[i])
+                .max((highs[i] - closes[i - 1]).abs())
+                .max((lows[i] - closes[i - 1]).abs())
+        })
+        .collect();
+    if true_ranges.len() < period {
+        return None;
+    }
+    let seed: f64 = true_ranges[..period].iter().sum::<f64>() / period as f64;
+    let mut value = seed;
+    for &tr in &true_ranges[period..] {
+        value = wilders_step(value, tr, period);
+    }
+    Some(round(value, 2))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn atr_basic() {
+        let closes: Vec<f64> = (0..20).map(|i| 100.0 + (i as f64 * 0.5)).collect();
+        let highs: Vec<f64> = closes.iter().map(|c| c + 2.0).collect();
+        let lows: Vec<f64> = closes.iter().map(|c| c - 2.0).collect();
+        let result = atr(&highs, &lows, &closes, 14).unwrap();
+        assert!(result > 0.0);
+    }
+
+    #[test]
+    fn atr_flat() {
+        let data = vec![100.0; 20];
+        assert_eq!(atr(&data, &data, &data, 14), Some(0.0));
+    }
+
+    #[test]
+    fn atr_insufficient() {
+        assert!(atr(&[1.0; 5], &[1.0; 5], &[1.0; 5], 14).is_none());
+    }
+}

package/src/{bollinger.rs → indicators/volatility/bollinger.rs}

@@ -1,6 +1,5 @@
-use crate::utils::round;
+use crate::core::utils::round;
 
-/// Bollinger Bands result.
 #[derive(Debug, Clone)]
 pub struct BollingerBandsResult {
     pub upper: f64,
@@ -9,8 +8,8 @@ pub struct BollingerBandsResult {
     pub percent_b: f64,
 }
 
-/// Bollinger Bands (default: period=20, std_dev_multiplier=2.0).
-/// Returns `None` if insufficient data.
+/// Bollinger Bands (uses population standard deviation).
+#[must_use]
 pub fn bollinger_bands(
     closes: &[f64],
     period: usize,
@@ -19,24 +18,18 @@ pub fn bollinger_bands(
     if closes.len() < period || period == 0 {
         return None;
     }
-
     let slice = &closes[closes.len() - period..];
     let middle: f64 = slice.iter().sum::<f64>() / period as f64;
-
-    let variance: f64 =
-        slice.iter().map(|&v| (v - middle).powi(2)).sum::<f64>() / period as f64;
+    let variance: f64 = slice.iter().map(|&v| (v - middle).powi(2)).sum::<f64>() / period as f64;
     let std_dev = variance.sqrt();
-
     let upper = middle + std_dev_multiplier * std_dev;
     let lower = middle - std_dev_multiplier * std_dev;
-
-    let current_price = *closes.last().unwrap();
+    let current_price = *closes.last()?;
     let percent_b = if (upper - lower).abs() < f64::EPSILON {
         0.5
     } else {
         (current_price - lower) / (upper - lower)
     };
-
     Some(BollingerBandsResult {
         upper: round(upper, 2),
         middle: round(middle, 2),
@@ -55,19 +48,10 @@ mod tests {
         let result = bollinger_bands(&closes, 20, 2.0).unwrap();
         assert!(result.upper > result.middle);
         assert!(result.middle > result.lower);
-        assert_eq!(result.middle, 10.5); // avg of 1..=20
-    }
-
-    #[test]
-    fn bb_percent_b() {
-        // Price at middle should give ~0.5
-        let closes = vec![10.0; 20];
-        let result = bollinger_bands(&closes, 20, 2.0).unwrap();
-        assert_eq!(result.percent_b, 0.5); // all same = flat bands
     }
 
     #[test]
-    fn bb_insufficient_data() {
+    fn bb_insufficient() {
         assert!(bollinger_bands(&[1.0; 5], 20, 2.0).is_none());
     }
 }

package/src/indicators/volatility/mod.rs

@@ -0,0 +1,2 @@
+pub mod atr;
+pub mod bollinger;

package/src/indicators/volume/mod.rs

@@ -0,0 +1,3 @@
+pub mod obv;
+pub mod volume_trend;
+pub mod vwap;