@devanshhq/indica 0.1.0 → 0.2.0

package/src/macd.rs

@@ -1,132 +0,0 @@
-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

@@ -1,71 +0,0 @@
-/// 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

@@ -1,166 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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);
-    }
-}

package/src/relative_strength.rs

@@ -1,67 +0,0 @@
-use crate::utils::round;
-
-/// Relative Strength vs a benchmark (e.g., Nifty 50).
-/// RS = 1 + (stock_return - benchmark_return).
-/// Returns >1 if outperforming, <1 if underperforming.
-/// Returns `None` if insufficient data.
-pub fn relative_strength(
-    stock_closes: &[f64],
-    benchmark_closes: &[f64],
-    period: usize,
-) -> Option<f64> {
-    if stock_closes.len() < period || benchmark_closes.len() < period || period == 0 {
-        return None;
-    }
-
-    let stock_start = stock_closes[stock_closes.len() - period];
-    let stock_end = *stock_closes.last().unwrap();
-    let bench_start = benchmark_closes[benchmark_closes.len() - period];
-    let bench_end = *benchmark_closes.last().unwrap();
-
-    if stock_start == 0.0 || bench_start == 0.0 {
-        return None;
-    }
-
-    let stock_return = (stock_end - stock_start) / stock_start;
-    let bench_return = (bench_end - bench_start) / bench_start;
-
-    if bench_return == 0.0 {
-        return Some(if stock_return > 0.0 { 2.0 } else { 0.0 });
-    }
-
-    Some(round(1.0 + (stock_return - bench_return), 2))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn rs_outperforming() {
-        let stock = vec![100.0, 110.0, 120.0]; // +20%
-        let bench = vec![100.0, 105.0, 110.0]; // +10%
-        let result = relative_strength(&stock, &bench, 3).unwrap();
-        assert!(result > 1.0); // Stock beat benchmark
-    }
-
-    #[test]
-    fn rs_underperforming() {
-        let stock = vec![100.0, 95.0, 90.0];  // -10%
-        let bench = vec![100.0, 105.0, 110.0]; // +10%
-        let result = relative_strength(&stock, &bench, 3).unwrap();
-        assert!(result < 1.0); // Stock lagged benchmark
-    }
-
-    #[test]
-    fn rs_equal_performance() {
-        let stock = vec![100.0, 110.0]; // +10%
-        let bench = vec![100.0, 110.0]; // +10%
-        let result = relative_strength(&stock, &bench, 2).unwrap();
-        assert_eq!(result, 1.0);
-    }
-
-    #[test]
-    fn rs_insufficient_data() {
-        assert!(relative_strength(&[100.0], &[100.0], 5).is_none());
-    }
-}

package/src/rsi.rs

@@ -1,74 +0,0 @@
-/// Relative Strength Index using Wilder's smoothing.
-/// Default period is typically 14.
-/// Returns `None` if insufficient data (need at least `period + 1` values).
-pub fn rsi(closes: &[f64], period: usize) -> Option<f64> {
-    if closes.len() < period + 1 || period == 0 {
-        return None;
-    }
-
-    let mut avg_gain = 0.0;
-    let mut avg_loss = 0.0;
-
-    // Initial average gain/loss from first `period` changes
-    for i in 1..=period {
-        let change = closes[i] - closes[i - 1];
-        if change > 0.0 {
-            avg_gain += change;
-        } else {
-            avg_loss += change.abs();
-        }
-    }
-    avg_gain /= period as f64;
-    avg_loss /= period as f64;
-
-    // Wilder's smoothing for remaining values
-    for i in (period + 1)..closes.len() {
-        let change = closes[i] - closes[i - 1];
-        let gain = if change > 0.0 { change } else { 0.0 };
-        let loss = if change < 0.0 { change.abs() } else { 0.0 };
-        avg_gain = (avg_gain * (period as f64 - 1.0) + gain) / period as f64;
-        avg_loss = (avg_loss * (period as f64 - 1.0) + loss) / period as f64;
-    }
-
-    if avg_loss == 0.0 {
-        return Some(100.0);
-    }
-
-    let rs = avg_gain / avg_loss;
-    Some(100.0 - 100.0 / (1.0 + rs))
-}
-
-#[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); // Near 0
-    }
-
-    #[test]
-    fn rsi_midrange() {
-        // Alternating up/down should be near 50
-        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_data() {
-        assert_eq!(rsi(&[100.0, 101.0], 14), None);
-        assert_eq!(rsi(&[], 14), None);
-    }
-}

package/src/utils.rs

@@ -1,17 +0,0 @@
-/// 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
-}
-
-#[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);
-        assert_eq!(round(100.0, 2), 100.0);
-    }
-}