@devanshhq/indica 0.1.0 → 0.2.0

package/src/core/utils.rs

@@ -0,0 +1,43 @@
+/// Round to N decimal places.
+pub fn round(value: f64, decimals: u32) -> f64 {
+    let factor = 10_f64.powi(decimals as i32);
+    (value * factor).round() / factor
+}
+
+/// Wilder's smoothing step: (prev * (period-1) + val) / period.
+/// Used by RSI and ATR.
+pub fn wilders_step(prev: f64, val: f64, period: usize) -> f64 {
+    (prev * (period as f64 - 1.0) + val) / period as f64
+}
+
+/// EMA smoothing step: val * k + prev * (1 - k), where k = 2/(period+1).
+pub fn ema_step(prev: f64, val: f64, k: f64) -> f64 {
+    val * k + prev * (1.0 - k)
+}
+
+/// Compute EMA smoothing factor for a given period.
+pub fn ema_k(period: usize) -> f64 {
+    2.0 / (period as f64 + 1.0)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_round() {
+        assert_eq!(round(1.23456, 2), 1.23);
+        assert_eq!(round(1.235, 2), 1.24);
+    }
+
+    #[test]
+    fn test_wilders_step() {
+        assert_eq!(wilders_step(10.0, 12.0, 2), 11.0);
+    }
+
+    #[test]
+    fn test_ema_step() {
+        let k = ema_k(3); // 0.5
+        assert_eq!(ema_step(10.0, 12.0, k), 11.0);
+    }
+}

package/src/indicators/india/circuit.rs

@@ -0,0 +1,101 @@
+use crate::core::utils::round;
+
+/// Circuit limit bands for Indian stocks.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CircuitLimit {
+    Percent2,
+    Percent5,
+    Percent10,
+    Percent20,
+}
+
+impl CircuitLimit {
+    fn multiplier(&self) -> f64 {
+        match self {
+            Self::Percent2 => 0.02,
+            Self::Percent5 => 0.05,
+            Self::Percent10 => 0.10,
+            Self::Percent20 => 0.20,
+        }
+    }
+}
+
+/// Circuit proximity status.
+#[derive(Debug, Clone)]
+pub struct CircuitStatus {
+    pub upper_limit: f64,
+    pub lower_limit: f64,
+    pub upper_distance_pct: f64, // How far from upper circuit (0 = at limit)
+    pub lower_distance_pct: f64, // How far from lower circuit
+    pub near_upper: bool,        // Within 1% of upper circuit
+    pub near_lower: bool,        // Within 1% of lower circuit
+}
+
+/// Check how close a stock is to its circuit limits.
+/// Indian stocks have daily price movement limits (2/5/10/20%).
+#[must_use]
+pub fn circuit_proximity(
+    current_price: f64,
+    prev_close: f64,
+    limit: CircuitLimit,
+) -> CircuitStatus {
+    let mult = limit.multiplier();
+    let upper_limit = round(prev_close * (1.0 + mult), 2);
+    let lower_limit = round(prev_close * (1.0 - mult), 2);
+
+    let upper_distance_pct = if current_price < upper_limit {
+        round((upper_limit - current_price) / upper_limit * 100.0, 2)
+    } else {
+        0.0
+    };
+
+    let lower_distance_pct = if current_price > lower_limit {
+        round((current_price - lower_limit) / lower_limit * 100.0, 2)
+    } else {
+        0.0
+    };
+
+    CircuitStatus {
+        upper_limit,
+        lower_limit,
+        upper_distance_pct,
+        lower_distance_pct,
+        near_upper: upper_distance_pct < 1.0,
+        near_lower: lower_distance_pct < 1.0,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn circuit_basic() {
+        let status = circuit_proximity(108.0, 100.0, CircuitLimit::Percent10);
+        assert_eq!(status.upper_limit, 110.0);
+        assert_eq!(status.lower_limit, 90.0);
+        assert!(!status.near_upper);
+        assert!(!status.near_lower);
+    }
+
+    #[test]
+    fn circuit_near_upper() {
+        let status = circuit_proximity(109.5, 100.0, CircuitLimit::Percent10);
+        assert!(status.near_upper);
+        assert!(!status.near_lower);
+    }
+
+    #[test]
+    fn circuit_at_lower() {
+        let status = circuit_proximity(90.0, 100.0, CircuitLimit::Percent10);
+        assert_eq!(status.lower_distance_pct, 0.0);
+        assert!(status.near_lower);
+    }
+
+    #[test]
+    fn circuit_2_pct() {
+        let status = circuit_proximity(100.0, 100.0, CircuitLimit::Percent2);
+        assert_eq!(status.upper_limit, 102.0);
+        assert_eq!(status.lower_limit, 98.0);
+    }
+}

package/src/indicators/india/delivery.rs

@@ -0,0 +1,116 @@
+use crate::core::utils::round;
+
+/// Delivery trend classification.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DeliveryTrend {
+    StrongAccumulation, // High delivery % + price up
+    Accumulation,       // Above avg delivery % + price up
+    Distribution,       // Above avg delivery % + price down
+    StrongDistribution, // High delivery % + price down
+    Neutral,
+}
+
+impl std::fmt::Display for DeliveryTrend {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::StrongAccumulation => write!(f, "strong_accumulation"),
+            Self::Accumulation => write!(f, "accumulation"),
+            Self::Distribution => write!(f, "distribution"),
+            Self::StrongDistribution => write!(f, "strong_distribution"),
+            Self::Neutral => write!(f, "neutral"),
+        }
+    }
+}
+
+/// Delivery percentage: delivery_volume / total_volume * 100.
+/// Unique to NSE/BSE — not available in US markets.
+#[must_use]
+pub fn delivery_pct(delivery_volume: f64, total_volume: f64) -> f64 {
+    if total_volume < f64::EPSILON {
+        return 0.0;
+    }
+    round(delivery_volume / total_volume * 100.0, 2)
+}
+
+/// Delivery trend analysis: compares recent delivery % with price movement.
+/// High delivery + price up = genuine buying (accumulation).
+/// High delivery + price down = genuine selling (distribution).
+#[must_use]
+pub fn delivery_trend(
+    delivery_pcts: &[f64],
+    closes: &[f64],
+    short_period: usize,
+    long_period: usize,
+) -> Option<DeliveryTrend> {
+    if delivery_pcts.len() < long_period
+        || closes.len() < long_period
+        || short_period == 0
+        || long_period == 0
+        || short_period >= long_period
+    {
+        return None;
+    }
+
+    let len = delivery_pcts.len();
+    let short_avg: f64 =
+        delivery_pcts[len - short_period..].iter().sum::<f64>() / short_period as f64;
+    let long_avg: f64 = delivery_pcts[len - long_period..].iter().sum::<f64>() / long_period as f64;
+
+    let delivery_ratio = if long_avg < f64::EPSILON {
+        1.0
+    } else {
+        short_avg / long_avg
+    };
+
+    let clen = closes.len();
+    let price_change = if closes[clen - short_period] > f64::EPSILON {
+        (closes[clen - 1] - closes[clen - short_period]) / closes[clen - short_period]
+    } else {
+        0.0
+    };
+
+    Some(match (delivery_ratio, price_change) {
+        (r, p) if r > 1.3 && p > 0.02 => DeliveryTrend::StrongAccumulation,
+        (r, p) if r > 1.1 && p > 0.0 => DeliveryTrend::Accumulation,
+        (r, p) if r > 1.3 && p < -0.02 => DeliveryTrend::StrongDistribution,
+        (r, p) if r > 1.1 && p < 0.0 => DeliveryTrend::Distribution,
+        _ => DeliveryTrend::Neutral,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn delivery_pct_basic() {
+        assert_eq!(delivery_pct(500_000.0, 1_000_000.0), 50.0);
+        assert_eq!(delivery_pct(0.0, 0.0), 0.0);
+    }
+
+    #[test]
+    fn accumulation() {
+        // High delivery + price up
+        let delivery_pcts = vec![40.0, 42.0, 45.0, 50.0, 55.0, 60.0, 65.0, 70.0, 72.0, 75.0];
+        let closes = vec![
+            100.0, 101.0, 102.0, 103.0, 104.0, 105.0, 106.0, 107.0, 108.0, 110.0,
+        ];
+        let result = delivery_trend(&delivery_pcts, &closes, 3, 10).unwrap();
+        assert!(
+            result == DeliveryTrend::Accumulation || result == DeliveryTrend::StrongAccumulation
+        );
+    }
+
+    #[test]
+    fn distribution() {
+        // High delivery + price down
+        let delivery_pcts = vec![40.0, 42.0, 45.0, 50.0, 55.0, 60.0, 65.0, 70.0, 72.0, 75.0];
+        let closes = vec![
+            110.0, 109.0, 108.0, 107.0, 106.0, 105.0, 104.0, 103.0, 102.0, 100.0,
+        ];
+        let result = delivery_trend(&delivery_pcts, &closes, 3, 10).unwrap();
+        assert!(
+            result == DeliveryTrend::Distribution || result == DeliveryTrend::StrongDistribution
+        );
+    }
+}

package/src/indicators/india/mod.rs

@@ -0,0 +1,2 @@
+pub mod circuit;
+pub mod delivery;

package/src/indicators/mod.rs

@@ -0,0 +1,6 @@
+pub mod india;
+pub mod momentum;
+pub mod support_resistance;
+pub mod trend;
+pub mod volatility;
+pub mod volume;

package/src/indicators/momentum/macd.rs

@@ -0,0 +1,123 @@
+use crate::core::utils::round;
+use crate::indicators::trend::ema::ema_series;
+
+/// MACD crossover direction.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum Crossover {
+    Bullish,
+    Bearish,
+    Neutral,
+}
+
+impl std::fmt::Display for Crossover {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Bullish => write!(f, "bullish"),
+            Self::Bearish => write!(f, "bearish"),
+            Self::Neutral => write!(f, "none"),
+        }
+    }
+}
+
+/// MACD computation result.
+#[derive(Debug, Clone)]
+pub struct MacdResult {
+    pub value: f64,
+    pub signal: f64,
+    pub histogram: f64,
+    pub crossover: Crossover,
+}
+
+/// MACD (Moving Average Convergence Divergence).
+#[must_use]
+pub fn macd(
+    closes: &[f64],
+    fast_period: usize,
+    slow_period: usize,
+    signal_period: usize,
+) -> Option<MacdResult> {
+    if closes.len() < slow_period + signal_period
+        || fast_period == 0
+        || slow_period == 0
+        || signal_period == 0
+        || fast_period >= slow_period
+    {
+        return None;
+    }
+
+    let ema_fast = ema_series(closes, fast_period)?;
+    let ema_slow = ema_series(closes, slow_period)?;
+
+    let offset = slow_period - fast_period;
+    if ema_fast.len() <= offset {
+        return None;
+    }
+
+    let macd_line: Vec<f64> = ema_fast[offset..]
+        .iter()
+        .zip(ema_slow.iter())
+        .map(|(f, s)| f - s)
+        .collect();
+
+    if macd_line.len() < signal_period {
+        return None;
+    }
+
+    let signal_series = ema_series(&macd_line, signal_period)?;
+    let current_signal = *signal_series.last()?;
+    let current_macd = *macd_line.last()?;
+    let histogram = current_macd - current_signal;
+
+    let prev_signal = if signal_series.len() >= 2 {
+        signal_series[signal_series.len() - 2]
+    } else {
+        current_signal
+    };
+    let prev_macd = if macd_line.len() >= 2 {
+        macd_line[macd_line.len() - 2]
+    } else {
+        current_macd
+    };
+    let prev_histogram = prev_macd - prev_signal;
+
+    let crossover = if prev_histogram <= 0.0 && histogram > 0.0 {
+        Crossover::Bullish
+    } else if prev_histogram >= 0.0 && histogram < 0.0 {
+        Crossover::Bearish
+    } else {
+        Crossover::Neutral
+    };
+
+    Some(MacdResult {
+        value: round(current_macd, 2),
+        signal: round(current_signal, 2),
+        histogram: round(histogram, 2),
+        crossover,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn macd_uptrend() {
+        let closes: Vec<f64> = (0..50).map(|i| 100.0 + i as f64 * 0.5).collect();
+        let result = macd(&closes, 12, 26, 9).unwrap();
+        assert!(result.value > 0.0);
+    }
+
+    #[test]
+    fn macd_downtrend() {
+        let closes: Vec<f64> = (0..50).map(|i| 150.0 - i as f64 * 0.5).collect();
+        let result = macd(&closes, 12, 26, 9).unwrap();
+        assert!(result.value < 0.0);
+    }
+
+    #[test]
+    fn macd_invalid_params() {
+        let data = vec![1.0; 50];
+        assert!(macd(&data, 0, 26, 9).is_none());
+        assert!(macd(&data, 26, 12, 9).is_none());
+    }
+}

package/src/indicators/momentum/mod.rs

@@ -0,0 +1,3 @@
+pub mod macd;
+pub mod rsi;
+pub mod stochastic;

package/src/indicators/momentum/rsi.rs

@@ -0,0 +1,130 @@
+use crate::core::traits::Indicator;
+use crate::core::types::Candle;
+use crate::core::utils::wilders_step;
+
+/// Streaming RSI (Wilder's smoothing).
+pub struct Rsi {
+    period: usize,
+    count: usize,
+    prev_close: f64,
+    gain_sum: f64,
+    loss_sum: f64,
+    avg_gain: f64,
+    avg_loss: f64,
+}
+
+impl Rsi {
+    pub fn new(period: usize) -> Self {
+        Self {
+            period,
+            count: 0,
+            prev_close: 0.0,
+            gain_sum: 0.0,
+            loss_sum: 0.0,
+            avg_gain: 0.0,
+            avg_loss: 0.0,
+        }
+    }
+}
+
+impl Indicator for Rsi {
+    type Output = f64;
+
+    fn update(&mut self, candle: &Candle) -> Option<f64> {
+        self.count += 1;
+
+        if self.count == 1 {
+            self.prev_close = candle.close;
+            return None;
+        }
+
+        let change = candle.close - self.prev_close;
+        let gain = change.max(0.0);
+        let loss = (-change).max(0.0);
+        self.prev_close = candle.close;
+
+        let idx = self.count - 1;
+
+        if idx <= self.period {
+            self.gain_sum += gain;
+            self.loss_sum += loss;
+            if idx == self.period {
+                self.avg_gain = self.gain_sum / self.period as f64;
+                self.avg_loss = self.loss_sum / self.period as f64;
+            } else {
+                return None;
+            }
+        } else {
+            self.avg_gain = wilders_step(self.avg_gain, gain, self.period);
+            self.avg_loss = wilders_step(self.avg_loss, loss, self.period);
+        }
+
+        if self.avg_loss < f64::EPSILON {
+            return Some(100.0);
+        }
+
+        let rs = self.avg_gain / self.avg_loss;
+        Some(100.0 - 100.0 / (1.0 + rs))
+    }
+
+    fn reset(&mut self) {
+        *self = Self::new(self.period);
+    }
+}
+
+/// Convenience function: RSI from close values.
+#[must_use]
+pub fn rsi(closes: &[f64], period: usize) -> Option<f64> {
+    if closes.len() < period + 1 || period == 0 {
+        return None;
+    }
+    let candles: Vec<Candle> = closes.iter().map(|&c| Candle::from_close(c)).collect();
+    let mut ind = Rsi::new(period);
+    ind.compute_last(&candles)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn rsi_all_gains() {
+        let closes: Vec<f64> = (0..20).map(|i| 100.0 + i as f64).collect();
+        assert_eq!(rsi(&closes, 14), Some(100.0));
+    }
+
+    #[test]
+    fn rsi_all_losses() {
+        let closes: Vec<f64> = (0..20).map(|i| 100.0 - i as f64).collect();
+        let result = rsi(&closes, 14).unwrap();
+        assert!(result < 1.0);
+    }
+
+    #[test]
+    fn rsi_midrange() {
+        let closes = vec![
+            100.0, 102.0, 100.0, 102.0, 100.0, 102.0, 100.0, 102.0, 100.0, 102.0, 100.0, 102.0,
+            100.0, 102.0, 100.0, 102.0,
+        ];
+        let result = rsi(&closes, 14).unwrap();
+        assert!((result - 50.0).abs() < 5.0);
+    }
+
+    #[test]
+    fn rsi_insufficient() {
+        assert_eq!(rsi(&[100.0, 101.0], 14), None);
+    }
+
+    #[test]
+    fn rsi_streaming() {
+        let closes: Vec<f64> = (0..20).map(|i| 100.0 + i as f64).collect();
+        let fn_result = rsi(&closes, 14).unwrap();
+
+        let mut ind = Rsi::new(14);
+        let mut last = None;
+        for &c in &closes {
+            last = ind.update(&Candle::from_close(c));
+        }
+        assert!((last.unwrap() - fn_result).abs() < 0.01);
+    }
+}

package/src/indicators/momentum/stochastic.rs

@@ -0,0 +1,99 @@
+use crate::core::utils::round;
+use std::collections::VecDeque;
+
+/// Stochastic Oscillator result.
+#[derive(Debug, Clone, Copy)]
+pub struct StochasticResult {
+    pub k: f64, // Fast line (0-100)
+    pub d: f64, // Slow line (SMA of K)
+}
+
+/// Stochastic Oscillator (%K, %D).
+/// %K = (close - lowest_low) / (highest_high - lowest_low) * 100
+/// %D = SMA of %K over d_period
+#[must_use]
+pub fn stochastic(
+    highs: &[f64],
+    lows: &[f64],
+    closes: &[f64],
+    k_period: usize,
+    d_period: usize,
+) -> Option<StochasticResult> {
+    let len = closes.len();
+    if len < k_period + d_period - 1
+        || highs.len() < len
+        || lows.len() < len
+        || k_period == 0
+        || d_period == 0
+    {
+        return None;
+    }
+
+    // Compute %K values
+    let mut k_values = VecDeque::with_capacity(d_period);
+
+    for i in (k_period - 1)..len {
+        let window_highs = &highs[i + 1 - k_period..=i];
+        let window_lows = &lows[i + 1 - k_period..=i];
+
+        let highest = window_highs
+            .iter()
+            .cloned()
+            .fold(f64::NEG_INFINITY, f64::max);
+        let lowest = window_lows.iter().cloned().fold(f64::INFINITY, f64::min);
+
+        let range = highest - lowest;
+        let k = if range < f64::EPSILON {
+            50.0
+        } else {
+            (closes[i] - lowest) / range * 100.0
+        };
+
+        k_values.push_back(k);
+        if k_values.len() > d_period {
+            k_values.pop_front();
+        }
+    }
+
+    if k_values.len() < d_period {
+        return None;
+    }
+
+    let k = *k_values.back()?;
+    let d = k_values.iter().sum::<f64>() / d_period as f64;
+
+    Some(StochasticResult {
+        k: round(k, 2),
+        d: round(d, 2),
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn stochastic_basic() {
+        let highs = vec![10.0, 12.0, 14.0, 13.0, 15.0, 14.0, 16.0, 15.0, 17.0, 16.0];
+        let lows = vec![8.0, 9.0, 11.0, 10.0, 12.0, 11.0, 13.0, 12.0, 14.0, 13.0];
+        let closes = vec![9.0, 11.0, 13.0, 12.0, 14.0, 13.0, 15.0, 14.0, 16.0, 15.0];
+        let result = stochastic(&highs, &lows, &closes, 5, 3).unwrap();
+        assert!(result.k >= 0.0 && result.k <= 100.0);
+        assert!(result.d >= 0.0 && result.d <= 100.0);
+    }
+
+    #[test]
+    fn stochastic_overbought() {
+        // Price at highs = %K near 100
+        let highs: Vec<f64> = (0..20).map(|i| 100.0 + i as f64).collect();
+        let lows: Vec<f64> = highs.iter().map(|h| h - 5.0).collect();
+        let closes = highs.clone(); // Close at high
+        let result = stochastic(&highs, &lows, &closes, 14, 3).unwrap();
+        assert!(result.k > 80.0);
+    }
+
+    #[test]
+    fn stochastic_insufficient() {
+        assert!(stochastic(&[1.0; 5], &[1.0; 5], &[1.0; 5], 14, 3).is_none());
+    }
+}

package/src/indicators/support_resistance/mod.rs

@@ -0,0 +1 @@
+pub mod pivot;

package/src/indicators/support_resistance/pivot.rs

@@ -0,0 +1,40 @@
+use crate::core::utils::round;
+
+#[derive(Debug, Clone)]
+pub struct PivotPointsResult {
+    pub r3: f64,
+    pub r2: f64,
+    pub r1: f64,
+    pub pivot: f64,
+    pub s1: f64,
+    pub s2: f64,
+    pub s3: f64,
+}
+
+/// Classic Pivot Points from a single candle.
+#[must_use]
+pub fn pivot_points(high: f64, low: f64, close: f64) -> PivotPointsResult {
+    let pivot = (high + low + close) / 3.0;
+    PivotPointsResult {
+        r3: round(high + 2.0 * (pivot - low), 2),
+        r2: round(pivot + (high - low), 2),
+        r1: round(2.0 * pivot - low, 2),
+        pivot: round(pivot, 2),
+        s1: round(2.0 * pivot - high, 2),
+        s2: round(pivot - (high - low), 2),
+        s3: round(low - 2.0 * (high - pivot), 2),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn pivot_basic() {
+        let r = pivot_points(110.0, 90.0, 100.0);
+        assert_eq!(r.pivot, 100.0);
+        assert!(r.r1 > r.pivot);
+        assert!(r.s1 < r.pivot);
+    }
+}