Skip to content
/ trading-indi Public

A TypeScript library for technical indicators with incremental, stateful calculation optimized for real-time and intraday trading applications.

License

MIT license
8 stars 4 forks Branches Tags Activity
Star
Notifications You must be signed in to change notification settings

junduck/trading-indi

BranchesTags

Repository files navigation

trading-indi

A comprehensive TypeScript library for incremental trading computations, featuring 80+ technical indicators, candlestick pattern recognition, composable computation primitives, and a powerful DAG-based flow system for building complex trading algorithms.

Why trading-indi?

Traditional technical indicator libraries recalculate entire datasets on each new data point. trading-indi is a complete framework for building sophisticated trading algorithms:

  • 80+ Technical Indicators: Foundation, Statistics, Volatility, Momentum, Oscillators, Stochastic, Trend, and Volume indicators
  • Pattern Recognition: 10+ candlestick pattern heuristics (Doji, Hammer, Marubozu, etc.)
  • Computation Primitives: 40+ arithmetic and logical operators for custom calculations
  • DAG Flow System: Build complex multi-indicator strategies with topological execution
  • Incremental Calculation: Stateful, online algorithms that update efficiently with each tick
  • Perfect for Realtime Trading: Designed for WebSocket streams, tick data, and intraday strategies
  • Memory Efficient: Uses sliding windows and online algorithms
  • Consistent API: Every operator follows the same class/hook pattern
  • Zero Dependencies: Clean, modern TypeScript

Performance

trading-indi is built for speed and efficiency, making it ideal for real-time trading applications:

Benchmark Results

  • Processing Speed: 2+ million indicator calculations per second
  • Latency: ~0.03ms to process a single bar with all 64 indicators
  • Memory Efficiency: ~2.5KB per indicator instance
  • Real-time Capability: Can handle tick data (1000+ bars/second) with ease

Real-time Trading Suitability

All trading strategies tested are feasible for real-time trading:

Strategy Indicators Time per Bar Max Bars/sec Status
Scalping 5 0.0017ms 590,935 ✅ FEASIBLE
Swing Trading 6 0.0020ms 502,162 ✅ FEASIBLE
Trend Following 6 0.0017ms 597,488 ✅ FEASIBLE
Mean Reversion 6 0.0020ms 488,757 ✅ FEASIBLE
Volume Analysis 6 0.0005ms 1,840,082 ✅ FEASIBLE
Multi-Timeframe 11 0.0028ms 358,709 ✅ FEASIBLE

The library can easily handle real-time trading scenarios, including tick data processing, with minimal memory footprint and excellent performance characteristics.

Installation

Install the package from npm:

npm install @junduck/trading-indi
# or
yarn add @junduck/trading-indi
# or
pnpm add @junduck/trading-indi

Library Capabilities

trading-indi is more than just an indicator library - it's a complete framework for building trading algorithms:

Capability Components Use Case
Technical Indicators 80+ indicators across 8 categories Calculate standard technical indicators incrementally
Pattern Recognition 10+ candlestick patterns Detect chart patterns in realtime
Computation Primitives 40+ arithmetic & logical operators Build custom calculations and trading logic
DAG Flow System GraphExec, OpRegistry, Schema validation Compose complex multi-indicator strategies with automatic dependency resolution

Architecture Overview

┌─────────────────────────────────────────────────────┐
│                   Your Strategy                     │
├─────────────────────────────────────────────────────┤
│  DAG Flow System (GraphExec + OpRegistry)               │
│  ├─ Topological execution                           │
│  ├─ JSON serialization                              │
│  └─ Forward reference resolution                    │
├─────────────────────────────────────────────────────┤
│  Operators (Stateful, Incremental)                  │
│  ├─ Technical Indicators (80+)                      │
│  ├─ Pattern Recognition (10+)                       │
│  └─ Computation Primitives (40+)                    │
├─────────────────────────────────────────────────────┤
│  Foundation (from @junduck/trading-core)            │
│  └─ Sliding windows, online algorithms              │
└─────────────────────────────────────────────────────┘

Quick Start

Class-Based Usage (Stateful)

import { RSI, EMA, MACD, ATR, BBANDS, ADX } from '@junduck/trading-indi';

const rsi = new RSI({ period: 14 });
const ema = new EMA({ period: 20 });
const macd = new MACD({
  period_fast: 12,
  period_slow: 26,
  period_signal: 9
});
const atr = new ATR({ period: 14 });
const bbands = new BBANDS({ period: 20, stddev: 2 });
const adx = new ADX({ period: 14 });

// Process streaming data
priceStream.on('data', (bar) => {
  const rsiValue = rsi.onData(bar);
  const emaValue = ema.onData(bar.close);
  const { macd: macdLine, signal, histogram } = macd.onData(bar);
  const atrValue = atr.onData(bar);
  const { upper, middle, lower } = bbands.onData(bar.close);
  const adxValue = adx.onData(bar);

  console.log({ rsiValue, emaValue, macdLine, atrValue, bbands: { upper, middle, lower }, adxValue });
});

Functional Usage (Hooks)

import { useRSI, useEMA, useMACD, useATR, useBBANDS, useADX } from '@junduck/trading-indi';

const getRSI = useRSI({ period: 14 });
const getEMA = useEMA({ period: 20 });
const getMACD = useMACD({
  period_fast: 12,
  period_slow: 26,
  period_signal: 9
});
const getATR = useATR({ period: 14 });
const getBBANDS = useBBANDS({ period: 20, stddev: 2 });
const getADX = useADX({ period: 14 });

for (const bar of historicalData) {
  const rsiValue = getRSI(bar);
  const emaValue = getEMA(bar.close);
  const { macd, signal, histogram } = getMACD(bar);
  const atrValue = getATR(bar);
  const { upper, middle, lower } = getBBANDS(bar.close);
  const adxValue = getADX(bar);
}

Available Indicators

Foundation

Indicator Parameters Output
EMA period or alpha number
EWMA period number
SMA period number
Variance period, ddof? {mean: number, variance: number}
Stddev period, ddof? {mean: number, stddev: number}
Min period number
Max period number
Sum period number
MinMax period {min: number, max: number}

Statistics

Indicator Parameters Output
VarianceEW period or alpha, ddof? {mean: number, variance: number}
Cov period, ddof? {meanX: number, meanY: number, covariance: number}
Corr period, ddof? {meanX: number, meanY: number, covariance: number, correlation: number}
Beta period, ddof? {meanX: number, meanY: number, covariance: number, beta: number}
ZSCORE period number
CORRELATION period number
BETA period number

Volatility

Indicator Parameters Output
VOLATILITY period, annualizedDays? number
CVI period number
MASS period number
TR none number
ATR period number
NATR period number
PriceChannel period {upper, lower}
BBANDS period, stddev? {upper, middle, lower}
KC period, multiplier? {upper, middle, lower}
DC period {upper, middle, lower}

Momentum

Indicator Parameters Output
BOP none number
MOM period number
ROC period number
ROCR period number
RSI period number
CMO period number
WAD none number
RVI period {rvi, signal}
TSI long_period?, short_period?, signal_period? {tsi, signal}
BBPOWER period {bull_power, bear_power}

Oscillators

Indicator Parameters Output
AO none number
APO period_fast, period_slow number
DPO period number
Fisher period number
MACD period_fast, period_slow, period_signal {macd, signal, histogram}
PPO period_fast, period_slow number
QSTICK period number
TRIX period number
ULTOSC period_fast, period_med, period_slow number

Stochastic

Indicator Parameters Output
STOCH k_period?, k_slowing?, d_period? {k, d}
STOCHRSI period number
WILLR period number

Trend

Indicator Parameters Output
AROON period {up, down}
AROONOSC period number
CCI period number
VHF period number
DM period {plus, minus}
DI period {plus, minus}
DX period number
ADX period number
ADXR period number
SAR acceleration?, maximum? number
VI period {vi_plus, vi_minus}
ICHIMOKU tenkan_period?, kijun_period?, senkou_b_period?, displacement? {tenkan, kijun, senkou_a, senkou_b, chikou}

Volume

Indicator Parameters Output
AD none number
ADOSC period_fast, period_slow number
KVO period_fast?, period_slow? number
NVI none number
OBV none number
PVI none number
MFI period number
EMV none number
MARKETFI none number
VOSC period_fast, period_slow number
CMF period number
CHO period_fast, period_slow number
PVO period_fast, period_slow, period_signal? {pvo, signal, histogram}
FI period number
VROC period number
PVT none number

Pattern Recognition Heuristics

trading-indi includes candlestick pattern recognition for identifying common chart patterns:

Pattern Parameters Output Description
Doji dojiThres? boolean Open and close at nearly the same price
LongLeggedDoji period? boolean Doji with very long shadows
DragonflyDoji lowerShadowThres?, upperShadowThres? boolean Doji with long lower shadow, no upper shadow
GravestoneDoji upperShadowThres?, lowerShadowThres? boolean Doji with long upper shadow, no lower shadow
SpinningTop period?, rangeMultiplier?, bodyThres? boolean Small body with long upper and lower shadows
MarubozuWhite period?, shadowThres? boolean Long white candle with minimal shadows
MarubozuBlack period?, shadowThres? boolean Long black candle with minimal shadows
Hammer bodyThres?, lowerShadowThres?, upperShadowThres? boolean Small body at top with long lower shadow
InvertedHammer bodyThres?, upperShadowThres?, lowerShadowThres? boolean Small body at bottom with long upper shadow
HighWave period?, rangeMultiplier?, bodyThres?, shadowThres? boolean Very long shadows in both directions with small body

Example: Pattern Recognition

import { Hammer, Doji, MarubozuWhite } from '@junduck/trading-indi';

const hammer = new Hammer();
const doji = new Doji();
const marubozu = new MarubozuWhite();

websocket.on('tick', (bar) => {
  const isHammer = hammer.onData(bar);
  const isDoji = doji.onData(bar);
  const isMarubozu = marubozu.onData(bar);

  if (isHammer) console.log('Hammer pattern detected - potential reversal');
  if (isDoji) console.log('Doji pattern detected - indecision');
  if (isMarubozu) console.log('Marubozu White - strong bullish momentum');
});

Computation Primitives

Build custom calculations using composable primitive operators. These are the building blocks for creating complex trading logic in the DAG flow system.

Arithmetic Operators

Operator Input Output Description
Add lhs, rhs number Addition
Sub lhs, rhs number Subtraction
Mul lhs, rhs number Multiplication
Div lhs, rhs number Division (safe from divide-by-zero)
Mod lhs, rhs number Modulo
Pow base, exp number Power
Min lhs, rhs number Minimum of two values
Max lhs, rhs number Maximum of two values
Negate x number Negation
Abs x number Absolute value
Sign x -1, 0, 1 Sign of number
Floor x number Floor function
Ceil x number Ceiling function
Round x number Round to nearest integer
Sqrt x number Square root
Log x number Natural logarithm
Exp x number Exponential (e^x)
Log1p x number log(1 + x)
Expm1 x number exp(x) - 1
Reciprocal x number 1/x
Clamp x, min, max number Clamp value between min and max
Lerp a, b, t number Linear interpolation
InvLerp a, b, v number Inverse linear interpolation
SumOf ...inputs number Sum of multiple values
ProdOf ...inputs number Product of multiple values
AvgOf ...inputs number Average of multiple values
MinOf ...inputs number Minimum of multiple values
MaxOf ...inputs number Maximum of multiple values
RelDist a, b number Relative distance: abs(a-b)/abs(b)

Logical Operators

Operator Input Output Description
LT lhs, rhs boolean Less than
GT lhs, rhs boolean Greater than
LTE lhs, rhs boolean Less than or equal
GTE lhs, rhs boolean Greater than or equal
EQ lhs, rhs boolean Equal
NEQ lhs, rhs boolean Not equal
Between x, lo, hi boolean Check if x is between lo and hi
Outside x, lo, hi boolean Check if x is outside lo and hi
And lhs, rhs boolean Logical AND
Or lhs, rhs boolean Logical OR
Not x boolean Logical NOT
Xor lhs, rhs boolean Logical XOR
AllOf ...inputs boolean All inputs are true
AnyOf ...inputs boolean Any input is true
NoneOf ...inputs boolean No inputs are true
IsNaN x boolean Check if NaN
IsFinite x boolean Check if finite
IsPositive x boolean Check if positive
IsNegative x boolean Check if negative
IsZero x boolean Check if zero
IfThenElse cond, thenVal, elseVal T Conditional selection
Gate cond, val T | undefined Pass value if condition is true
Coalesce ...inputs T | undefined Return first non-null value

DAG Flow System

The GraphExec and OpRegistry provide a powerful DAG (Directed Acyclic GraphExec) execution engine for building complex, composable trading strategies. Define your computation as a graph of operators with dependencies, and the system handles topological sorting and execution.

Key Features

  • Topological Execution: Automatically determines correct execution order
  • Type Safety: Zod-based schema validation
  • JSON Serialization: Save and load graphs as JSON
  • Forward References: Support for future node references
  • High Performance: Index-based adjacency lists, 2M+ ops/sec
  • AI-Friendly: Schema designed for AI agent code generation

Example: Multi-Indicator Strategy with DAG

import { GraphExec, OpRegistry } from '@junduck/trading-indi';

// Register all operators you want to use
OpRegistry.registerDefaults();

// Define your strategy as a graph
const graph = new GraphExec('trading-strategy');

// Input nodes
graph.addNode('close', 'Input', []);
graph.addNode('high', 'Input', []);
graph.addNode('low', 'Input', []);

// Calculate indicators
graph.addNode('rsi', 'RSI', ['close'], { period: 14 });
graph.addNode('ema20', 'EMA', ['close'], { period: 20 });
graph.addNode('ema50', 'EMA', ['close'], { period: 50 });

// Build trading logic with primitives
graph.addNode('rsi_oversold', 'LT', ['rsi', 30]);  // RSI < 30
graph.addNode('ema_bullish', 'GT', ['ema20', 'ema50']);  // EMA20 > EMA50
graph.addNode('buy_signal', 'And', ['rsi_oversold', 'ema_bullish']);

// Process streaming data
websocket.on('tick', (bar) => {
  graph.update('close', bar.close);
  graph.update('high', bar.high);
  graph.update('low', bar.low);

  const buySignal = graph.read('buy_signal');
  const rsi = graph.read('rsi');

  if (buySignal) {
    console.log(`BUY SIGNAL: RSI=${rsi}`);
  }
});

// Serialize to JSON for storage or AI agent generation
const schema = graph.exportSchema();
console.log(JSON.stringify(schema, null, 2));

// Load from JSON
const restoredGraph = GraphExec.fromSchema(schema);

Example: Complex Strategy with Multiple Outputs

import { GraphExec, OpRegistry } from '@junduck/trading-indi';

OpRegistry.registerDefaults();

const graph = new GraphExec('advanced-strategy');

// Inputs
graph.addNode('bar', 'Input', []);

// Multiple indicators
graph.addNode('rsi', 'RSI', ['bar'], { period: 14 });
graph.addNode('macd_result', 'MACD', ['bar'], {
  period_fast: 12,
  period_slow: 26,
  period_signal: 9
});
graph.addNode('atr', 'ATR', ['bar'], { period: 14 });

// Extract MACD components
graph.addNode('macd_line', 'GetField', ['macd_result', 'macd']);
graph.addNode('signal_line', 'GetField', ['macd_result', 'signal']);

// Build complex conditions
graph.addNode('rsi_bullish', 'Between', ['rsi', 30, 50]);
graph.addNode('macd_crossover', 'GT', ['macd_line', 'signal_line']);
graph.addNode('strong_signal', 'And', ['rsi_bullish', 'macd_crossover']);

// Calculate position sizing based on ATR
graph.addNode('atr_multiplier', 'Mul', ['atr', 2]);
graph.addNode('position_size', 'Div', [1000, 'atr_multiplier']);

// Update with streaming data
for (const bar of streamingData) {
  graph.update('bar', bar);

  const signal = graph.read('strong_signal');
  const posSize = graph.read('position_size');
  const atr = graph.read('atr');

  if (signal) {
    console.log(`Entry Signal - Position Size: ${posSize}, Stop Loss: ${atr * 2}`);
  }
}

Real-World Example: Intraday Strategy

import { RSI, ATR, EMA, BBANDS, ADX, MACD, VOLUME } from '@junduck/trading-indi';

const rsi = new RSI({ period: 14 });
const atr = new ATR({ period: 14 });
const ema20 = new EMA({ period: 20 });
const ema50 = new EMA({ period: 50 });
const bbands = new BBANDS({ period: 20, stddev: 2 });
const adx = new ADX({ period: 14 });
const macd = new MACD({ period_fast: 12, period_slow: 26, period_signal: 9 });
const obv = new OBV();

websocket.on('tick', (bar) => {
  const rsiValue = rsi.onData(bar);
  const atrValue = atr.onData(bar);
  const shortEMA = ema20.onData(bar.close);
  const longEMA = ema50.onData(bar.close);
  const { upper, middle, lower } = bbands.onData(bar.close);
  const adxValue = adx.onData(bar);
  const { macd: macdLine, signal, histogram } = macd.onData(bar);
  const obvValue = obv.onData(bar);

  // Multi-indicator strategy
  const isOversold = rsiValue < 30;
  const isBullishTrend = shortEMA > longEMA;
  const isStrongTrend = adxValue > 25;
  const isNearSupport = bar.close <= lower * 1.02; // Within 2% of lower band
  const isMACDBullish = macdLine > signal && histogram > 0;
  const isVolumeConfirming = obvValue > 0; // Positive volume flow

  if (isOversold && isBullishTrend && isStrongTrend && isNearSupport && isMACDBullish && isVolumeConfirming) {
    console.log('Strong Buy Signal - Multiple Confirmations');
    console.log(`Entry: ${bar.close}`);
    console.log(`Stop Loss: ${bar.close - (atrValue * 2)}`);
    console.log(`Target: ${bar.close + (atrValue * 3)}`);
    console.log(`RSI: ${rsiValue}, ADX: ${adxValue}, MACD: ${macdLine}`);
  }

  // Exit signal
  const isOverbought = rsiValue > 70;
  const isBearishMACD = macdLine < signal && histogram < 0;
  const isNearResistance = bar.close >= upper * 0.98; // Within 2% of upper band

  if (isOverbought || isBearishMACD || isNearResistance) {
    console.log('Exit Signal - Consider Taking Profits');
    console.log(`Current Price: ${bar.close}`);
    console.log(`RSI: ${rsiValue}, MACD: ${macdLine}, BB Position: ${(bar.close - lower) / (upper - lower)}`);
  }
});

Statistical Analysis

The library includes advanced statistical indicators for quantitative analysis:

import { Corr, Beta, ZSCORE } from '@junduck/trading-indi';

// Correlation between two assets
const correlation = new Corr({ period: 20 });
const corrValue = correlation.onData(assetPrice, benchmarkPrice);

// Beta calculation for risk analysis
const beta = new Beta({ period: 252 }); // Daily data for 1 year
const betaValue = beta.onData(stockPrice, marketIndexPrice);

// Z-Score for statistical arbitrage
const zscore = new ZSCORE({ period: 20 });
const zValue = zscore.onData(price);

API Reference

Exports

The library exports all its capabilities from the main package:

// Technical Indicators (80+)
import {
  // Foundation
  SMA, EMA, EWMA, Variance, Stddev, Min, Max, Sum, MinMax,

  // Statistics
  VarianceEW, Cov, Corr, Beta, ZSCORE, CORRELATION,

  // Volatility
  VOLATILITY, CVI, MASS, TR, ATR, NATR, PriceChannel, BBANDS, KC, DC,

  // Momentum
  BOP, MOM, ROC, ROCR, RSI, CMO, WAD, RVI, TSI, BBPOWER,

  // Oscillators
  AO, APO, DPO, Fisher, MACD, PPO, QSTICK, TRIX, ULTOSC,

  // Stochastic
  STOCH, STOCHRSI, WILLR,

  // Trend
  AROON, AROONOSC, CCI, VHF, DM, DI, DX, ADX, ADXR, SAR, VI, ICHIMOKU,

  // Volume
  AD, ADOSC, KVO, NVI, OBV, PVI, MFI, EMV, MarketFI, VOSC, CMF, CHO, PVO, FI, VROC, PVT
} from '@junduck/trading-indi';

// Pattern Recognition
import {
  Doji, LongLeggedDoji, DragonflyDoji, GravestoneDoji,
  SpinningTop, MarubozuWhite, MarubozuBlack,
  Hammer, InvertedHammer, HighWave
} from '@junduck/trading-indi';

// Computation Primitives
import {
  // Arithmetic
  Add, Sub, Mul, Div, Mod, Pow, Min, Max,
  Negate, Abs, Sign, Floor, Ceil, Round, Sqrt, Log, Exp,
  Log1p, Expm1, Reciprocal, Clamp, Lerp, InvLerp,
  SumOf, ProdOf, AvgOf, MinOf, MaxOf, RelDist,

  // Logical
  LT, GT, LTE, GTE, EQ, NEQ, Between, Outside,
  And, Or, Not, Xor, AllOf, AnyOf, NoneOf,
  IsNaN, IsFinite, IsPositive, IsNegative, IsZero,
  IfThenElse, Gate, Coalesce
} from '@junduck/trading-indi';

// DAG Flow System
import {
  GraphExec, OpRegistry,
  validateGraphSchema, formatValidationError, graphComplexity, graphDiff
} from '@junduck/trading-indi';

// Types
import type {
  NodeSchema, GraphSchema, GraphSchemaValidationResult, GraphError, GraphDiff,
  BarData, BarWith, PeriodOptions
} from '@junduck/trading-indi';

Hook Pattern

Every class-based operator has a corresponding functional hook:

import { useRSI, useSMA, useHammer } from '@junduck/trading-indi';

const getRSI = useRSI({ period: 14 });
const getSMA = useSMA({ period: 20 });
const isHammer = useHammer();

for (const bar of data) {
  const rsi = getRSI(bar);
  const sma = getSMA(bar.close);
  const hammer = isHammer(bar);
}

Bar Data Types

Most indicators accept BarData with these properties:

interface BarData {
  open?: number;
  high?: number;
  low?: number;
  close: number;
  volume?: number;
}

Each indicator only requires the fields it needs. Check TypeScript types for specific requirements.

Use Cases

1. Realtime Trading Bot

import { RSI, MACD, ATR, Hammer } from '@junduck/trading-indi';

const rsi = new RSI({ period: 14 });
const macd = new MACD({ period_fast: 12, period_slow: 26, period_signal: 9 });
const atr = new ATR({ period: 14 });
const hammer = new Hammer();

websocket.on('message', (bar) => {
  const rsiValue = rsi.onData(bar);
  const macdData = macd.onData(bar);
  const atrValue = atr.onData(bar);
  const isHammer = hammer.onData(bar);

  if (rsiValue < 30 && macdData.histogram > 0 && isHammer) {
    placeOrder({
      type: 'BUY',
      stopLoss: bar.close - (atr * 2),
      takeProfit: bar.close + (atr * 3)
    });
  }
});

2. Backtesting Engine

import { useSMA, useEMA, useRSI } from '@junduck/trading-indi';

const getSMA = useSMA({ period: 50 });
const getEMA = useEMA({ period: 20 });
const getRSI = useRSI({ period: 14 });

const results = historicalData.map(bar => ({
  timestamp: bar.timestamp,
  close: bar.close,
  sma50: getSMA(bar.close),
  ema20: getEMA(bar.close),
  rsi: getRSI(bar)
}));

3. Custom Indicator with DAG

import { GraphExec, OpRegistry } from '@junduck/trading-indi';

OpRegistry.registerDefaults();

// Build a custom "Trend Strength" indicator
const graph = new GraphExec('trend-strength');

graph.addNode('close', 'Input', []);
graph.addNode('ema20', 'EMA', ['close'], { period: 20 });
graph.addNode('ema50', 'EMA', ['close'], { period: 50 });
graph.addNode('rsi', 'RSI', ['close'], { period: 14 });
graph.addNode('adx', 'ADX', ['bar'], { period: 14 });

// Calculate trend strength: (EMA20 - EMA50) * RSI/100 * ADX/100
graph.addNode('ema_diff', 'Sub', ['ema20', 'ema50']);
graph.addNode('rsi_norm', 'Div', ['rsi', 100]);
graph.addNode('adx_norm', 'Div', ['adx', 100]);
graph.addNode('strength', 'Mul', ['ema_diff', 'rsi_norm']);
graph.addNode('trend_strength', 'Mul', ['strength', 'adx_norm']);

// Use it
for (const bar of data) {
  graph.update('close', bar.close);
  graph.update('bar', bar);

  const trendStrength = graph.read('trend_strength');
  console.log(`Trend Strength: ${trendStrength}`);
}

4. Multi-Asset Correlation Analysis

import { Corr, Beta } from '@junduck/trading-indi';

const correlation = new Corr({ period: 20 });
const beta = new Beta({ period: 252 });

for (let i = 0; i < assetPrices.length; i++) {
  const corr = correlation.onData(assetPrices[i], benchmarkPrices[i]);
  const betaValue = beta.onData(assetPrices[i], benchmarkPrices[i]);

  console.log(`Correlation: ${corr.correlation}, Beta: ${betaValue.beta}`);
}

Summary

trading-indi provides a complete framework for building incremental trading algorithms:

Category Count Highlights
Technical Indicators 80+ SMA, EMA, RSI, MACD, ATR, BBANDS, ADX, Ichimoku, and more
Pattern Recognition 10+ Doji, Hammer, Marubozu, Spinning Top, High Wave
Arithmetic Primitives 28 Add, Sub, Mul, Div, Pow, Sqrt, Log, Clamp, Lerp, SumOf, AvgOf, etc.
Logical Primitives 23 LT, GT, EQ, And, Or, Not, Between, IfThenElse, AllOf, AnyOf, etc.
Flow System 1 DAG engine GraphExec, OpRegistry, Schema validation, JSON serialization

Key Features

  • Incremental Calculation: All operators maintain state and update efficiently
  • High Performance: 2M+ operations/sec, suitable for tick data
  • Memory Efficient: Sliding windows and online algorithms
  • Type Safe: Full TypeScript support with strict typing
  • Composable: Build complex strategies from simple building blocks
  • AI-Friendly: OperatorDoc schema for AI agent code generation
  • Zero Dependencies: Clean, modern TypeScript

Getting Started

  1. Simple indicator: Use class-based or hook pattern for individual indicators
  2. Pattern recognition: Detect candlestick patterns in realtime
  3. Custom calculations: Combine primitives for custom logic
  4. Complex strategies: Use DAG flow system to compose multi-indicator strategies
  5. Serialization: Save/load strategies as JSON for portability

Changelog

See CHANGELOG.md for a detailed history of changes.

License

MIT

About

A TypeScript library for technical indicators with incremental, stateful calculation optimized for real-time and intraday trading applications.

Topics

real-time typescript trading cryptocurrency stock-market algorithmic-trading technical-indicators

Resources

Readme

License

MIT license
Activity

Stars

8 stars

Watchers

1 watching

Forks

4 forks
Report repository

Releases

No releases published

Packages

No packages published

Languages