@devanshhq/indica 0.1.0

package/src/relative_strength.rs

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

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

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

package/src/volume.rs

@@ -0,0 +1,64 @@
+/// 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".
+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 {
+        return "insufficient data";
+    }
+
+    let ratio = avg5 / avg20;
+
+    if ratio > 1.5 {
+        "surging"
+    } else if ratio > 1.1 {
+        "increasing"
+    } else if ratio > 0.9 {
+        "stable"
+    } else if ratio > 0.5 {
+        "declining"
+    } else {
+        "drying up"
+    }
+}
+
+#[cfg(test)]
+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");
+    }
+
+    #[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");
+    }
+
+    #[test]
+    fn volume_insufficient() {
+        assert_eq!(volume_trend(&[100.0; 10]), "insufficient data");
+    }
+}