@devanshhq/indica 0.1.0 → 0.2.0

package/src/indicators/volume/obv.rs

@@ -0,0 +1,44 @@
+/// On-Balance Volume.
+/// Running total: +volume on up days, -volume on down days.
+#[must_use]
+pub fn obv(closes: &[f64], volumes: &[f64]) -> Option<f64> {
+    let len = closes.len();
+    if len < 2 || volumes.len() < len {
+        return None;
+    }
+    let mut value = 0.0;
+    for i in 1..len {
+        if closes[i] > closes[i - 1] {
+            value += volumes[i];
+        } else if closes[i] < closes[i - 1] {
+            value -= volumes[i];
+        }
+    }
+    Some(value)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn obv_up_trend() {
+        let closes = vec![10.0, 11.0, 12.0, 13.0, 14.0];
+        let volumes = vec![100.0, 200.0, 300.0, 400.0, 500.0];
+        let result = obv(&closes, &volumes).unwrap();
+        assert_eq!(result, 1400.0); // 200+300+400+500
+    }
+
+    #[test]
+    fn obv_mixed() {
+        let closes = vec![10.0, 12.0, 11.0, 13.0];
+        let volumes = vec![100.0, 200.0, 300.0, 400.0];
+        let result = obv(&closes, &volumes).unwrap();
+        assert_eq!(result, 300.0); // +200 -300 +400
+    }
+
+    #[test]
+    fn obv_insufficient() {
+        assert!(obv(&[10.0], &[100.0]).is_none());
+    }
+}

package/src/{volume.rs → indicators/volume/volume_trend.rs}

@@ -1,20 +1,15 @@
 /// Classify volume trend by comparing recent 5-day avg to 20-day avg.
-/// Returns a static string: "surging", "increasing", "stable", "declining", "drying up",
-/// or "insufficient data".
+#[must_use]
 pub fn volume_trend(volumes: &[f64]) -> &'static str {
     if volumes.len() < 20 {
         return "insufficient data";
     }
-
     let avg5: f64 = volumes[volumes.len() - 5..].iter().sum::<f64>() / 5.0;
     let avg20: f64 = volumes[volumes.len() - 20..].iter().sum::<f64>() / 20.0;
-
-    if avg20 == 0.0 {
+    if avg20 < f64::EPSILON {
         return "insufficient data";
     }
-
     let ratio = avg5 / avg20;
-
     if ratio > 1.5 {
         "surging"
     } else if ratio > 1.1 {
@@ -33,32 +28,19 @@ mod tests {
     use super::*;
 
     #[test]
-    fn volume_stable() {
-        let volumes = vec![1000.0; 25];
-        assert_eq!(volume_trend(&volumes), "stable");
-    }
-
-    #[test]
-    fn volume_surging() {
-        let mut volumes = vec![100.0; 20];
-        // Last 5 are much higher
-        for _ in 0..5 {
-            volumes.push(500.0);
-        }
-        assert_eq!(volume_trend(&volumes), "surging");
+    fn stable() {
+        assert_eq!(volume_trend(&vec![1000.0; 25]), "stable");
     }
 
     #[test]
-    fn volume_drying_up() {
-        let mut volumes = vec![1000.0; 20];
-        for _ in 0..5 {
-            volumes.push(10.0);
-        }
-        assert_eq!(volume_trend(&volumes), "drying up");
+    fn surging() {
+        let mut v = vec![100.0; 20];
+        v.extend_from_slice(&[500.0; 5]);
+        assert_eq!(volume_trend(&v), "surging");
     }
 
     #[test]
-    fn volume_insufficient() {
+    fn insufficient() {
         assert_eq!(volume_trend(&[100.0; 10]), "insufficient data");
     }
 }

package/src/indicators/volume/vwap.rs

@@ -0,0 +1,53 @@
+use crate::core::utils::round;
+
+/// Volume Weighted Average Price.
+/// VWAP = sum(typical_price * volume) / sum(volume)
+/// where typical_price = (high + low + close) / 3
+#[must_use]
+pub fn vwap(highs: &[f64], lows: &[f64], closes: &[f64], volumes: &[f64]) -> Option<f64> {
+    let len = closes.len();
+    if len == 0 || highs.len() < len || lows.len() < len || volumes.len() < len {
+        return None;
+    }
+
+    let mut cum_tp_vol = 0.0;
+    let mut cum_vol = 0.0;
+
+    for i in 0..len {
+        let typical_price = (highs[i] + lows[i] + closes[i]) / 3.0;
+        cum_tp_vol += typical_price * volumes[i];
+        cum_vol += volumes[i];
+    }
+
+    if cum_vol < f64::EPSILON {
+        return None;
+    }
+
+    Some(round(cum_tp_vol / cum_vol, 2))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn vwap_basic() {
+        let highs = vec![12.0, 13.0, 14.0];
+        let lows = vec![10.0, 11.0, 12.0];
+        let closes = vec![11.0, 12.0, 13.0];
+        let volumes = vec![1000.0, 2000.0, 3000.0];
+        let result = vwap(&highs, &lows, &closes, &volumes).unwrap();
+        assert!(result > 11.0 && result < 14.0);
+    }
+
+    #[test]
+    fn vwap_zero_volume() {
+        assert!(vwap(&[10.0], &[10.0], &[10.0], &[0.0]).is_none());
+    }
+
+    #[test]
+    fn vwap_empty() {
+        let empty: Vec<f64> = vec![];
+        assert!(vwap(&empty, &empty, &empty, &empty).is_none());
+    }
+}

package/src/lib.rs

@@ -1,25 +1,75 @@
 //! # indica
 //!
 //! Fast technical analysis indicators for stock markets.
-//! SMA, EMA, RSI, MACD, Bollinger Bands, ATR, Pivot Points, and more.
-
-mod moving_avg;
-mod rsi;
-mod macd;
-mod bollinger;
-mod atr;
-mod pivot;
-mod volume;
-mod relative_strength;
-mod utils;
+//! Built for Indian markets. Screening to signals.
+//!
+//! ## Indicators
+//!
+//! **Trend:** SMA, EMA, Supertrend, ADX
+//! **Momentum:** RSI, MACD, Stochastic
+//! **Volatility:** Bollinger Bands, ATR
+//! **Volume:** OBV, VWAP, Volume Trend
+//! **Support/Resistance:** Pivot Points
+//! **India-Specific:** Delivery Analysis, Circuit Limits
+//!
+//! ## Usage
+//!
+//! ```rust
+//! use indica::{sma, rsi, supertrend};
+//! ```
+
 pub mod batch;
-mod napi_bindings;
-
-pub use moving_avg::{sma, ema};
-pub use rsi::rsi;
-pub use macd::{macd, MacdResult, Crossover};
-pub use bollinger::{bollinger_bands, BollingerBandsResult};
-pub use atr::atr;
-pub use pivot::{pivot_points, PivotPointsResult};
-pub use volume::volume_trend;
-pub use relative_strength::relative_strength;
+pub mod core;
+pub mod indicators;
+pub mod signals;
+
+// ── Backward-compatible convenience re-exports ──
+
+// Trend
+pub use indicators::trend::adx::adx;
+pub use indicators::trend::ema::ema;
+pub use indicators::trend::sma::sma;
+pub use indicators::trend::supertrend::{SupertrendDirection, SupertrendResult, supertrend};
+
+// Momentum
+pub use indicators::momentum::macd::{Crossover, MacdResult, macd};
+pub use indicators::momentum::rsi::rsi;
+pub use indicators::momentum::stochastic::{StochasticResult, stochastic};
+
+// Volatility
+pub use indicators::volatility::atr::atr;
+pub use indicators::volatility::bollinger::{BollingerBandsResult, bollinger_bands};
+
+// Volume
+pub use indicators::volume::obv::obv;
+pub use indicators::volume::volume_trend::volume_trend;
+pub use indicators::volume::vwap::vwap;
+
+// Support/Resistance
+pub use indicators::support_resistance::pivot::{PivotPointsResult, pivot_points};
+
+// India-specific
+pub use indicators::india::circuit::{CircuitLimit, CircuitStatus, circuit_proximity};
+pub use indicators::india::delivery::{DeliveryTrend, delivery_pct, delivery_trend};
+
+// Core types
+pub use core::traits::Indicator;
+pub use core::types::Candle;
+
+// Streaming indicator structs
+pub use indicators::momentum::rsi::Rsi;
+pub use indicators::trend::adx::Adx;
+pub use indicators::trend::ema::Ema;
+pub use indicators::trend::sma::Sma;
+pub use indicators::trend::supertrend::Supertrend;
+
+// Signals
+pub use signals::engine::{IndicatorValues, SignalEngine, SignalRule};
+pub use signals::presets::{momentum_trader, swing_trader};
+pub use signals::types::{Signal, SignalStrength, SignalVote};
+
+// Batch processing
+pub use batch::compute::{
+    IndicatorSnapshot, StockData, batch_compute, batch_compute_parallel, compute_snapshot,
+};
+pub use batch::screen::{ScreenFilter, ScreenResult, screen, screen_precomputed};

package/src/signals/engine.rs

@@ -0,0 +1,139 @@
+use crate::indicators::india::delivery::DeliveryTrend;
+use crate::indicators::momentum::macd::MacdResult;
+use crate::indicators::momentum::stochastic::StochasticResult;
+use crate::indicators::trend::supertrend::SupertrendResult;
+use crate::indicators::volatility::bollinger::BollingerBandsResult;
+
+use super::types::{Signal, SignalStrength, SignalVote};
+
+/// Snapshot of all computed indicator values for a single stock.
+#[derive(Debug, Clone, Default)]
+pub struct IndicatorValues {
+    pub rsi: Option<f64>,
+    pub macd: Option<MacdResult>,
+    pub supertrend: Option<SupertrendResult>,
+    pub bollinger: Option<BollingerBandsResult>,
+    pub volume_trend: String,
+    pub adx: Option<f64>,
+    pub stochastic: Option<StochasticResult>,
+    pub delivery_trend: Option<DeliveryTrend>,
+}
+
+/// Trait for individual signal rules.
+/// Each rule inspects indicator values and optionally casts a vote.
+pub trait SignalRule: Send + Sync {
+    fn evaluate(&self, snapshot: &IndicatorValues) -> Option<SignalVote>;
+}
+
+/// Engine that collects votes from multiple rules and produces a composite signal.
+pub struct SignalEngine {
+    rules: Vec<Box<dyn SignalRule>>,
+}
+
+impl SignalEngine {
+    pub fn new() -> Self {
+        Self { rules: Vec::new() }
+    }
+
+    /// Add a rule to the engine.
+    pub fn add_rule(&mut self, rule: Box<dyn SignalRule>) {
+        self.rules.push(rule);
+    }
+
+    /// Evaluate all rules against the given indicator values.
+    pub fn evaluate(&self, values: &IndicatorValues) -> Signal {
+        let votes: Vec<SignalVote> = self
+            .rules
+            .iter()
+            .filter_map(|rule| rule.evaluate(values))
+            .collect();
+
+        if votes.is_empty() {
+            return Signal {
+                strength: SignalStrength::Neutral,
+                confidence: 0.0,
+                reasons: vec!["No indicator data available".to_string()],
+            };
+        }
+
+        let total_weight: f64 = votes.iter().map(|v| v.weight).sum();
+        if total_weight < f64::EPSILON {
+            return Signal {
+                strength: SignalStrength::Neutral,
+                confidence: 0.0,
+                reasons: vec!["All weights are zero".to_string()],
+            };
+        }
+
+        // Weighted average score
+        let weighted_score: f64 = votes
+            .iter()
+            .map(|v| v.strength.score() * v.weight)
+            .sum::<f64>()
+            / total_weight;
+
+        let strength = if weighted_score >= 1.5 {
+            SignalStrength::StrongBuy
+        } else if weighted_score >= 0.5 {
+            SignalStrength::Buy
+        } else if weighted_score > -0.5 {
+            SignalStrength::Neutral
+        } else if weighted_score > -1.5 {
+            SignalStrength::Sell
+        } else {
+            SignalStrength::StrongSell
+        };
+
+        // Confidence = how much the votes agree (0..1)
+        // Perfect agreement = 1.0, evenly split = 0.0
+        let max_possible = 2.0; // max absolute score
+        let confidence = (weighted_score.abs() / max_possible).min(1.0);
+
+        let reasons: Vec<String> = votes.iter().map(|v| v.reason.clone()).collect();
+
+        Signal {
+            strength,
+            confidence,
+            reasons,
+        }
+    }
+}
+
+impl Default for SignalEngine {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    struct AlwaysBuy;
+    impl SignalRule for AlwaysBuy {
+        fn evaluate(&self, _snapshot: &IndicatorValues) -> Option<SignalVote> {
+            Some(SignalVote {
+                strength: SignalStrength::Buy,
+                weight: 1.0,
+                reason: "Always buy".to_string(),
+            })
+        }
+    }
+
+    #[test]
+    fn engine_single_rule() {
+        let mut engine = SignalEngine::new();
+        engine.add_rule(Box::new(AlwaysBuy));
+        let signal = engine.evaluate(&IndicatorValues::default());
+        assert_eq!(signal.strength, SignalStrength::Buy);
+        assert!(!signal.reasons.is_empty());
+    }
+
+    #[test]
+    fn engine_no_rules() {
+        let engine = SignalEngine::new();
+        let signal = engine.evaluate(&IndicatorValues::default());
+        assert_eq!(signal.strength, SignalStrength::Neutral);
+        assert_eq!(signal.confidence, 0.0);
+    }
+}

package/src/signals/mod.rs

@@ -0,0 +1,4 @@
+pub mod engine;
+pub mod presets;
+pub mod rules;
+pub mod types;

package/src/signals/presets.rs

@@ -0,0 +1,109 @@
+use super::engine::SignalEngine;
+use super::rules::{
+    AdxTrendRule, MacdCrossoverRule, RsiRule, StochasticRule, SupertrendRule, VolumeTrendRule,
+};
+
+/// Swing trader strategy: RSI + MACD + Supertrend + Volume.
+/// Best for multi-day holds on NSE/BSE.
+pub fn swing_trader() -> SignalEngine {
+    let mut engine = SignalEngine::new();
+    engine.add_rule(Box::new(RsiRule));
+    engine.add_rule(Box::new(MacdCrossoverRule));
+    engine.add_rule(Box::new(SupertrendRule));
+    engine.add_rule(Box::new(VolumeTrendRule));
+    engine
+}
+
+/// Momentum trader strategy: RSI + Stochastic + ADX + Volume.
+/// Best for short-term momentum plays.
+pub fn momentum_trader() -> SignalEngine {
+    let mut engine = SignalEngine::new();
+    engine.add_rule(Box::new(RsiRule));
+    engine.add_rule(Box::new(StochasticRule));
+    engine.add_rule(Box::new(AdxTrendRule));
+    engine.add_rule(Box::new(VolumeTrendRule));
+    engine
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::indicators::momentum::macd::{Crossover, MacdResult};
+    use crate::indicators::momentum::stochastic::StochasticResult;
+    use crate::indicators::trend::supertrend::{SupertrendDirection, SupertrendResult};
+    use crate::signals::engine::IndicatorValues;
+    use crate::signals::types::SignalStrength;
+
+    #[test]
+    fn swing_trader_bullish() {
+        let engine = swing_trader();
+        let vals = IndicatorValues {
+            rsi: Some(28.0),
+            macd: Some(MacdResult {
+                value: 1.0,
+                signal: 0.5,
+                histogram: 0.5,
+                crossover: Crossover::Bullish,
+            }),
+            supertrend: Some(SupertrendResult {
+                value: 95.0,
+                direction: SupertrendDirection::Up,
+            }),
+            volume_trend: "surging".to_string(),
+            ..Default::default()
+        };
+        let signal = engine.evaluate(&vals);
+        assert_eq!(signal.strength, SignalStrength::Buy);
+        assert!(signal.confidence > 0.0);
+        assert_eq!(signal.reasons.len(), 4);
+    }
+
+    #[test]
+    fn swing_trader_bearish() {
+        let engine = swing_trader();
+        let vals = IndicatorValues {
+            rsi: Some(75.0),
+            macd: Some(MacdResult {
+                value: -1.0,
+                signal: -0.5,
+                histogram: -0.5,
+                crossover: Crossover::Bearish,
+            }),
+            supertrend: Some(SupertrendResult {
+                value: 120.0,
+                direction: SupertrendDirection::Down,
+            }),
+            volume_trend: "declining".to_string(),
+            ..Default::default()
+        };
+        let signal = engine.evaluate(&vals);
+        assert_eq!(signal.strength, SignalStrength::Sell);
+        assert!(signal.confidence > 0.0);
+    }
+
+    #[test]
+    fn momentum_trader_bullish() {
+        let engine = momentum_trader();
+        let vals = IndicatorValues {
+            rsi: Some(25.0),
+            stochastic: Some(StochasticResult { k: 18.0, d: 15.0 }),
+            adx: Some(45.0),
+            volume_trend: "surging".to_string(),
+            ..Default::default()
+        };
+        let signal = engine.evaluate(&vals);
+        assert!(
+            signal.strength == SignalStrength::Buy || signal.strength == SignalStrength::StrongBuy
+        );
+        assert!(signal.confidence > 0.0);
+    }
+
+    #[test]
+    fn swing_trader_no_data() {
+        let engine = swing_trader();
+        let vals = IndicatorValues::default();
+        let signal = engine.evaluate(&vals);
+        // volume_trend defaults to "" which returns None from VolumeTrendRule
+        assert_eq!(signal.strength, SignalStrength::Neutral);
+    }
+}