@devanshhq/indica 0.1.0

package/src/batch.rs

@@ -0,0 +1,139 @@
+use crate::*;
+use rayon::prelude::*;
+
+/// Input data for a single stock.
+#[derive(Debug, Clone)]
+pub struct StockData {
+    pub symbol: String,
+    pub closes: Vec<f64>,
+    pub highs: Vec<f64>,
+    pub lows: Vec<f64>,
+    pub volumes: Vec<f64>,
+}
+
+/// All indicators computed for a single stock.
+#[derive(Debug, Clone)]
+pub struct IndicatorSnapshot {
+    pub symbol: String,
+    pub sma_20: Option<f64>,
+    pub sma_50: Option<f64>,
+    pub sma_200: Option<f64>,
+    pub ema_20: Option<f64>,
+    pub rsi_14: Option<f64>,
+    pub macd_result: Option<MacdResult>,
+    pub bollinger: Option<BollingerBandsResult>,
+    pub atr_14: Option<f64>,
+    pub volume_trend: String,
+}
+
+/// Compute all indicators for a single stock.
+pub fn compute_indicators(stock: &StockData) -> IndicatorSnapshot {
+    IndicatorSnapshot {
+        symbol: stock.symbol.clone(),
+        sma_20: sma(&stock.closes, 20),
+        sma_50: sma(&stock.closes, 50),
+        sma_200: sma(&stock.closes, 200),
+        ema_20: ema(&stock.closes, 20),
+        rsi_14: rsi(&stock.closes, 14),
+        macd_result: macd(&stock.closes, 12, 26, 9),
+        bollinger: bollinger_bands(&stock.closes, 20, 2.0),
+        atr_14: atr(&stock.highs, &stock.lows, &stock.closes, 14),
+        volume_trend: volume_trend(&stock.volumes).to_string(),
+    }
+}
+
+/// Compute indicators for multiple stocks sequentially.
+pub fn batch_compute(stocks: &[StockData]) -> Vec<IndicatorSnapshot> {
+    stocks.iter().map(compute_indicators).collect()
+}
+
+/// Compute indicators for multiple stocks in parallel using Rayon.
+/// Automatically distributes work across all CPU cores.
+pub fn batch_compute_parallel(stocks: &[StockData]) -> Vec<IndicatorSnapshot> {
+    stocks.par_iter().map(compute_indicators).collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn make_stock(symbol: &str, days: usize) -> StockData {
+        let closes: Vec<f64> = (0..days).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 volumes: Vec<f64> = vec![1_000_000.0; days];
+        StockData {
+            symbol: symbol.to_string(),
+            closes,
+            highs,
+            lows,
+            volumes,
+        }
+    }
+
+    #[test]
+    fn single_stock() {
+        let stock = make_stock("RELIANCE", 250);
+        let result = compute_indicators(&stock);
+        assert_eq!(result.symbol, "RELIANCE");
+        assert!(result.sma_20.is_some());
+        assert!(result.sma_50.is_some());
+        assert!(result.sma_200.is_some());
+        assert!(result.rsi_14.is_some());
+        assert!(result.macd_result.is_some());
+        assert!(result.bollinger.is_some());
+        assert!(result.atr_14.is_some());
+        assert_eq!(result.volume_trend, "stable");
+    }
+
+    #[test]
+    fn batch_multiple() {
+        let stocks: Vec<StockData> = ["RELIANCE", "TCS", "INFY", "SBIN", "HDFCBANK"]
+            .iter()
+            .map(|s| make_stock(s, 250))
+            .collect();
+
+        let results = batch_compute(&stocks);
+        assert_eq!(results.len(), 5);
+        assert_eq!(results[0].symbol, "RELIANCE");
+        assert_eq!(results[4].symbol, "HDFCBANK");
+    }
+
+    #[test]
+    fn batch_2000_stocks() {
+        let stocks: Vec<StockData> = (0..2000)
+            .map(|i| make_stock(&format!("STOCK{}", i), 250))
+            .collect();
+
+        let start = std::time::Instant::now();
+        let results = batch_compute(&stocks);
+        let elapsed = start.elapsed();
+
+        assert_eq!(results.len(), 2000);
+        println!("2000 stocks sequential: {:?}", elapsed);
+    }
+
+    #[test]
+    fn batch_2000_parallel() {
+        let stocks: Vec<StockData> = (0..2000)
+            .map(|i| make_stock(&format!("STOCK{}", i), 250))
+            .collect();
+
+        let start = std::time::Instant::now();
+        let results = batch_compute_parallel(&stocks);
+        let elapsed = start.elapsed();
+
+        assert_eq!(results.len(), 2000);
+        println!("2000 stocks parallel:   {:?}", elapsed);
+    }
+
+    #[test]
+    fn insufficient_data_stock() {
+        let stock = make_stock("NEWIPO", 10);
+        let result = compute_indicators(&stock);
+        assert_eq!(result.symbol, "NEWIPO");
+        assert!(result.sma_20.is_none());
+        assert!(result.rsi_14.is_none());
+        assert!(result.macd_result.is_none());
+    }
+}

package/src/bollinger.rs

@@ -0,0 +1,73 @@
+use crate::utils::round;
+
+/// Bollinger Bands result.
+#[derive(Debug, Clone)]
+pub struct BollingerBandsResult {
+    pub upper: f64,
+    pub middle: f64,
+    pub lower: f64,
+    pub percent_b: f64,
+}
+
+/// Bollinger Bands (default: period=20, std_dev_multiplier=2.0).
+/// Returns `None` if insufficient data.
+pub fn bollinger_bands(
+    closes: &[f64],
+    period: usize,
+    std_dev_multiplier: f64,
+) -> Option<BollingerBandsResult> {
+    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 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 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),
+        lower: round(lower, 2),
+        percent_b: round(percent_b, 2),
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn bb_basic() {
+        let closes: Vec<f64> = (1..=20).map(|i| i as f64).collect();
+        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() {
+        assert!(bollinger_bands(&[1.0; 5], 20, 2.0).is_none());
+    }
+}

package/src/lib.rs

@@ -0,0 +1,25 @@
+//! # 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;
+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;

package/src/macd.rs

@@ -0,0 +1,132 @@
+use crate::utils::round;
+
+/// MACD crossover direction.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Crossover {
+    Bullish,
+    Bearish,
+    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).
+/// Default parameters: fast=12, slow=26, signal=9.
+/// Returns `None` if insufficient data.
+pub fn macd(
+    closes: &[f64],
+    fast_period: usize,
+    slow_period: usize,
+    signal_period: usize,
+) -> Option<MacdResult> {
+    if closes.len() < slow_period + signal_period || slow_period == 0 {
+        return None;
+    }
+
+    let k_fast = 2.0 / (fast_period as f64 + 1.0);
+    let k_slow = 2.0 / (slow_period as f64 + 1.0);
+
+    let mut ema_slow: f64 = closes[..slow_period].iter().sum::<f64>() / slow_period as f64;
+
+    // Seed fast EMA and advance it to slow_period point
+    let mut ema_fast: f64 = closes[..fast_period].iter().sum::<f64>() / fast_period as f64;
+    for i in fast_period..slow_period {
+        ema_fast = closes[i] * k_fast + ema_fast * (1.0 - k_fast);
+    }
+
+    let mut macd_line = Vec::new();
+    for i in slow_period..closes.len() {
+        ema_fast = closes[i] * k_fast + ema_fast * (1.0 - k_fast);
+        ema_slow = closes[i] * k_slow + ema_slow * (1.0 - k_slow);
+        macd_line.push(ema_fast - ema_slow);
+    }
+
+    if macd_line.len() < signal_period {
+        return None;
+    }
+
+    // Signal line = EMA of MACD line
+    let k_signal = 2.0 / (signal_period as f64 + 1.0);
+    let mut signal_line: f64 =
+        macd_line[..signal_period].iter().sum::<f64>() / signal_period as f64;
+
+    let mut prev_signal = signal_line;
+    for i in signal_period..macd_line.len() {
+        prev_signal = signal_line;
+        signal_line = macd_line[i] * k_signal + signal_line * (1.0 - k_signal);
+    }
+
+    let current_macd = *macd_line.last().unwrap();
+    let histogram = current_macd - signal_line;
+
+    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::None
+    };
+
+    Some(MacdResult {
+        value: round(current_macd, 2),
+        signal: round(signal_line, 2),
+        histogram: round(histogram, 2),
+        crossover,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn trending_up() -> Vec<f64> {
+        (0..50).map(|i| 100.0 + i as f64 * 0.5).collect()
+    }
+
+    fn trending_down() -> Vec<f64> {
+        (0..50).map(|i| 150.0 - i as f64 * 0.5).collect()
+    }
+
+    #[test]
+    fn macd_trending_up() {
+        let result = macd(&trending_up(), 12, 26, 9).unwrap();
+        assert!(result.value > 0.0, "MACD should be positive in uptrend");
+        assert!(result.histogram > 0.0 || result.histogram.abs() < 0.5);
+    }
+
+    #[test]
+    fn macd_trending_down() {
+        let result = macd(&trending_down(), 12, 26, 9).unwrap();
+        assert!(result.value < 0.0, "MACD should be negative in downtrend");
+    }
+
+    #[test]
+    fn macd_insufficient_data() {
+        assert!(macd(&[1.0; 20], 12, 26, 9).is_none());
+    }
+
+    #[test]
+    fn macd_crossover_detection() {
+        // Flat then up — should eventually get bullish crossover
+        let mut data: Vec<f64> = vec![100.0; 35];
+        for i in 0..20 {
+            data.push(100.0 + i as f64 * 2.0);
+        }
+        let result = macd(&data, 12, 26, 9);
+        assert!(result.is_some());
+    }
+}

package/src/moving_avg.rs

@@ -0,0 +1,71 @@
+/// Simple Moving Average of the last `period` values.
+/// Returns `None` if there are fewer values than `period`.
+pub fn sma(values: &[f64], period: usize) -> Option<f64> {
+    if values.len() < period || period == 0 {
+        return None;
+    }
+    let slice = &values[values.len() - period..];
+    let sum: f64 = slice.iter().sum();
+    Some(sum / period as f64)
+}
+
+/// Exponential Moving Average.
+/// Seeded with SMA of the first `period` values, then smoothed forward.
+/// Returns `None` if there are fewer values than `period`.
+pub fn ema(values: &[f64], period: usize) -> Option<f64> {
+    if values.len() < period || period == 0 {
+        return None;
+    }
+    let k = 2.0 / (period as f64 + 1.0);
+    let seed: f64 = values[..period].iter().sum::<f64>() / period as f64;
+    let result = values[period..].iter().fold(seed, |prev, &val| {
+        val * k + prev * (1.0 - k)
+    });
+    Some(result)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn sma_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_insufficient_data() {
+        assert_eq!(sma(&[1.0, 2.0], 5), None);
+        assert_eq!(sma(&[], 1), None);
+    }
+
+    #[test]
+    fn sma_period_one() {
+        assert_eq!(sma(&[42.0, 99.0], 1), Some(99.0));
+    }
+
+    #[test]
+    fn ema_basic() {
+        let data = vec![10.0, 11.0, 12.0, 13.0, 14.0, 15.0];
+        let result = ema(&data, 3).unwrap();
+        // EMA(3) of [10,11,12,13,14,15]:
+        // Seed = avg(10,11,12) = 11.0, k = 0.5
+        // 13*0.5 + 11*0.5 = 12.0
+        // 14*0.5 + 12*0.5 = 13.0
+        // 15*0.5 + 13*0.5 = 14.0
+        assert!((result - 14.0).abs() < 0.01);
+    }
+
+    #[test]
+    fn ema_insufficient_data() {
+        assert_eq!(ema(&[1.0], 5), None);
+    }
+
+    #[test]
+    fn ema_equals_sma_at_period_length() {
+        let data = vec![10.0, 20.0, 30.0];
+        // With exactly `period` values, EMA seed = SMA and no further smoothing
+        assert_eq!(ema(&data, 3), sma(&data, 3));
+    }
+}

package/src/napi_bindings.rs

@@ -0,0 +1,166 @@
+use napi_derive::napi;
+use crate::batch::{StockData, batch_compute_parallel};
+
+// ── Simple indicator functions (for single stock use) ──
+
+#[napi]
+pub fn calc_sma(values: Vec<f64>, period: u32) -> Option<f64> {
+    crate::sma(&values, period as usize)
+}
+
+#[napi]
+pub fn calc_ema(values: Vec<f64>, period: u32) -> Option<f64> {
+    crate::ema(&values, period as usize)
+}
+
+#[napi]
+pub fn calc_rsi(closes: Vec<f64>, period: u32) -> Option<f64> {
+    crate::rsi(&closes, period as usize)
+}
+
+#[napi]
+pub fn calc_atr(highs: Vec<f64>, lows: Vec<f64>, closes: Vec<f64>, period: u32) -> Option<f64> {
+    crate::atr(&highs, &lows, &closes, period as usize)
+}
+
+#[napi]
+pub fn calc_volume_trend(volumes: Vec<f64>) -> String {
+    crate::volume_trend(&volumes).to_string()
+}
+
+#[napi]
+pub fn calc_relative_strength(stock: Vec<f64>, benchmark: Vec<f64>, period: u32) -> Option<f64> {
+    crate::relative_strength(&stock, &benchmark, period as usize)
+}
+
+// ── Struct results (returned as JS objects) ──
+
+#[napi(object)]
+pub struct JsMacdResult {
+    pub value: f64,
+    pub signal: f64,
+    pub histogram: f64,
+    pub crossover: String,
+}
+
+#[napi]
+pub fn calc_macd(closes: Vec<f64>, fast: u32, slow: u32, signal: u32) -> Option<JsMacdResult> {
+    crate::macd(&closes, fast as usize, slow as usize, signal as usize).map(|r| JsMacdResult {
+        value: r.value,
+        signal: r.signal,
+        histogram: r.histogram,
+        crossover: match r.crossover {
+            crate::Crossover::Bullish => "bullish".to_string(),
+            crate::Crossover::Bearish => "bearish".to_string(),
+            crate::Crossover::None => "none".to_string(),
+        },
+    })
+}
+
+#[napi(object)]
+pub struct JsBollingerBands {
+    pub upper: f64,
+    pub middle: f64,
+    pub lower: f64,
+    pub percent_b: f64,
+}
+
+#[napi]
+pub fn calc_bollinger_bands(closes: Vec<f64>, period: u32, std_dev: f64) -> Option<JsBollingerBands> {
+    crate::bollinger_bands(&closes, period as usize, std_dev).map(|r| JsBollingerBands {
+        upper: r.upper,
+        middle: r.middle,
+        lower: r.lower,
+        percent_b: r.percent_b,
+    })
+}
+
+#[napi(object)]
+pub struct JsPivotPoints {
+    pub r3: f64,
+    pub r2: f64,
+    pub r1: f64,
+    pub pivot: f64,
+    pub s1: f64,
+    pub s2: f64,
+    pub s3: f64,
+}
+
+#[napi]
+pub fn calc_pivot_points(high: f64, low: f64, close: f64) -> JsPivotPoints {
+    let r = crate::pivot_points(high, low, close);
+    JsPivotPoints {
+        r3: r.r3, r2: r.r2, r1: r.r1,
+        pivot: r.pivot,
+        s1: r.s1, s2: r.s2, s3: r.s3,
+    }
+}
+
+// ── Batch processing (the main payoff) ──
+
+#[napi(object)]
+pub struct JsStockData {
+    pub symbol: String,
+    pub closes: Vec<f64>,
+    pub highs: Vec<f64>,
+    pub lows: Vec<f64>,
+    pub volumes: Vec<f64>,
+}
+
+#[napi(object)]
+pub struct JsIndicatorSnapshot {
+    pub symbol: String,
+    pub sma_20: Option<f64>,
+    pub sma_50: Option<f64>,
+    pub sma_200: Option<f64>,
+    pub ema_20: Option<f64>,
+    pub rsi_14: Option<f64>,
+    pub macd: Option<JsMacdResult>,
+    pub bollinger: Option<JsBollingerBands>,
+    pub atr_14: Option<f64>,
+    pub volume_trend: String,
+}
+
+#[napi]
+pub fn batch_compute_indicators(stocks: Vec<JsStockData>) -> Vec<JsIndicatorSnapshot> {
+    let stock_data: Vec<StockData> = stocks
+        .into_iter()
+        .map(|s| StockData {
+            symbol: s.symbol,
+            closes: s.closes,
+            highs: s.highs,
+            lows: s.lows,
+            volumes: s.volumes,
+        })
+        .collect();
+
+    batch_compute_parallel(&stock_data)
+        .into_iter()
+        .map(|snap| JsIndicatorSnapshot {
+            symbol: snap.symbol,
+            sma_20: snap.sma_20,
+            sma_50: snap.sma_50,
+            sma_200: snap.sma_200,
+            ema_20: snap.ema_20,
+            rsi_14: snap.rsi_14,
+            macd: snap.macd_result.map(|m| JsMacdResult {
+                value: m.value,
+                signal: m.signal,
+                histogram: m.histogram,
+                crossover: match m.crossover {
+                    crate::Crossover::Bullish => "bullish".to_string(),
+                    crate::Crossover::Bearish => "bearish".to_string(),
+                    crate::Crossover::None => "none".to_string(),
+                },
+            }),
+            bollinger: snap.bollinger.map(|b| JsBollingerBands {
+                upper: b.upper,
+                middle: b.middle,
+                lower: b.lower,
+                percent_b: b.percent_b,
+            }),
+            atr_14: snap.atr_14,
+            volume_trend: snap.volume_trend,
+        })
+        .collect()
+}

package/src/pivot.rs

@@ -0,0 +1,58 @@
+use crate::utils::round;
+
+/// Classic Pivot Points result.
+#[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 (typically previous day).
+pub fn pivot_points(high: f64, low: f64, close: f64) -> PivotPointsResult {
+    let pivot = (high + low + close) / 3.0;
+    let r1 = 2.0 * pivot - low;
+    let s1 = 2.0 * pivot - high;
+    let r2 = pivot + (high - low);
+    let s2 = pivot - (high - low);
+    let r3 = high + 2.0 * (pivot - low);
+    let s3 = low - 2.0 * (high - pivot);
+
+    PivotPointsResult {
+        r3: round(r3, 2),
+        r2: round(r2, 2),
+        r1: round(r1, 2),
+        pivot: round(pivot, 2),
+        s1: round(s1, 2),
+        s2: round(s2, 2),
+        s3: round(s3, 2),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn pivot_basic() {
+        let result = pivot_points(110.0, 90.0, 100.0);
+        assert_eq!(result.pivot, 100.0);
+        assert!(result.r1 > result.pivot);
+        assert!(result.r2 > result.r1);
+        assert!(result.r3 > result.r2);
+        assert!(result.s1 < result.pivot);
+        assert!(result.s2 < result.s1);
+        assert!(result.s3 < result.s2);
+    }
+
+    #[test]
+    fn pivot_symmetry() {
+        // When close == midpoint of range, pivot = close
+        let result = pivot_points(110.0, 90.0, 100.0);
+        assert_eq!(result.pivot, 100.0);
+    }
+}