Package Exports

@neural-trader/features
@neural-trader/features/index.js

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (@neural-trader/features) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

@neural-trader/features

Enterprise-grade technical indicators library for Neural Trader with 150+ indicators including RSI, MACD, Bollinger Bands, and advanced custom indicators. Built with Rust for maximum computational performance.

Features
Installation
Quick Start
Available Indicators
Core Concepts
Examples
Integration Patterns
API Reference
Custom Indicators
Performance Optimization
Best Practices
License

Features

150+ Indicators: Comprehensive technical analysis library covering all major indicator families
Rust Performance: Calculate thousands of indicators per second with SIMD optimization
Moving Averages: SMA, EMA, WMA, VWMA, DEMA, TEMA, and more
Momentum: RSI, Stochastic, Williams %R, CCI, ROC
Trend: MACD, ADX, Parabolic SAR, Aroon, Ichimoku
Volatility: Bollinger Bands, ATR, Keltner Channels, Donchian Channels
Volume: OBV, VWAP, MFI, A/D Line, Chaikin Money Flow
Custom Indicators: Build your own indicators with simple API
Batch Processing: Calculate multiple indicators in parallel
Type Safety: Full TypeScript definitions for all indicators
Zero Dependencies: Standalone package with no external dependencies

Installation

# Install with required dependencies
npm install @neural-trader/features @neural-trader/core

# Or with yarn
yarn add @neural-trader/features @neural-trader/core

# Install type definitions
npm install --save-dev @types/node

Dependencies

This package requires:

@neural-trader/core - Core functionality and types

Quick Start

Basic Usage

import { calculateSma, calculateRsi, calculateMacd } from '@neural-trader/features';

// Simple Moving Average
const prices = [150, 152, 151, 153, 155, 154, 156, 158, 157, 159];
const sma5 = calculateSma(prices, 5);
console.log('SMA(5):', sma5);
// Output: [152.2, 153.0, 153.8, 155.2, 156.8, 156.8]

// Relative Strength Index
const rsi = calculateRsi(prices, 14);
console.log('RSI(14):', rsi);
// Output: [52.3, 56.8, 61.2, ...]

// Exponential Moving Average
const ema = calculateEma(prices, 12);
console.log('EMA(12):', ema);
// Output: [151.5, 152.8, 154.2, ...]

Using with Bar Data

import { calculateIndicator } from '@neural-trader/features';
import { MarketDataProvider } from '@neural-trader/market-data';

// Fetch historical data
const provider = new MarketDataProvider({
  provider: 'alpaca',
  apiKey: process.env.ALPACA_API_KEY,
  apiSecret: process.env.ALPACA_SECRET
});

await provider.connect();

const bars = await provider.fetchBars(
  'AAPL',
  '2024-01-01',
  '2024-12-31',
  '1Day'
);

// Calculate MACD using bar data
const macdResult = await calculateIndicator(bars, 'MACD', JSON.stringify({
  fast_period: 12,
  slow_period: 26,
  signal_period: 9
}));

console.log('MACD:', macdResult);
// Output: { macd: [...], signal: [...], histogram: [...] }

await provider.disconnect();

Available Indicators

Trend Indicators

Moving Averages

SMA - Simple Moving Average
EMA - Exponential Moving Average
WMA - Weighted Moving Average
VWMA - Volume-Weighted Moving Average
DEMA - Double Exponential Moving Average
TEMA - Triple Exponential Moving Average
KAMA - Kaufman Adaptive Moving Average
MAMA - MESA Adaptive Moving Average
T3 - Triple Exponential Moving Average (T3)

Trend Following

MACD - Moving Average Convergence/Divergence
MACD_HISTOGRAM - MACD Histogram
MACD_SIGNAL - MACD Signal Line
ADX - Average Directional Index
PLUS_DI - Plus Directional Indicator
MINUS_DI - Minus Directional Indicator
AROON - Aroon Indicator
AROON_OSC - Aroon Oscillator
PSAR - Parabolic SAR
SAR - Stop and Reverse
SUPERTREND - SuperTrend Indicator

Momentum Indicators

RSI - Relative Strength Index
STOCH - Stochastic Oscillator
STOCH_RSI - Stochastic RSI
WILLIAMS_R - Williams %R
CCI - Commodity Channel Index
ROC - Rate of Change
MOMENTUM - Momentum
TSI - True Strength Index
UO - Ultimate Oscillator
AO - Awesome Oscillator
CMO - Chande Momentum Oscillator
PPO - Percentage Price Oscillator

Volatility Indicators

BBANDS - Bollinger Bands
ATR - Average True Range
NATR - Normalized ATR
KELTNER - Keltner Channels
DONCHIAN - Donchian Channels
STDDEV - Standard Deviation
VAR - Variance
RVI - Relative Volatility Index
CHAIKIN_VOL - Chaikin Volatility

Volume Indicators

OBV - On-Balance Volume
VWAP - Volume-Weighted Average Price
MFI - Money Flow Index
AD - Accumulation/Distribution
ADOSC - Accumulation/Distribution Oscillator
CMF - Chaikin Money Flow
FI - Force Index
EOM - Ease of Movement
NVI - Negative Volume Index
PVI - Positive Volume Index

Custom & Advanced Indicators

ICHIMOKU - Ichimoku Cloud (Tenkan, Kijun, Senkou A/B, Chikou)
PIVOT - Pivot Points (Standard, Fibonacci, Camarilla, Woodie, DeMark)
FIBONACCI - Fibonacci Retracements
ELLIOTT_WAVE - Elliott Wave Detection
HARMONIC - Harmonic Pattern Detection (Gartley, Butterfly, Bat, Crab)
CANDLESTICK - Candlestick Pattern Recognition (50+ patterns)

Core Concepts

Indicator Parameters

Most indicators accept configurable parameters:

// RSI with different periods
const rsi14 = calculateRsi(prices, 14); // Standard
const rsi9 = calculateRsi(prices, 9);   // Faster
const rsi21 = calculateRsi(prices, 21); // Slower

// MACD with custom periods
const macd = await calculateIndicator(bars, 'MACD', JSON.stringify({
  fast_period: 12,   // Fast EMA period
  slow_period: 26,   // Slow EMA period
  signal_period: 9   // Signal line period
}));

// Bollinger Bands with custom parameters
const bbands = await calculateIndicator(bars, 'BBANDS', JSON.stringify({
  period: 20,              // Moving average period
  std_dev_multiplier: 2.0, // Standard deviation multiplier
  ma_type: 'SMA'          // Moving average type
}));

Indicator Output Formats

Different indicators return different data structures:

// Single value array (SMA, EMA, RSI)
const sma = calculateSma(prices, 20);
// Returns: [number, number, ...]

// Multiple values (Bollinger Bands)
const bbands = await calculateIndicator(bars, 'BBANDS', params);
// Returns: { upper: [...], middle: [...], lower: [...] }

// Complex structures (MACD)
const macd = await calculateIndicator(bars, 'MACD', params);
// Returns: { macd: [...], signal: [...], histogram: [...] }

// Boolean signals (Candlestick patterns)
const patterns = await calculateIndicator(bars, 'CANDLESTICK', params);
// Returns: { doji: [true, false, ...], hammer: [...], ... }

Examples

Basic Technical Analysis

import { calculateSma, calculateEma, calculateRsi, calculateMacd } from '@neural-trader/features';

// Price data
const prices = [
  100, 102, 101, 103, 105, 104, 106, 108, 107, 109,
  111, 110, 112, 114, 113, 115, 117, 116, 118, 120
];

// Calculate multiple indicators
const sma20 = calculateSma(prices, 20);
const ema20 = calculateEma(prices, 20);
const rsi14 = calculateRsi(prices, 14);

console.log('Current Price:', prices[prices.length - 1]);
console.log('SMA(20):', sma20[sma20.length - 1]);
console.log('EMA(20):', ema20[ema20.length - 1]);
console.log('RSI(14):', rsi14[rsi14.length - 1]);

// Determine trend
const currentPrice = prices[prices.length - 1];
const currentSma = sma20[sma20.length - 1];
const currentRsi = rsi14[rsi14.length - 1];

if (currentPrice > currentSma && currentRsi < 70) {
  console.log('Signal: BULLISH - Price above SMA, RSI not overbought');
} else if (currentPrice < currentSma && currentRsi > 30) {
  console.log('Signal: BEARISH - Price below SMA, RSI not oversold');
} else {
  console.log('Signal: NEUTRAL');
}

Bollinger Bands Strategy

import { calculateIndicator } from '@neural-trader/features';
import { MarketDataProvider } from '@neural-trader/market-data';

const provider = new MarketDataProvider({
  provider: 'alpaca',
  apiKey: process.env.ALPACA_API_KEY,
  apiSecret: process.env.ALPACA_SECRET
});

await provider.connect();

// Fetch data
const bars = await provider.fetchBars('AAPL', '2024-01-01', '2024-12-31', '1Day');

// Calculate Bollinger Bands
const bbands = await calculateIndicator(bars, 'BBANDS', JSON.stringify({
  period: 20,
  std_dev_multiplier: 2.0,
  ma_type: 'SMA'
}));

// Analyze current position
const currentClose = parseFloat(bars[bars.length - 1].close);
const upperBand = bbands.upper[bbands.upper.length - 1];
const lowerBand = bbands.lower[bbands.lower.length - 1];
const middleBand = bbands.middle[bbands.middle.length - 1];

console.log(`Current Price: $${currentClose.toFixed(2)}`);
console.log(`Upper Band: $${upperBand.toFixed(2)}`);
console.log(`Middle Band: $${middleBand.toFixed(2)}`);
console.log(`Lower Band: $${lowerBand.toFixed(2)}`);

// Generate signals
if (currentClose <= lowerBand) {
  console.log('Signal: BUY - Price touching lower Bollinger Band');
} else if (currentClose >= upperBand) {
  console.log('Signal: SELL - Price touching upper Bollinger Band');
} else if (currentClose > middleBand) {
  console.log('Signal: HOLD - Price above middle band (bullish)');
} else {
  console.log('Signal: HOLD - Price below middle band (bearish)');
}

await provider.disconnect();

MACD Crossover Strategy

import { calculateIndicator } from '@neural-trader/features';
import { MarketDataProvider } from '@neural-trader/market-data';

const provider = new MarketDataProvider({
  provider: 'alpaca',
  apiKey: process.env.ALPACA_API_KEY,
  apiSecret: process.env.ALPACA_SECRET
});

await provider.connect();

const bars = await provider.fetchBars('MSFT', '2024-01-01', '2024-12-31', '1Day');

// Calculate MACD
const macd = await calculateIndicator(bars, 'MACD', JSON.stringify({
  fast_period: 12,
  slow_period: 26,
  signal_period: 9
}));

// Detect crossovers
const signals = [];
for (let i = 1; i < macd.macd.length; i++) {
  const prevMacd = macd.macd[i - 1];
  const prevSignal = macd.signal[i - 1];
  const currMacd = macd.macd[i];
  const currSignal = macd.signal[i];

  // Bullish crossover (MACD crosses above signal)
  if (prevMacd <= prevSignal && currMacd > currSignal) {
    signals.push({
      date: bars[i].timestamp,
      type: 'BUY',
      macd: currMacd,
      signal: currSignal,
      histogram: macd.histogram[i]
    });
  }

  // Bearish crossover (MACD crosses below signal)
  if (prevMacd >= prevSignal && currMacd < currSignal) {
    signals.push({
      date: bars[i].timestamp,
      type: 'SELL',
      macd: currMacd,
      signal: currSignal,
      histogram: macd.histogram[i]
    });
  }
}

console.log(`Found ${signals.length} MACD crossover signals:`);
signals.slice(-5).forEach(signal => {
  console.log(`${signal.date}: ${signal.type} - MACD: ${signal.macd.toFixed(2)}, Signal: ${signal.signal.toFixed(2)}`);
});

await provider.disconnect();

Multi-Indicator Confirmation

import { calculateRsi, calculateSma, calculateIndicator } from '@neural-trader/features';
import { MarketDataProvider } from '@neural-trader/market-data';

const provider = new MarketDataProvider({
  provider: 'alpaca',
  apiKey: process.env.ALPACA_API_KEY,
  apiSecret: process.env.ALPACA_SECRET
});

await provider.connect();

const bars = await provider.fetchBars('GOOGL', '2024-01-01', '2024-12-31', '1Day');

// Extract close prices
const closes = bars.map(b => parseFloat(b.close));

// Calculate multiple indicators
const rsi = calculateRsi(closes, 14);
const sma50 = calculateSma(closes, 50);
const sma200 = calculateSma(closes, 200);
const macd = await calculateIndicator(bars, 'MACD', JSON.stringify({
  fast_period: 12,
  slow_period: 26,
  signal_period: 9
}));

// Get current values
const currentPrice = closes[closes.length - 1];
const currentRsi = rsi[rsi.length - 1];
const currentSma50 = sma50[sma50.length - 1];
const currentSma200 = sma200[sma200.length - 1];
const currentMacd = macd.macd[macd.macd.length - 1];
const currentSignal = macd.signal[macd.signal.length - 1];

// Multi-indicator analysis
let bullishSignals = 0;
let bearishSignals = 0;

// RSI analysis
if (currentRsi < 30) bullishSignals++; // Oversold
if (currentRsi > 70) bearishSignals++; // Overbought

// Moving average analysis
if (currentPrice > currentSma50) bullishSignals++; // Above 50-day MA
if (currentPrice < currentSma50) bearishSignals++; // Below 50-day MA
if (currentSma50 > currentSma200) bullishSignals++; // Golden cross territory
if (currentSma50 < currentSma200) bearishSignals++; // Death cross territory

// MACD analysis
if (currentMacd > currentSignal) bullishSignals++; // MACD above signal
if (currentMacd < currentSignal) bearishSignals++; // MACD below signal

console.log('\nMulti-Indicator Analysis:');
console.log(`Price: $${currentPrice.toFixed(2)}`);
console.log(`RSI(14): ${currentRsi.toFixed(2)}`);
console.log(`SMA(50): $${currentSma50.toFixed(2)}`);
console.log(`SMA(200): $${currentSma200.toFixed(2)}`);
console.log(`MACD: ${currentMacd.toFixed(2)}`);
console.log(`\nBullish Signals: ${bullishSignals}/5`);
console.log(`Bearish Signals: ${bearishSignals}/5`);

if (bullishSignals >= 4) {
  console.log('\nOverall Signal: STRONG BUY');
} else if (bullishSignals >= 3) {
  console.log('\nOverall Signal: BUY');
} else if (bearishSignals >= 4) {
  console.log('\nOverall Signal: STRONG SELL');
} else if (bearishSignals >= 3) {
  console.log('\nOverall Signal: SELL');
} else {
  console.log('\nOverall Signal: NEUTRAL');
}

await provider.disconnect();

Batch Indicator Calculation

import { calculateSma, calculateEma, calculateRsi } from '@neural-trader/features';

// Calculate multiple indicators in parallel
const prices = [/* ... large price array ... */];

const [sma20, sma50, sma200, ema12, ema26, rsi14] = await Promise.all([
  Promise.resolve(calculateSma(prices, 20)),
  Promise.resolve(calculateSma(prices, 50)),
  Promise.resolve(calculateSma(prices, 200)),
  Promise.resolve(calculateEma(prices, 12)),
  Promise.resolve(calculateEma(prices, 26)),
  Promise.resolve(calculateRsi(prices, 14))
]);

console.log('All indicators calculated in parallel');

Integration Patterns

Integration with Strategies

import { calculateRsi, calculateSma } from '@neural-trader/features';
import { Strategy } from '@neural-trader/strategies';
import { MarketDataProvider } from '@neural-trader/market-data';
import { BrokerClient } from '@neural-trader/brokers';

// Create strategy with indicator parameters
const strategy = new Strategy({
  name: 'rsi-sma-strategy',
  symbols: ['AAPL', 'MSFT', 'GOOGL'],
  parameters: {
    rsiPeriod: 14,
    rsiOversold: 30,
    rsiOverbought: 70,
    smaPeriod: 50
  }
});

// Setup data provider and broker
const dataProvider = new MarketDataProvider({
  provider: 'alpaca',
  apiKey: process.env.ALPACA_API_KEY,
  apiSecret: process.env.ALPACA_SECRET
});

const broker = new BrokerClient({
  brokerType: 'alpaca',
  apiKey: process.env.ALPACA_API_KEY,
  apiSecret: process.env.ALPACA_SECRET,
  paperTrading: true
});

await dataProvider.connect();
await broker.connect();

// Strategy logic using indicators
strategy.on('bar', async (bar) => {
  // Fetch historical data
  const bars = await dataProvider.fetchBars(
    bar.symbol,
    /* start date */,
    /* end date */,
    '1Day'
  );

  // Calculate indicators
  const closes = bars.map(b => parseFloat(b.close));
  const rsi = calculateRsi(closes, strategy.parameters.rsiPeriod);
  const sma = calculateSma(closes, strategy.parameters.smaPeriod);

  const currentRsi = rsi[rsi.length - 1];
  const currentSma = sma[sma.length - 1];
  const currentPrice = parseFloat(bar.close);

  // Generate signals
  if (currentRsi < strategy.parameters.rsiOversold && currentPrice > currentSma) {
    // Oversold RSI + price above SMA = Buy signal
    await broker.placeOrder({
      symbol: bar.symbol,
      side: 'buy',
      orderType: 'market',
      quantity: 100,
      timeInForce: 'day'
    });
    console.log(`BUY ${bar.symbol}: RSI=${currentRsi.toFixed(2)}, Price > SMA`);
  } else if (currentRsi > strategy.parameters.rsiOverbought) {
    // Overbought RSI = Sell signal
    await broker.placeOrder({
      symbol: bar.symbol,
      side: 'sell',
      orderType: 'market',
      quantity: 100,
      timeInForce: 'day'
    });
    console.log(`SELL ${bar.symbol}: RSI=${currentRsi.toFixed(2)}`);
  }
});

await strategy.start(dataProvider);

Integration with Backtesting

import { calculateSma, calculateRsi, calculateIndicator } from '@neural-trader/features';
import { BacktestEngine } from '@neural-trader/backtesting';
import { MarketDataProvider } from '@neural-trader/market-data';

// Setup backtest
const backtest = new BacktestEngine({
  initialCapital: 100000,
  commission: 0.001,
  startDate: '2023-01-01',
  endDate: '2023-12-31'
});

// Fetch historical data
const provider = new MarketDataProvider({
  provider: 'alpaca',
  apiKey: process.env.ALPACA_API_KEY,
  apiSecret: process.env.ALPACA_SECRET
});

await provider.connect();

const symbols = ['AAPL', 'MSFT', 'GOOGL'];
const historicalData = new Map();

for (const symbol of symbols) {
  const bars = await provider.fetchBars(symbol, '2023-01-01', '2023-12-31', '1Day');
  historicalData.set(symbol, bars);
}

// Strategy using indicators
backtest.addStrategy(async (context) => {
  const { symbol, date, portfolio } = context;
  const bars = historicalData.get(symbol);

  if (!bars) return;

  // Get bars up to current date
  const currentBars = bars.filter(b => new Date(b.timestamp) <= date);
  if (currentBars.length < 50) return;

  // Calculate indicators
  const closes = currentBars.map(b => parseFloat(b.close));
  const rsi = calculateRsi(closes, 14);
  const sma20 = calculateSma(closes, 20);
  const sma50 = calculateSma(closes, 50);

  const currentRsi = rsi[rsi.length - 1];
  const currentSma20 = sma20[sma20.length - 1];
  const currentSma50 = sma50[sma50.length - 1];
  const currentPrice = closes[closes.length - 1];

  // Trading logic
  const position = portfolio.positions.get(symbol);

  if (!position || position.quantity === 0) {
    // Entry conditions: RSI oversold + bullish crossover
    if (currentRsi < 30 && currentSma20 > currentSma50) {
      await context.placeOrder({
        symbol,
        side: 'buy',
        orderType: 'market',
        quantity: 100,
        timeInForce: 'day'
      });
    }
  } else {
    // Exit conditions: RSI overbought or bearish crossover
    if (currentRsi > 70 || currentSma20 < currentSma50) {
      await context.placeOrder({
        symbol,
        side: 'sell',
        orderType: 'market',
        quantity: position.quantity,
        timeInForce: 'day'
      });
    }
  }
});

// Run backtest
const results = await backtest.run(symbols);

console.log('\nBacktest Results:');
console.log(`  Total Return: ${(results.totalReturn * 100).toFixed(2)}%`);
console.log(`  Sharpe Ratio: ${results.sharpeRatio.toFixed(2)}`);
console.log(`  Max Drawdown: ${(results.maxDrawdown * 100).toFixed(2)}%`);
console.log(`  Win Rate: ${(results.winRate * 100).toFixed(2)}%`);

await provider.disconnect();

API Reference

Simple Functions

Quick functions for common indicators using price arrays.

// Moving Averages
function calculateSma(prices: number[], period: number): number[];
function calculateEma(prices: number[], period: number): number[];
function calculateWma(prices: number[], period: number): number[];

// Momentum
function calculateRsi(prices: number[], period: number): number[];
function calculateMacd(
  prices: number[],
  fastPeriod: number,
  slowPeriod: number,
  signalPeriod: number
): { macd: number[]; signal: number[]; histogram: number[] };

// Volatility
function calculateBollingerBands(
  prices: number[],
  period: number,
  stdDev: number
): { upper: number[]; middle: number[]; lower: number[] };

function calculateAtr(
  highs: number[],
  lows: number[],
  closes: number[],
  period: number
): number[];

Generic Indicator Function

For advanced indicators requiring OHLCV data.

function calculateIndicator(
  bars: JsBar[],
  indicator: string,
  params: string
): Promise<any>;

// Usage examples:

// MACD
const macd = await calculateIndicator(bars, 'MACD', JSON.stringify({
  fast_period: 12,
  slow_period: 26,
  signal_period: 9
}));

// Bollinger Bands
const bbands = await calculateIndicator(bars, 'BBANDS', JSON.stringify({
  period: 20,
  std_dev_multiplier: 2.0,
  ma_type: 'SMA'
}));

// ADX
const adx = await calculateIndicator(bars, 'ADX', JSON.stringify({
  period: 14
}));

// Stochastic
const stoch = await calculateIndicator(bars, 'STOCH', JSON.stringify({
  k_period: 14,
  d_period: 3,
  smooth_k: 3
}));

Types

interface JsBar {
  symbol: string;
  timestamp: string;
  open: string;
  high: string;
  low: string;
  close: string;
  volume: string;
}

interface IndicatorResult {
  // Single value indicators
  values?: number[];

  // Multi-value indicators (e.g., Bollinger Bands)
  upper?: number[];
  middle?: number[];
  lower?: number[];

  // MACD specific
  macd?: number[];
  signal?: number[];
  histogram?: number[];

  // Stochastic specific
  k?: number[];
  d?: number[];

  // Ichimoku specific
  tenkan?: number[];
  kijun?: number[];
  senkou_a?: number[];
  senkou_b?: number[];
  chikou?: number[];
}

Custom Indicators

Creating Custom Indicators

// Create custom indicator by combining existing ones
function calculateCustomMomentum(
  prices: number[],
  rsiPeriod: number,
  smaPeriod: number
): number[] {
  const rsi = calculateRsi(prices, rsiPeriod);
  const sma = calculateSma(prices, smaPeriod);

  // Normalize RSI (0-100) to match price scale
  const normalizedRsi = rsi.map(r => (r - 50) / 50); // -1 to +1

  // Combine signals
  return prices.map((price, i) => {
    if (i >= sma.length) return 0;

    const priceVsSma = (price - sma[i]) / sma[i]; // Percentage above/below SMA
    const momentum = priceVsSma + normalizedRsi[i];

    return momentum;
  });
}

// Usage
const customMomentum = calculateCustomMomentum(prices, 14, 50);
console.log('Custom Momentum:', customMomentum);

Custom Indicator with Parameters

interface CustomIndicatorParams {
  rsiPeriod: number;
  smaPeriod: number;
  threshold: number;
}

function calculateCustomSignal(
  prices: number[],
  params: CustomIndicatorParams
): { value: number[]; signal: string[] } {
  const rsi = calculateRsi(prices, params.rsiPeriod);
  const sma = calculateSma(prices, params.smaPeriod);

  const values: number[] = [];
  const signals: string[] = [];

  for (let i = 0; i < prices.length; i++) {
    const value = rsi[i] * (prices[i] / (sma[i] || 1));
    values.push(value);

    if (value > params.threshold) {
      signals.push('BUY');
    } else if (value < -params.threshold) {
      signals.push('SELL');
    } else {
      signals.push('HOLD');
    }
  }

  return { value: values, signal: signals };
}

Performance Optimization

Batch Processing

// Process multiple symbols efficiently
const symbols = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA'];
const results = await Promise.all(
  symbols.map(async symbol => {
    const bars = await provider.fetchBars(symbol, '2024-01-01', '2024-12-31', '1Day');
    const closes = bars.map(b => parseFloat(b.close));

    return {
      symbol,
      rsi: calculateRsi(closes, 14),
      sma50: calculateSma(closes, 50),
      sma200: calculateSma(closes, 200)
    };
  })
);

console.log('Processed', results.length, 'symbols');

Caching Indicator Results

const indicatorCache = new Map();

function getCachedIndicator(
  key: string,
  calculator: () => number[]
): number[] {
  if (indicatorCache.has(key)) {
    return indicatorCache.get(key);
  }

  const result = calculator();
  indicatorCache.set(key, result);
  return result;
}

// Usage
const rsi = getCachedIndicator(
  `rsi-${symbol}-14`,
  () => calculateRsi(prices, 14)
);

Best Practices

1. Use Appropriate Lookback Periods

// Standard periods for common indicators
const rsi14 = calculateRsi(prices, 14);      // Standard RSI
const sma20 = calculateSma(prices, 20);      // Short-term trend
const sma50 = calculateSma(prices, 50);      // Medium-term trend
const sma200 = calculateSma(prices, 200);    // Long-term trend

2. Validate Input Data

function validatePrices(prices: number[]): boolean {
  if (!Array.isArray(prices) || prices.length === 0) {
    return false;
  }

  return prices.every(p =>
    typeof p === 'number' &&
    !isNaN(p) &&
    p > 0
  );
}

if (!validatePrices(prices)) {
  throw new Error('Invalid price data');
}

3. Handle Edge Cases

// Ensure sufficient data for indicator
const minimumBars = Math.max(rsiPeriod, smaPeriod) + 10;

if (bars.length < minimumBars) {
  console.warn(`Insufficient data: need ${minimumBars} bars, have ${bars.length}`);
  return;
}

4. Combine Multiple Indicators

// Use multiple indicators for confirmation
function getSignalStrength(
  price: number,
  rsi: number,
  sma50: number,
  sma200: number
): number {
  let strength = 0;

  if (rsi < 30) strength += 2;        // Strong oversold
  else if (rsi < 40) strength += 1;   // Oversold

  if (price > sma50) strength += 1;   // Above 50-day MA
  if (sma50 > sma200) strength += 2;  // Golden cross

  return strength; // 0-6 scale
}

5. Optimize Performance

// Calculate once, use multiple times
const closes = bars.map(b => parseFloat(b.close));

// Reuse closes array for multiple indicators
const rsi = calculateRsi(closes, 14);
const sma20 = calculateSma(closes, 20);
const sma50 = calculateSma(closes, 50);
const ema12 = calculateEma(closes, 12);

License

Dual-licensed under MIT OR Apache-2.0.

See LICENSE-MIT and LICENSE-APACHE for details.