@devanshhq/indica 0.1.0 → 0.2.0

package/README.md

@@ -1,160 +1,149 @@
 # indica
 
-Fast technical analysis indicators for stock markets. Built in Rust.
+Fast technical analysis indicators for stock markets. Built in Rust. Built for Indian markets.
 
-[![Crates.io](https://img.shields.io/crates/v/indica)](https://crates.io/crates/indica)
+[![npm](https://img.shields.io/npm/v/@devanshhq/indica)](https://www.npmjs.com/package/@devanshhq/indica)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![CI](https://github.com/Devansh-365/indica/actions/workflows/ci.yml/badge.svg)](https://github.com/Devansh-365/indica/actions)
 
 ## Why
 
 JavaScript/Python TA libraries are slow when screening thousands of stocks. indica computes all indicators for **2,000 stocks in 6ms** using Rust + Rayon parallelism.
 
-| Stocks | Sequential | Parallel (Rayon) |
-|--------|-----------|-----------------|
-| 100 | 0.5ms | 0.3ms |
-| 2,000 | 11ms | 6ms |
+No other TA library has India-specific indicators (delivery volume analysis, circuit limit detection).
 
-## Indicators
+## Indicators (16)
 
-- **SMA** — Simple Moving Average
-- **EMA** — Exponential Moving Average
-- **RSI** — Relative Strength Index (Wilder's smoothing)
-- **MACD** — Moving Average Convergence Divergence with crossover detection
-- **Bollinger Bands** — Upper, middle, lower bands + %B
-- **ATR** — Average True Range (Wilder's smoothing)
-- **Pivot Points** — Classic (R3/R2/R1/Pivot/S1/S2/S3)
-- **Volume Trend** — Surging / increasing / stable / declining / drying up
-- **Relative Strength** — Stock vs benchmark comparison
+| Category | Indicators |
+|----------|-----------|
+| **Trend** | SMA, EMA, Supertrend, ADX |
+| **Momentum** | RSI, MACD (with crossover), Stochastic (%K/%D) |
+| **Volatility** | Bollinger Bands (%B), ATR |
+| **Volume** | OBV, VWAP, Volume Trend |
+| **Support/Resistance** | Classic Pivot Points (R3-S3) |
+| **India-Specific** | Delivery % Analysis, Circuit Limit Proximity |
 
 ## Installation
 
-### Rust
-
 ```toml
+# Rust
 [dependencies]
 indica = "0.1"
 ```
 
-### Node.js (via NAPI-RS)
+## Quick Start
 
-```bash
-npm install indica
+```rust
+use indica::{sma, rsi, macd, supertrend, bollinger_bands, stochastic, vwap, obv};
+
+let closes = vec![44.34, 44.09, 44.15, 43.61, 44.33, 44.83, 45.10,
+                  45.42, 45.84, 46.08, 45.89, 46.03, 45.61, 46.28,
+                  46.28, 46.00, 46.03, 46.41, 46.22, 46.21];
+
+sma(&closes, 20);                           // Some(45.52)
+rsi(&closes, 14);                           // Some(55.37)
+macd(&closes, 12, 26, 9);                   // Some(MacdResult { crossover: Bullish, ... })
+bollinger_bands(&closes, 20, 2.0);          // Some(BollingerBandsResult { upper, lower, %B })
+stochastic(&highs, &lows, &closes, 14, 3); // Some(StochasticResult { k, d })
+supertrend(&highs, &lows, &closes, 10, 3.0); // Some(SupertrendResult { direction: Up })
+vwap(&highs, &lows, &closes, &volumes);    // Some(245.67)
+obv(&closes, &volumes);                     // Some(1234567.0)
 ```
 
-## Usage (Rust)
+## Streaming API (real-time)
 
-```rust
-use indica::{sma, rsi, macd, bollinger_bands, atr, pivot_points};
-
-fn main() {
-    let closes = vec![44.34, 44.09, 44.15, 43.61, 44.33, 44.83, 45.10,
-                      45.42, 45.84, 46.08, 45.89, 46.03, 45.61, 46.28,
-                      46.28, 46.00, 46.03, 46.41, 46.22, 46.21];
+Feed candles one at a time — O(1) updates, no recomputation:
 
-    // Simple Moving Average
-    let sma_20 = sma(&closes, 20);
-    println!("SMA(20): {:?}", sma_20); // Some(45.52)
+```rust
+use indica::{Rsi, Sma, Candle, Indicator};
 
-    // RSI
-    let rsi_14 = rsi(&closes, 14);
-    println!("RSI(14): {:?}", rsi_14); // Some(55.37)
+let mut rsi = Rsi::new(14);
+let mut sma = Sma::new(20);
 
-    // MACD
-    if let Some(result) = macd(&closes, 12, 26, 9) {
-        println!("MACD: {}, Signal: {}, Crossover: {:?}",
-            result.value, result.signal, result.crossover);
+for candle in live_feed {
+    if let Some(value) = rsi.update(&candle) {
+        println!("RSI: {:.1}", value);
     }
-
-    // Bollinger Bands
-    if let Some(bb) = bollinger_bands(&closes, 20, 2.0) {
-        println!("BB Upper: {}, Lower: {}, %B: {}", bb.upper, bb.lower, bb.percent_b);
+    if let Some(value) = sma.update(&candle) {
+        println!("SMA: {:.2}", value);
     }
 }
 ```
 
-## Batch Processing (screen thousands of stocks)
+Available streaming indicators: `Sma`, `Ema`, `Rsi`, `Supertrend`, `Adx`
 
-```rust
-use indica::batch::{StockData, batch_compute_parallel};
-
-let stocks = vec![
-    StockData {
-        symbol: "RELIANCE".to_string(),
-        closes: vec![/* 250 daily closes */],
-        highs: vec![/* ... */],
-        lows: vec![/* ... */],
-        volumes: vec![/* ... */],
-    },
-    // ... 2000 more stocks
-];
-
-// Computes ALL indicators for ALL stocks using all CPU cores
-let results = batch_compute_parallel(&stocks);
-
-for snap in &results {
-    println!("{}: RSI={:?}, SMA20={:?}", snap.symbol, snap.rsi_14, snap.sma_20);
-}
-```
+## India-Specific Indicators
 
-## Usage (Node.js)
+Indicators that only work with Indian market data (NSE/BSE):
 
-```javascript
-const { calcRsi, calcMacd, batchComputeIndicators } = require('indica');
+```rust
+use indica::{delivery_pct, delivery_trend, circuit_proximity, CircuitLimit};
 
-// Single indicator
-const rsi = calcRsi([44.34, 44.09, /* ... */], 14);
-console.log('RSI:', rsi); // 55.37
+// Delivery Volume Analysis (unique to NSE/BSE)
+let pct = delivery_pct(500_000.0, 1_000_000.0); // 50.0%
 
-// MACD with crossover detection
-const macd = calcMacd(closes, 12, 26, 9);
-console.log(macd); // { value: 0.34, signal: 0.28, histogram: 0.06, crossover: 'bullish' }
+// Delivery trend: high delivery + price up = genuine buying
+let trend = delivery_trend(&delivery_pcts, &closes, 3, 10);
+// Some(DeliveryTrend::Accumulation)
 
-// Batch: screen 2000 stocks at once
-const results = batchComputeIndicators([
-  { symbol: 'RELIANCE', closes: [...], highs: [...], lows: [...], volumes: [...] },
-  { symbol: 'TCS', closes: [...], highs: [...], lows: [...], volumes: [...] },
-  // ... thousands more
-]);
-// Returns in ~6ms using all CPU cores
+// Circuit Limit Proximity
+let status = circuit_proximity(108.0, 100.0, CircuitLimit::Percent10);
+// CircuitStatus { upper_limit: 110.0, near_upper: false, ... }
 ```
 
-## API Reference
-
-### Single Indicators
-
-| Function | Input | Output |
-|----------|-------|--------|
-| `sma(values, period)` | `&[f64], usize` | `Option<f64>` |
-| `ema(values, period)` | `&[f64], usize` | `Option<f64>` |
-| `rsi(closes, period)` | `&[f64], usize` | `Option<f64>` |
-| `macd(closes, fast, slow, signal)` | `&[f64], usize, usize, usize` | `Option<MacdResult>` |
-| `bollinger_bands(closes, period, std_dev)` | `&[f64], usize, f64` | `Option<BollingerBandsResult>` |
-| `atr(highs, lows, closes, period)` | `&[f64], &[f64], &[f64], usize` | `Option<f64>` |
-| `pivot_points(high, low, close)` | `f64, f64, f64` | `PivotPointsResult` |
-| `volume_trend(volumes)` | `&[f64]` | `&str` |
-| `relative_strength(stock, bench, period)` | `&[f64], &[f64], usize` | `Option<f64>` |
+## Architecture
 
-### Batch
-
-| Function | Input | Output |
-|----------|-------|--------|
-| `batch_compute(stocks)` | `&[StockData]` | `Vec<IndicatorSnapshot>` |
-| `batch_compute_parallel(stocks)` | `&[StockData]` | `Vec<IndicatorSnapshot>` |
+```
+src/
+├── core/               ← Candle, Indicator trait, utils
+├── indicators/
+│   ├── trend/          ← SMA, EMA, Supertrend, ADX
+│   ├── momentum/       ← RSI, MACD, Stochastic
+│   ├── volatility/     ← Bollinger Bands, ATR
+│   ├── volume/         ← OBV, VWAP, Volume Trend
+│   ├── support_resistance/ ← Pivot Points
+│   └── india/          ← Delivery Analysis, Circuit Limits
+├── signals/            ← Signal engine (Buy/Sell with confidence)
+└── batch/              ← Parallel batch processing + screening
+```
 
-All functions return `Option` (Rust's null) when there isn't enough data for the calculation. No panics, no NaN.
+## API Reference
 
-## Building from Source
+### Convenience Functions
+
+| Function | Returns |
+|----------|---------|
+| `sma(closes, period)` | `Option<f64>` |
+| `ema(closes, period)` | `Option<f64>` |
+| `rsi(closes, period)` | `Option<f64>` |
+| `macd(closes, fast, slow, signal)` | `Option<MacdResult>` |
+| `stochastic(highs, lows, closes, k, d)` | `Option<StochasticResult>` |
+| `bollinger_bands(closes, period, mult)` | `Option<BollingerBandsResult>` |
+| `atr(highs, lows, closes, period)` | `Option<f64>` |
+| `supertrend(highs, lows, closes, period, mult)` | `Option<SupertrendResult>` |
+| `adx(highs, lows, closes, period)` | `Option<f64>` |
+| `obv(closes, volumes)` | `Option<f64>` |
+| `vwap(highs, lows, closes, volumes)` | `Option<f64>` |
+| `volume_trend(volumes)` | `&str` |
+| `pivot_points(high, low, close)` | `PivotPointsResult` |
+| `delivery_pct(delivery_vol, total_vol)` | `f64` |
+| `delivery_trend(pcts, closes, short, long)` | `Option<DeliveryTrend>` |
+| `circuit_proximity(price, prev_close, limit)` | `CircuitStatus` |
+
+All functions return `Option` when there isn't enough data. No panics, no NaN.
+
+## Building
 
 ```bash
-# Rust library
 cargo build --release
 cargo test
-
-# Node.js native addon
-npm install
-npm run build
+cargo clippy -- -D warnings
 ```
 
+## Contributing
+
+PRs welcome. Run `cargo test && cargo clippy -- -D warnings && cargo fmt --check` before submitting.
+
 ## License
 
 MIT

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@devanshhq/indica",
-  "version": "0.1.0",
-  "description": "Fast technical analysis indicators for stock markets. Built in Rust.",
+  "version": "0.2.0",
+  "description": "Fast technical analysis indicators for Indian stock markets. 16 indicators, signal engine, batch screening.",
   "main": "index.js",
   "types": "index.d.ts",
   "repository": "https://github.com/Devansh-365/indica",

package/src/batch/compute.rs

@@ -0,0 +1,165 @@
+use rayon::prelude::*;
+
+use crate::indicators::india::delivery::{DeliveryTrend, delivery_pct, delivery_trend};
+use crate::indicators::momentum::macd::{MacdResult, macd};
+use crate::indicators::momentum::rsi::rsi;
+use crate::indicators::momentum::stochastic::{StochasticResult, stochastic};
+use crate::indicators::trend::adx::adx;
+use crate::indicators::trend::ema::ema;
+use crate::indicators::trend::sma::sma;
+use crate::indicators::trend::supertrend::{SupertrendResult, supertrend};
+use crate::indicators::volatility::atr::atr;
+use crate::indicators::volatility::bollinger::{BollingerBandsResult, bollinger_bands};
+use crate::indicators::volume::obv::obv;
+use crate::indicators::volume::volume_trend::volume_trend;
+use crate::indicators::volume::vwap::vwap;
+
+/// Input data for one stock.
+#[derive(Debug, Clone)]
+pub struct StockData {
+    pub symbol: String,
+    pub opens: Vec<f64>,
+    pub highs: Vec<f64>,
+    pub lows: Vec<f64>,
+    pub closes: Vec<f64>,
+    pub volumes: Vec<f64>,
+    /// Delivery volumes (NSE/BSE specific). Optional.
+    pub delivery_volumes: Option<Vec<f64>>,
+}
+
+/// Complete indicator snapshot for a single stock.
+#[derive(Debug, Clone)]
+pub struct IndicatorSnapshot {
+    pub symbol: String,
+    pub sma_20: 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 supertrend: Option<SupertrendResult>,
+    pub stochastic: Option<StochasticResult>,
+    pub adx_14: Option<f64>,
+    pub obv: Option<f64>,
+    pub vwap: Option<f64>,
+    pub volume_trend: String,
+    pub delivery_trend: Option<DeliveryTrend>,
+}
+
+/// Compute all indicators for a single stock.
+pub fn compute_snapshot(data: &StockData) -> IndicatorSnapshot {
+    let delivery_trend_val = data.delivery_volumes.as_ref().and_then(|dv| {
+        // Compute delivery percentages from delivery_volume / total_volume
+        let delivery_pcts: Vec<f64> = dv
+            .iter()
+            .zip(data.volumes.iter())
+            .map(|(&d, &t)| delivery_pct(d, t))
+            .collect();
+        delivery_trend(&delivery_pcts, &data.closes, 5, 20)
+    });
+
+    IndicatorSnapshot {
+        symbol: data.symbol.clone(),
+        sma_20: sma(&data.closes, 20),
+        ema_20: ema(&data.closes, 20),
+        rsi_14: rsi(&data.closes, 14),
+        macd_result: macd(&data.closes, 12, 26, 9),
+        bollinger: bollinger_bands(&data.closes, 20, 2.0),
+        atr_14: atr(&data.highs, &data.lows, &data.closes, 14),
+        supertrend: supertrend(&data.highs, &data.lows, &data.closes, 10, 3.0),
+        stochastic: stochastic(&data.highs, &data.lows, &data.closes, 14, 3),
+        adx_14: adx(&data.highs, &data.lows, &data.closes, 14),
+        obv: obv(&data.closes, &data.volumes),
+        vwap: vwap(&data.highs, &data.lows, &data.closes, &data.volumes),
+        volume_trend: volume_trend(&data.volumes).to_string(),
+        delivery_trend: delivery_trend_val,
+    }
+}
+
+/// Batch compute indicators for multiple stocks (sequential).
+pub fn batch_compute(stocks: &[StockData]) -> Vec<IndicatorSnapshot> {
+    stocks.iter().map(compute_snapshot).collect()
+}
+
+/// Batch compute indicators for multiple stocks (parallel via rayon).
+pub fn batch_compute_parallel(stocks: &[StockData]) -> Vec<IndicatorSnapshot> {
+    stocks.par_iter().map(compute_snapshot).collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn make_stock(symbol: &str, len: usize) -> StockData {
+        let closes: Vec<f64> = (0..len).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 opens: Vec<f64> = closes.iter().map(|c| c - 0.5).collect();
+        let volumes: Vec<f64> = vec![1_000_000.0; len];
+        StockData {
+            symbol: symbol.to_string(),
+            opens,
+            highs,
+            lows,
+            closes,
+            volumes,
+            delivery_volumes: None,
+        }
+    }
+
+    #[test]
+    fn single_stock_snapshot() {
+        let stock = make_stock("RELIANCE", 60);
+        let snap = compute_snapshot(&stock);
+        assert_eq!(snap.symbol, "RELIANCE");
+        assert!(snap.sma_20.is_some());
+        assert!(snap.ema_20.is_some());
+        assert!(snap.rsi_14.is_some());
+        assert!(snap.macd_result.is_some());
+        assert!(snap.bollinger.is_some());
+        assert!(snap.atr_14.is_some());
+        assert!(snap.supertrend.is_some());
+        assert!(snap.stochastic.is_some());
+        assert!(snap.obv.is_some());
+        assert!(snap.vwap.is_some());
+        assert_ne!(snap.volume_trend, "insufficient data");
+    }
+
+    #[test]
+    fn batch_compute_100_stocks() {
+        let stocks: Vec<StockData> = (0..100)
+            .map(|i| make_stock(&format!("STOCK{i}"), 60))
+            .collect();
+        let results = batch_compute(&stocks);
+        assert_eq!(results.len(), 100);
+        for snap in &results {
+            assert!(snap.rsi_14.is_some());
+        }
+    }
+
+    #[test]
+    fn batch_compute_parallel_100_stocks() {
+        let stocks: Vec<StockData> = (0..100)
+            .map(|i| make_stock(&format!("STOCK{i}"), 60))
+            .collect();
+        let results = batch_compute_parallel(&stocks);
+        assert_eq!(results.len(), 100);
+        for snap in &results {
+            assert!(snap.rsi_14.is_some());
+        }
+    }
+
+    #[test]
+    fn batch_with_delivery_data() {
+        let mut stock = make_stock("HDFC", 60);
+        stock.delivery_volumes = Some(vec![600_000.0; 60]);
+        let snap = compute_snapshot(&stock);
+        assert!(snap.delivery_trend.is_some());
+    }
+
+    #[test]
+    fn batch_empty() {
+        let results = batch_compute(&[]);
+        assert!(results.is_empty());
+    }
+}

package/src/batch/mod.rs

@@ -0,0 +1,2 @@
+pub mod compute;
+pub mod screen;

package/src/batch/screen.rs

@@ -0,0 +1,176 @@
+use crate::indicators::trend::supertrend::SupertrendDirection;
+
+use super::compute::{IndicatorSnapshot, StockData, compute_snapshot};
+
+/// Filter criteria for stock screening.
+#[derive(Debug, Clone)]
+pub enum ScreenFilter {
+    RsiBelow(f64),
+    RsiAbove(f64),
+    SupertrendUp,
+    SupertrendDown,
+    AdxAbove(f64),
+    VolumeAbove(f64),
+}
+
+/// A stock that passed all screening filters.
+#[derive(Debug, Clone)]
+pub struct ScreenResult {
+    pub symbol: String,
+    pub snapshot: IndicatorSnapshot,
+}
+
+fn matches_filter(snap: &IndicatorSnapshot, filter: &ScreenFilter, data: &StockData) -> bool {
+    match filter {
+        ScreenFilter::RsiBelow(threshold) => snap.rsi_14.is_some_and(|rsi| rsi < *threshold),
+        ScreenFilter::RsiAbove(threshold) => snap.rsi_14.is_some_and(|rsi| rsi > *threshold),
+        ScreenFilter::SupertrendUp => snap
+            .supertrend
+            .as_ref()
+            .is_some_and(|st| st.direction == SupertrendDirection::Up),
+        ScreenFilter::SupertrendDown => snap
+            .supertrend
+            .as_ref()
+            .is_some_and(|st| st.direction == SupertrendDirection::Down),
+        ScreenFilter::AdxAbove(threshold) => {
+            snap.adx_14.is_some_and(|adx_val| adx_val > *threshold)
+        }
+        ScreenFilter::VolumeAbove(threshold) => {
+            data.volumes.last().is_some_and(|&vol| vol > *threshold)
+        }
+    }
+}
+
+/// Screen stocks: compute indicators and return those matching ALL filters.
+pub fn screen(stocks: &[StockData], filters: &[ScreenFilter]) -> Vec<ScreenResult> {
+    stocks
+        .iter()
+        .filter_map(|data| {
+            let snapshot = compute_snapshot(data);
+            let passes = filters.iter().all(|f| matches_filter(&snapshot, f, data));
+            if passes {
+                Some(ScreenResult {
+                    symbol: data.symbol.clone(),
+                    snapshot,
+                })
+            } else {
+                None
+            }
+        })
+        .collect()
+}
+
+/// Screen with pre-computed snapshots (avoids recomputing).
+pub fn screen_precomputed(
+    snapshots: &[(StockData, IndicatorSnapshot)],
+    filters: &[ScreenFilter],
+) -> Vec<ScreenResult> {
+    snapshots
+        .iter()
+        .filter_map(|(data, snapshot)| {
+            let passes = filters.iter().all(|f| matches_filter(snapshot, f, data));
+            if passes {
+                Some(ScreenResult {
+                    symbol: data.symbol.clone(),
+                    snapshot: snapshot.clone(),
+                })
+            } else {
+                None
+            }
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn make_uptrend_stock(symbol: &str) -> StockData {
+        let len = 60;
+        let closes: Vec<f64> = (0..len).map(|i| 100.0 + i as f64 * 2.0).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 opens: Vec<f64> = closes.iter().map(|c| c - 0.5).collect();
+        let volumes: Vec<f64> = vec![2_000_000.0; len];
+        StockData {
+            symbol: symbol.to_string(),
+            opens,
+            highs,
+            lows,
+            closes,
+            volumes,
+            delivery_volumes: None,
+        }
+    }
+
+    fn make_downtrend_stock(symbol: &str) -> StockData {
+        let len = 60;
+        let closes: Vec<f64> = (0..len).map(|i| 200.0 - i as f64 * 2.0).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 opens: Vec<f64> = closes.iter().map(|c| c + 0.5).collect();
+        let volumes: Vec<f64> = vec![500_000.0; len];
+        StockData {
+            symbol: symbol.to_string(),
+            opens,
+            highs,
+            lows,
+            closes,
+            volumes,
+            delivery_volumes: None,
+        }
+    }
+
+    #[test]
+    fn screen_supertrend_up() {
+        let stocks = vec![
+            make_uptrend_stock("RELIANCE"),
+            make_downtrend_stock("YESBANK"),
+        ];
+        let results = screen(&stocks, &[ScreenFilter::SupertrendUp]);
+        assert!(results.iter().any(|r| r.symbol == "RELIANCE"));
+        assert!(!results.iter().any(|r| r.symbol == "YESBANK"));
+    }
+
+    #[test]
+    fn screen_volume_above() {
+        let stocks = vec![
+            make_uptrend_stock("RELIANCE"),  // 2M volume
+            make_downtrend_stock("YESBANK"), // 500K volume
+        ];
+        let results = screen(&stocks, &[ScreenFilter::VolumeAbove(1_000_000.0)]);
+        assert_eq!(results.len(), 1);
+        assert_eq!(results[0].symbol, "RELIANCE");
+    }
+
+    #[test]
+    fn screen_multiple_filters() {
+        let stocks = vec![
+            make_uptrend_stock("RELIANCE"),
+            make_downtrend_stock("YESBANK"),
+        ];
+        let results = screen(
+            &stocks,
+            &[
+                ScreenFilter::SupertrendUp,
+                ScreenFilter::VolumeAbove(1_000_000.0),
+            ],
+        );
+        // Only RELIANCE should match both
+        assert!(results.iter().all(|r| r.symbol == "RELIANCE"));
+    }
+
+    #[test]
+    fn screen_empty_filters_returns_all() {
+        let stocks = vec![make_uptrend_stock("A"), make_downtrend_stock("B")];
+        let results = screen(&stocks, &[]);
+        assert_eq!(results.len(), 2);
+    }
+
+    #[test]
+    fn screen_no_matches() {
+        let stocks = vec![make_uptrend_stock("RELIANCE")];
+        let results = screen(&stocks, &[ScreenFilter::SupertrendDown]);
+        assert!(results.is_empty());
+    }
+}

package/src/core/mod.rs

@@ -0,0 +1,3 @@
+pub mod traits;
+pub mod types;
+pub mod utils;

package/src/core/traits.rs

@@ -0,0 +1,37 @@
+use super::types::Candle;
+
+/// Core trait for all streaming indicators.
+///
+/// Supports two modes:
+/// - **Streaming**: feed candles one at a time via `update()` — O(1) per update
+/// - **Batch**: pass a full array via `compute()` or `compute_last()`
+///
+/// All indicators implement this trait, enabling polymorphic batch processing
+/// and consistent API across the library.
+pub trait Indicator: Send + Sync {
+    /// The output type (f64, MacdResult, BollingerBandsResult, etc.)
+    type Output: Clone;
+
+    /// Feed one new candle. Returns `None` while building up, `Some` once ready.
+    fn update(&mut self, candle: &Candle) -> Option<Self::Output>;
+
+    /// Reset internal state to start fresh.
+    fn reset(&mut self);
+
+    /// Compute the indicator for every candle in the array.
+    /// Returns a Vec of the same length as input.
+    fn compute(&mut self, candles: &[Candle]) -> Vec<Option<Self::Output>> {
+        self.reset();
+        candles.iter().map(|c| self.update(c)).collect()
+    }
+
+    /// Compute only the final value (most common use case).
+    fn compute_last(&mut self, candles: &[Candle]) -> Option<Self::Output> {
+        self.reset();
+        let mut last = None;
+        for c in candles {
+            last = self.update(c);
+        }
+        last
+    }
+}

package/src/core/types.rs

@@ -0,0 +1,22 @@
+/// A single OHLCV candle.
+#[derive(Debug, Clone, Copy)]
+pub struct Candle {
+    pub open: f64,
+    pub high: f64,
+    pub low: f64,
+    pub close: f64,
+    pub volume: f64,
+}
+
+impl Candle {
+    /// Create a candle from just a close price (for indicators that only need close).
+    pub fn from_close(close: f64) -> Self {
+        Self {
+            open: close,
+            high: close,
+            low: close,
+            close,
+            volume: 0.0,
+        }
+    }
+}