EXAMPLES.md

Technical Analysis (ta.js)

ta.js is a JavaScript module for dealing with financial technical analysis.

NOTE

A react compatible version of this package is available here: https://github.com/Bitvested/ta.web

Installation

NPM

Use the package manager npm to install ta.js.

npm install ta.js --save

CDN

<script src="https://unpkg.com/ta.js/ta.min.js"></script>

Usage

const ta = require('ta.js');

Examples

Moving Averages

• Simple Moving Average
• Smoothed Moving Average
• Weighted Moving Average
• Exponential Moving Average
• Hull Moving Average
• Least Squares Moving Average
• Volume Weighted Moving Average
• Volume Weighted Weighted Moving Average
• Wilder's Smoothing Moving Average
• Parabolic Weighted Moving Average
• Hyperbolic Weighted Moving Average
• Kaufman Adaptive Moving Average
• Custom Weighted Moving Average

Indicators

• Moving Average Convergence / Divergence
• MACD Signal
• MACD Bars
• Relative Strength Index
• Wilder's Relative Strength Index
• True Strength Index
• Balance Of Power
• Force Index
• Accumulative Swing Index
• Alligator Indicator
• Williams %R
• Stochastics
• Fibonacci Retracement
• Bollinger Bandwidth
• Ichimoku Cloud
• Average True Range
• Aroon Up
• Aroon Down
• Money Flow Index
• Rate Of Change
• Coppock Curve
• Know Sure Thing
• On-Balance Volume
• Volume-Weighted Average Price
• Fractals
• Crossover
• Momentum
• HalfTrend
• ZigZag
• Parabolic SAR
• SuperTrend
• Elder Ray Index
• Historical Volatility
• Relative Vigor Index
• Relative Vigor Index Signal
• RSI Divergence
• Divergence

Oscillators

• Alligator Oscillator
• Chande Momentum Oscillator
• Chaikin Oscillator
• Aroon Oscillator
• Awesome Oscillator
• Accelerator Oscillator
• Fisher Transform

Bands

• Bollinger Bands
• Keltner Channels
• Donchian Channels
• Fibonacci Bollinger Bands
• Envelope

Statistics

• Sum
• Standard Deviation
• Variance
• Normal CDF
• Inverse Normal Distribution
• Monte Carlo Simulation
• Percentile
• Correlation
• Covariance
• Percentage Difference
• Expected Return
• Abnormal Return
• Kelly Criterion
• Martingale
• Anti-Martingale
• Permutations
• Expected Trails
• Winratio
• Average Win
• Average Loss
• Return Positive
• Return Negative
• Drawdown
• Median
• Recent High
• Recent Low
• Median Absolute Deviation
• Average Absolute Deviation
• Standard Error
• Sum Squared Differences
• Logarithm
• Exponent
• Normalize
• Denormalize
• Normalize Pair
• Normalize From
• Standardize
• Z-Score
• P-Value
• K-means Clustering
• Mean Squared Error
• Cumulative

Random functions

• Pseudo Random Number Generator
• Pick Random
• Random Range
• Random Float
• Random Order

Chart Types

• Heikin Ashi
• Renko

Miscellaneous

• Fibonacci Sequence
• Times Up
• Times Down

Experimental

• Support Line
• Resistance Line
• Divergence State

Moving Averages

Simple Moving Average (SMA)

var data = [1, 2, 3, 4, 5, 6, 10];
var length = 6; // default = 14
ta.sma(data, length);
// output (array)
// [3.5, 5]

Smoothed Moving Average (SMMA)

var data = [1, 2, 3, 4, 5, 6, 10];
var length = 5; // default = 14
ta.smma(data, length);
// output (array)
// [3.4, 4.92]

Weighted Moving Average (WMA)

var data = [69, 68, 66, 70, 68];
var length = 4; // default = 14
ta.wma(data, length);
// output (array)
// [68.3, 68.2]

Exponential Moving Average (EMA)

var data = [1, 2, 3, 4, 5, 6, 10];
var length = 6; // default = 12
ta.ema(data, length);
// output (array)
// [3.5, 5.357]

Hull Moving Average

var data = [6, 7, 5, 6, 7, 4, 5, 7];
var length = 6; // default = 14
ta.hull(data, length);
// output (array)
// [4.76, 5.48]

Least Squares Moving Average (LSMA)

var data = [5, 6, 6, 3, 4, 6, 7];
var length = 6; // default = 25
ta.lsma(data, length);
// output (array)
// [4.714, 5.761]

Volume Weighted Moving Average (VWMA)

var data = [[1, 59], [1.1, 82], [1.21, 27], [1.42, 73], [1.32, 42]]; // [price, volume (quantity)]
var length = 4; // default = 20
ta.vwma(data, length);
// output (array)
// [1.185, 1.259]

Volume Weighted Weighted Moving Average

var data = [[1,59],[1.1,82],[1.21,27],[1.42,73],[1.32,42]]; // [price, volume]
var length = 4;
ta.vwwma(data, length);
// output (array)
// [1.262, 1.316]

Wilder's Smoothing Moving Average

var data = [1, 2, 3, 4, 5, 6, 10];
var length = 6; // default = 14
ta.wsma(data, length);
// output (array)
// [3.5, 4.58]

Parabolic Weighted Moving Average

var data = [17, 26, 23, 29, 20];
var length = 4; // default = 14
ta.pwma(data, length);
// output (array)
// [24.09, 25.18]

Hyperbolic Weighted Moving Average

var data = [54, 51, 86, 42, 47];
var length = 4; // default = 14
ta.hwma(data, length);
// output (array)
// [56.2, 55.0]

Kaufman Adaptive Moving Average (KAMA)

var data = [8, 7, 8, 9, 7, 9];
var length1 = 2; // default = 10
var length2 = 4; // default = 2
var length3 = 8; // default = 30
ta.kama(data, length1, length2, length3);
// output (array)
// [8, 8.64, 8.57, 8.57]

Custom Weighted Moving Average

var data = [69,68,66,70,68,69];
var weights = [1,2,3,5,8];
ta.cwma(data, weights);
// output (array)
// [68.26315789473684, 68.52631578947368]

Indicators

Moving Average Convergence / Divergence (MACD)

var data = [1, 2, 3, 4, 5, 6, 14];
var length1 = 3; // default = 12
var length2 = 6; // default = 26
ta.macd(data, length1, length2);
// output (array)
// [1.5, 3]

MACD Signal

var data = [1, 2, 3, 4, 5, 6, 14, 8, 10, 11];
var length1 = 3;
var length2 = 6;
var signal_length = 3;
ta.macd_signal(data, length1, length2, signal_length);
// output (array)
// [2.107, 1.838, 1.653]

MACD Bars

var data = [1, 2, 3, 4, 5, 6, 14, 8, 10, 11];
var length1 = 3;
var length2 = 6;
var signal_length = 3;
ta.macd_bars(data, length1, length2, signal_length);
// output (array)
// [-0.286, -0.269, -0.184]

Relative Strength Index (RSI)

var data = [1, 2, 3, 4, 5, 6, 7, 5];
var length = 6; // default = 14
ta.rsi(data, length);
// output (array)
// [100.0, 100.0, 66.667]

Wilder's Relative Strength Index

var data = [1, 2, 3, 4, 5, 6, 7, 5, 6];
var length = 6; // default = 14
ta.wrsi(data, length);
// output (array)
// [100, 71.43, 75.61]

True Strength Index (TSI)

var data = [1.32, 1.27, 1.42, 1.47, 1.42, 1.45, 1.59];
var longlength = 3; // default = 25
var shortlength = 2; // default = 13
var signallength = 2; // default = 13
ta.tsi(data, longlength, shortlength, signallength);
// output (array)
// [[0.327, 0.320], [0.579, 0.706]]
// [strength line, signal line]

Balance Of Power

var data = [[4, 5, 4, 5], [5, 6, 5, 6], [6, 8, 5, 6]]; // [open, high, low, close]
var length = 2; // default = 14
ta.bop(data, length);
// output (array)
// [1, 0.5]

Force Index

var data = [[1.4, 200], [1.5, 240], [1.1, 300], [1.2, 240], [1.5, 400]]; // [close, volume]
var length = 4; // default = 13
ta.fi(data, length);
// output (array)
// [0.0075]

Accumulative Swing Index

var data = [[7, 6, 4], [9, 7, 5], [9, 8, 6]]; // [high, close, low]
ta.asi(data);
// output (array)
// [0, -12.5]

Alligator Indicator

var data = [8,7,8,9,7,8,9,6,7,8,6,8,10,8,7,9,8,7,9,6,7,9];
// defaults shown
var jawlength = 13;
var teethlength = 8;
var liplength = 5;
var jawshift = 8;
var teethshift = 5;
var lipshift = 3;
ta.alligator(data, jawlength, teethlength, liplength, jawshift, teethshift, lipshift);
// output (array)
// [jaw, teeth, lips]

Williams %R

var data = [2, 1, 3, 1, 2];
var length = 4; // default = 14
ta.pr(data, length);
// output (array)
// [-0, -100, -50]

Stochastics

var data = [[3,2,1], [2,2,1], [4,3,1], [2,2,1]]; // [high, close, low]
var length = 2; // default = 14
var smoothd = 1; // default = 3
var smoothk = 1; // default = 3
ta.stoch(data, length, smoothd, smoothk);
// output (array)
// [[66.667, 66.667], [33.336, 33.336]]
// [kline, dline]

Fibonacci Retracement

var start = 1;
var end = 2;
ta.fib(start, end);
// output (array)
// [1, 1.236, 1.382, 1.5, 1.618, 1.786, 2, 2.618, 3.618, 4.618, 5.236]

Bollinger Bandwidth

var data = [1, 2, 3, 4, 5, 6];
var length = 5; // default = 14
var deviations = 2; // default = 1
ta.bandwidth(data, length, deviations);
// output (array)
// [1.886, 1.344]

Ichimoku Cloud

var data = [[6, 3, 2], [5, 4, 2], [5, 4, 3], [6, 4, 3], [7, 6, 4], [6, 5, 3]]; // [high, close, low]
var length1 = 9; // default = 9
var length2 = 26; // default = 26
var length3 = 52; // default = 52
var displacement = 26; // default = 26
ta.ichimoku(data, length1, length2, length3, displacement);
// output (array)
// [conversion line, base line, leading span A, leading span B, lagging span]

Average True Range (ATR)

var data = [[3,2,1], [2,2,1], [4,3,1], [2,2,1]]; // [high, close, low]
var length = 3; // default = 14
ta.atr(data, length);
// output (array)
// [2, 1.667, 2.111, 1.741]

Aroon Up

var data = [5, 4, 5, 2];
var length = 3; // default = 10
ta.aroon.up(data, length);
// output (array)
// [100, 50]

Aroon Down

var data = [2, 5, 4, 5];
var length = 3; // default = 10
ta.aroon.down(data, length);
// output (array)
// [0, 50]

Money Flow Index

var data = [[19, 13], [14, 38], [21, 25], [32, 17]]; // [buy volume, sell volume]
var length = 3; // default = 14
ta.mfi(data, length);
// output (array)
// [41.54, 45.58]

Rate Of Change

var data = [1, 2, 3, 4];
var length = 3; // default = 14
ta.roc(data, length);
// output (array)
// [2, 1]

Coppock Curve

var data = [3, 4, 5, 3, 4, 5, 6, 4, 7, 5, 4, 7, 5];
var length1 = 4; // (ROC period 1) default = 11
var length2 = 6; // (ROC period 2) default = 14
var length3 = 5; // (WMA smoothing period) default = 10
ta.cop(data, length1, length2, length3);
// output (array)
// [0.376, 0.237]

Know Sure Thing

var data = [8, 6, 7, 6, 8, 9, 7, 5, 6, 7, 6, 8, 6, 7, 6, 8, 9, 9, 8, 6, 4, 6, 5, 6, 7, 8, 9];
// roc sma #1
var r1 = 5; // default = 10
var s1 = 5; // default = 10
// roc sma #2
var r2 = 7; // default = 15
var s2 = 5; // default = 10
// roc sma #3
var r3 = 10; // default = 20
var s3 = 5; // default = 10
// roc sma #4
var r4 = 15; // default = 30
var s4 = 7; // default = 15
// signal line
var sig = 4; // default = 9
ta.kst(data, r1, r2, r3, r4, s1, s2, s3, s4, sig);
// output (array)
// [[-0.68, -0.52], [-0.29, -0.58], [0.35, -0.36]]
// [kst line, signal line]

On-Balance Volume

var data = [[25200, 10], [30000, 10.15], [25600, 10.17], [32000, 10.13]]; // [asset volume, close price]
ta.obv(data);
// output (array)
// [0, 30000, 55600, 23600]

Volume-Weighted Average Price

var data = [[127.21, 89329], [127.17, 16137], [127.16, 23945]]; // [average price, volume (quantity)]
var length = 2; // default = data.length
ta.vwap(data, length);
// output (array)
// [127.204, 127.164]

Fractals

var data = [[7,6],[8,6],[9,6],[8,5],[7,4],[6,3],[7,4],[8,5]]; // [high, low]
ta.fractals(data);
// output (array, same length as input)
// [[false, false],[false,false],[true,false],[false,false],[false,false],[false,true],[false,false],[false,false]]
// [upper fractal, lower fractal]

Crossover (golden cross)

var fastdata = [3,4,5,4,3]; // short period gets spliced when longer
var slowdata = [4,3,2,3,4];
ta.cross(fastdata, slowdata);
// output (array)
// [{index: 1, cross true}, {index: 4, cross: false}]
// cross is true when fastdata is greater than the slowdata

Momentum

var data = [1, 1.1, 1.2, 1.24, 1.34];
var length = 4; // default = 10
var percentage = false; // default = false (true returns percentage)
ta.mom(data, length, percentage);
// output (array)
// [0.24, 0.24]

HalfTrend

// experimental (untested) function (may change in the future), ported from:
// https://www.tradingview.com/script/U1SJ8ubc-HalfTrend/
// data = [high, close, low]
var data = [[100,97,90],[101,98,94],[103,96,92],[106,100,95],[110,101,100],[112,110,105],[110,100,90],[103,100,97],[95,90,85],[94,80,80],[90,82,81],[85,80,70]];
var atrlen = 6;
var amplitude = 3;
var deviation = 2;
ta.halftrend(data, atrlen, amplitude, deviation);
// output (array)
// [[high, halftrend, low, signal]]

ZigZag

// Based on high / low
var data = [[10,9], [12,10], [14,12], [15,13], [16,15], [11,10], [18,15]]; // [high, low]
var percentage = 0.25; // default = 0.05
ta.zigzag(data, percentage);
// output (array)
// [9, 10.75, 12.5, 14.25, 16, 10, 18]

// Based on close
var data = [6,7,8,9,10,12,9,8,5,3,3,3,5,7,8,9,11];
var percentage = 0.05;
ta.zigzag(data, percentage);
// output (array)
// [6, 7.2, 8.4, 9.6, 10.8, 12.0, 10.5, 9.0, 7.5, 6.0, 4.5, 3.0, 4.6, 6.2, 7.8, 9.4, 11.0]

Parabolic SAR

var data = [[82.15,81.29],[81.89,80.64],[83.03,81.31],[83.30,82.65],[83.85,83.07],[83.90,83.11],[83.33,82.49],[84.30,82.3],[84.84,84.15],[85,84.11],[75.9,74.03],[76.58,75.39],[76.98,75.76],[78,77.17],[70.87,70.01]];
var step = 0.02;
var max = 0.2;
ta.psar(data, step, max);
// output (array)
// [81.29,82.15,80.64,80.64,80.7464,80.932616,81.17000672,81.3884061824,81.67956556416,82.0588176964608,85,85,84.7806,84.565588,84.35487624000001]

SuperTrend

var data = [[3,2,1], [2,2,1], [4,3,1], [2,2,1]] // [high, close, low]
var length = 3; // default = 20
var multiplier = 0.5; // default = 3
ta.supertrend(data, length, multiplier);
// output (array)
// [[5.56,1.44],[3.37,0.63]]
// [up, down]

Elder Ray Index

var data = [6,5,4,7,8,9,6,8];
var length = 7;
ta.elderray(data, length);
// output (array)
// [[2.57,-2.43],[2.29,-2.71]]
// [bull, bear]

Historical Volatility

var data = [7,6,5,7,8,9,7,6,5];
var length = 8;
ta.hv(data, length);
// output (array)
// [0.642, 0.682]

Relative Vigor Index

// data = [[open,high,low,close]] (requires at least 4 + length values)
var data = [[4,6,3,3], [3,5,2,2], [2,5,2,4], [4,6,4,5], [5,7,4,4], [4,6,3,4], [4,7,3,5], [5,7,5,6], [6,8,6,6], [6,9,5,6], [6,8,6,7], [7,9,5,6],[6,7,4,5],[5,6,5,6],[6,8,5,5],[5,7,2,6]];
var length = 8;
ta.rvi(data, length);
// output (array)
// [0.29,0.21,0.15,0.16,0.09,0.05]

Relative Vigor Index Signal

var rvi = [0.29,0.21,0.15,0.16,0.09,0.05]; // requires at least 4 values
ta.rvi_signal(rvi);
// output (array)
// [0.20,0.15,0.12]

RSI Divergence

Experimental function: #18

var data = [74,83,66,78,69,70,84,73,74,73,83];
var rsi_length = 5;
var rsi_function = ta.wrsi; // default (the tradingview rsi indicator)
ta.rsi_divergence(data, rsi_length, rsi_function);
// output (array)
// 1 = RSI is in divergence
// 0 = RSI is not in divergence
// [0, 0, 1, 0, 1, 0] (better to quantify if needed)

Universal Divergence

var data1 = [48,34,43,54,56,64,43];
var data2 = [76,74,43,55,34,32,45,47];
ta.divergence(data1, data2);
// output (array)
// 1 = RSI is in divergence
// 0 = RSI is not in divergence
// [0, 0, 1, 1, 0, 1] (better to quantify if needed)

Oscillators

Alligator Oscillator

var data = [8,7,8,9,7,8,9,6,7,8,6,8,10,8,7,9,8,7,9,6,7,9];
// defaults shown
var jawlength = 13;
var teethlength = 8;
var liplength = 5;
var jawshift = 8;
var teethshift = 5;
var lipshift = 3;
ta.gator(data, jawlength, teethlength, liplength, jawshift, teethshift, lipshift);
// output (array)
// [upper gator, lower gator]

Chande Momentum Oscillator

var data = [1, 1.2, 1.3, 1.3, 1.2, 1.4];
var length = 4; // default = 9
ta.mom_osc(data, length);
// output (array)
// [0, 3.85]

Chaikin Oscillator

var data = [[2,3,4,6],[5,5,5,4],[5,4,3,7],[4,3,3,4],[6,5,4,6],[7,4,3,6]]; // [high, close, low, volume]
var length1 = 2; // default = 3
var length2 = 4; // default = 10
ta.chaikin_osc(data, length1, length2);
// output (array)
// [-1.667, -0.289, -0.736]

Aroon Oscillator

var data = [2, 5, 4, 5];
var length = 3; // default = 25
ta.aroon.osc(data, length);
// output (array)
// [50, 50]

Awesome Oscillator

var data = [[6, 5], [8, 6], [7, 4], [6, 5], [7, 6], [9, 8]]; // [high, low]
var shortlength = 2; // default = 5
var longlength = 5; // default = 35
ta.ao(data, shortlength, longlength);
// output (array)
// [0, 0.9]

Accelerator Oscillator

var data = [[6, 5], [8, 6], [7, 4], [6, 5], [7, 6], [9, 8]]; // [high, low]
var shortlength = 2; // default = 5
var longlength = 4; // default = 35
ta.ac(data, shortlength, longlength);
// output (array)
// [-5.875, -6.125, -6.5]

Fisher Transform

var data = [8,6,8,9,7,8,9,8,7,8,6,7]; // high + low / 2
var length = 9;
ta.fisher(data, length);
// output (array)
// [[-0.318, -0.11], [-0.449, -0.318], [-0.616, -0.449]] // [fisher, trigger]

Bands

Bollinger Bands

var data = [1, 2, 3, 4, 5, 6];
var length = 5; // default = 14
var deviations = 2; // default = 1
ta.bands(data, length, deviations);
// output (array)
// [[5.828, 3, 0.172], [6.828, 4, 1.172]]
// [upper band, middle band, lower band]

Keltner Channels

var data = [[3,2,1], [2,2,1], [4,3,1], [2,2,1], [3,3,1]]; // [high, close, low]
var length = 5; // default = 14
var deviations = 1; // default = 1
ta.keltner(data, length, deviations);
// output (array)
// [[3.93, 2.06, 0.20]]
// [upper band, middle band, lower band]

Donchian Channels

var data = [[6, 2], [5, 2], [5, 3], [6, 3], [7, 4], [6, 3]]; // [high, low]
var length = 5; // default = 20
ta.don(data, length);
// output (array)
// [[7, 4.5, 2], [7, 4.5, 2]]
// [upper band, base line, lower band]

Fibonacci Bollinger Bands

// created from: https://tradingview.com/script/qIKR3tbN-Fibonacci-Bollinger-Bands/
var data = [[1,59],[1.1,82],[1.21,27],[1.42,73],[1.32,42]]; // [price, volume]
var length = 4; // default = 20
var deviations = 3; // default = 3
ta.fibbands(data, length, deviations);
// output (array)
// [[highest band -> fibonacci levels -> lowest band]]

Envelope

var data = [6,7,8,7,6,7,8,7,8,7,8,7,8];
var length = 11, // default = 10
var percentage = 0.05; // default = 0.005
ta.envelope(data, length, percentage);
// output (array)
// [[7.541, 7.182, 6.823], [7.636, 7.273, 6.909]]
// [upper band, base line, lower band]

Statistics

Sum

var data = [1,2,3];
ta.sum(data);
// output (float)
// 6

Standard Deviation

var data = [1, 2, 3];
var length = 3; // default = data.length
ta.std(data, length);
// output (float)
// 0.81649658092773

Variance

var data = [6, 7, 2, 3, 5, 8, 6, 2];
var length = 7; // default = data.length
ta.variance(data, length);
// output (array)
// [3.918, 5.061]

Normal CDF

var sample = 13;
var mean = 10;
var stdv = 2;
ta.ncdf(sample, mean, stdv);
// output (float)
// 0.9331737996110652

var zscore = 1.5;
ta.ncdf(zscore);
// output (float)
// 0.9331737996110652

Inverse Normal Distribution

var data = 0.4732;
ta.normsinv(data);
// output (float)
// -0.06722824471054376

Monte Carlo Simulation

var data = [6, 4, 7, 8, 5, 6];
var length = 2; // default = 50
var simulations = 100; // default = 1000
var percentile = 0.5; // default = undefined (returns all raw simulations)
ta.sim(data, length, simulations, percentile);
// output (array)
// [6, 4, 7, 8, 5, 6, 5.96, 5.7]

Multi threaded ~ not faster in all cases (node version >= 12)

await ta.multi.sim(data, length, simulations, percentile);

Percentile

var data = [[6,4,7], [5,3,6], [7,5,8]];
var percentile = 0.5;
ta.percentile(data, percentile);
// output (array)
// [6, 4, 7]

Correlation

var data1 = [1, 2, 3, 4, 5, 2];
var data2 = [1, 3, 2, 4, 6, 3];
ta.cor(data1, data2);
// output (float)
// 0.8808929232684737

Covariance

var data1 = [12,13,25,39];
var data2 = [67,45,32,21];
var length = 4;
ta.covariance(data1, data2, 4);
// output (array)
// [-165.8125]

Percentage Difference

var newval = 0.75;
var oldval = 0.5;
ta.dif(newval, oldval);
// output (float)
// 0.5

Expected Return

var data = [0.02, -0.01, 0.03, 0.05, -0.03]; // historical return data
ta.er(data);
// output (float)
// 0.0119

Abnormal Return

var data = [0.02, -0.01, 0.03, 0.05, -0.03]; // historical return data
var length = 3;
ta.ar(data, length);
// output (array)
// [0.037, -0.053]

Kelly Criterion

var data = [0.01, 0.02, -0.01, -0.03, -0.015, 0.045, 0.005];
ta.kelly(data);
// output (float)
// 0.1443

Martingale

var data = [-1,-1,1,1,-1,-1]; // win or loss (> 0 || < 0)
var bet = 5;
var max = 20;
var multiplier = 2; // default = 2
ta.martingale(data, bet, max, multiplier);
// output (float)
// 20

Anti-Martingale

var data = [1,1,-1,-1,1,1]; // win or loss (> 0 || < 0)
var bet = 5;
var max = 20;
var multiplier = 2; // default = 2
ta.antimartingale(data, bet, max, multiplier);
// output (float)
// 20

Permutations

var data = [10,10,10];
ta.permutations(data);
// output (int)
// 1000

Expected Trails

var samples = 100;
ta.expected_trails(samples);
// output (int)
// 519

Winratio

var data = [0.01, 0.02, -0.01, -0.03, -0.015, 0.005];
ta.winratio(data);
// output (float)
// 0.5

Average Win

var data = [0.01, 0.02, -0.01, -0.03, -0.015, 0.005];
ta.avgwin(data);
// output (float)
// 0.012

Average Loss

var data = [0.01, 0.02, -0.01, -0.03, -0.015, 0.005];
ta.avgloss(data);
// output (float)
// -0.018

Return Positive

var data = [0.02,0.01,-0.03,-0.01,0.005];
ta.return_positive(data);
// output (array)
// [0.02,0.01,0.005]

Return Negative

var data = [0.02,0.01,-0.03,-0.01,0.005];
ta.return_negative(data);
// output (array)
// [-0.03,-0.01]

Drawdown

var data = [1, 2, 3, 4, 2, 3];
ta.drawdown(data);
// output (float)
// -0.5

Median

var data = [4, 6, 3, 1, 2, 5];
var length = 4; // default = data.length
ta.median(data, length);
// output (array)
// [3, 2, 2]

Recent High

var data = [4,5,6,7,8,9,8,7,8,9,10,3,2,1];
var lookback = 3; // No higher values after 3 periods? resets after each new high
ta.recent_high(data, lookback);
// output (object)
// {index: 10, value: 10}

Recent Low

var data = [1,4,5,6,4,3,2,3,4,3,5,7,8,8,5];
var lookback = 4; // No lower values after 4 periods? resets after each new low
ta.recent_low(data, lookback);
// output (object)
// {index: 6, value: 2}

Median Absolute Deviation

var data = [3, 7, 5, 4, 3, 8, 9];
var length = 6; // default = data.length
ta.mad(data, length);
// output (array)
// [1, 2]

Average Absolute Deviation

var data = [4, 6, 8, 6, 8, 9, 10, 11];
var length = 7; // default = data.length
ta.aad(data, length);
// output (array)
// [1.673, 1.468]

Standard Error

var data = [34, 54, 45, 43, 57, 38, 49];
var size = 10; // default = data.length
ta.se(data, size);
// output (float)
// 2.424

Sum Squared Differences

var data = [7, 6, 5, 7, 9, 8, 3, 5, 4];
var length = 7; // default = data.length
ta.ssd(data, length);
// output (array)
// [4.87, 4.986, 5.372]

Logarithm

var data = [5, 14, 18, 28, 68, 103];
ta.log(data);
// output (array)
// [1.61, 2.64, 2.89, 3.33, 4.22, 4.63]

Exponent

var data = [1.6, 2.63, 2.89, 3.33, 4.22, 4.63];
ta.exp(data);
// output (array)
// [4.95, 13.87, 17.99, 27.94, 68.03, 102.51]

Normalize

var data = [5,4,9,4];
var margin = 0.1; // margin % (default = 0)
ta.normalize(data, margin);
// output (array)
// [0.22, 0.06, 0.86, 0.06]

Denormalize

var data = [5,4,9,4]; // original data || [highest, lowest]
var norm = [0.22, 0.06, 0.86, 0.06, 0.44]; // normalized data
var margin = 0.1; // margin % (default = 0)
ta.denormalize(data, norm, margin);
// output (array)
// [5 ,4, 9, 4, 6.4]

Normalize Pair

var pair1 = [10,12,11,13];
var pair2 = [100,130,100,140];
ta.normalize_pair(pair1, pair2);
// output (array)
// [[55, 55], [66, 71.5], [60.5, 54.99], [71.5, 76.99]]

Normalize From

var data = [8, 12, 10, 11];
var baseline = 100;
ta.normalize_from(data, baseline);
// output (array)
// [100, 150, 125, 137.5]

Standardize

var data = [6,4,6,8,6];
ta.standardize(data);
// output (array)
// [0, -1.581, 0, 1.581, 0]

Z-Score

var data = [34,54,45,43,57,38,49];
var length = 5;
ta.zscore(data, length);
// output (array)
// [1.266, -1.331, 0.408]

P-Value

var t_stat = 2;
var df = 4;
ta.pvalue(t_stat, df);
// output (float)
// 0.075

K-means Clustering

var data = [2, 3, 4, 5, 3, 5, 7, 8, 6, 8, 6, 4, 2, 6];
var length = 4;
ta.kmeans(data, length);
// output (array)
// [[ 4, 5, 5, 4 ], [ 7, 6, 6, 6 ], [ 8, 8 ], [ 2, 3, 3, 2 ]]

Mean Squared Error

var data1 = [7,8,7,8,6,9];
var data2 = [6,8,8,9,6,8];
ta.mse(data1, data2);
// output (float)
// 0.6666666666666666

Cumulative

var data = [3,5,7,5,10];
var length = 4;
ta.cum(data, length);
// output (array)
// [20, 27]

Random Functions

Pseudo Random Number Generator

var seed = "abcdefg"; // string || number
var prng = ta.random.prng(seed);
console.log(prng());
// output (float)
// 0.9100735441315919

Pick Random

var data = ['a', 'b', 'c'];
var prng = ta.random.prng('abcdefg');
ta.random.pick(data, prng); // default number generator = Math.random
// output (array element)
// 'c'

Random Range

var min = 10;
var max = 50;
var prng = ta.random.prng('abcdefg');
ta.random.range(min, max, prng); // default number generator = Math.random
// output (int)
// 46

Random Float

var min = 1.4;
var max = 2.8;
var prng = ta.random.prng('abcdefg');
ta.random.float(min, max, prng); // default number generator = Math.random
// output (float)
// 2.6741029617842287

Random Order

var data = ['a','b','c','d','e'];
var prng = ta.random.prng('abcdefg');
ta.random.order(data, prng); // default number generator = Math.random
// output (array)
// ['e', 'c', 'b', 'd', 'a'];

Chart Types

Heikin Ashi

var data = [[3, 4, 2, 3], [3, 6, 3, 5], [5, 5, 2, 3]]; // [open, high, low, close]
ta.ha(data);
// output (array)
// [open, high, low, close]
// first 7-10 candles are unreliable

Renko

var data = [[8, 6], [9, 7], [9, 8]]; // [high, low]
var bricksize = 3;
ta.ren(data, bricksize);
// output (array)
// [open, high, low, close]

Miscellaneous

Fibonacci Sequence

ta.fibnumbers;
// output (array)
// [0, 1, 1, 2, 3, 5, 8...];

Times Up

var data = [5,6,7,8,7,6,5];
var length = 3;
ta.times_up(data, length);
// output (array)
// [1, 0, 0, 0]

Times Down

var data = [5,6,7,8,7,6,5];
var length = 3;
ta.times_down(data, length);
// output (array)
// [0, 0, 0, 1]

Experimental Functions

Support Line

var data = [4,3,2,5,7,6,5,4,7,8,5,4,6,7,5];
var start = {index: 2, value: 2}; // default = recent_low(data, 25);
var support = ta.support(data, start);
// output (object)
// support.calculate = function(x) // calculates line at position x from start.index (= 0)
// support.slope = delta y per x
// support.lowest = lowest (start) value at x = 0
// support.index = (start) index of the lowest value
// to get the line at the current candle / chart period
var current = support.calculate(data.length-support.index);

Resistance Line

var data = [5,7,5,5,4,6,5,4,6,5,4,3,2,4,3,2,1];
var start = {index: 1, value: 7}; // default = recent_high(data, 25);
var resistance = ta.resistance(data, start);
// output (object)
// resistance.calculate = function(x) // calculates line at position x from start.index (= 0)
// resistance.slope = delta y per x
// resistance.highest = highest (start) value
// resistance.index = (start) index of highest value
// to get the line at the current candle / chart period
var current = resistance.calculate(data.length-resistance.index);

Divergence State

Beware as more data becomes available values returned by the function could change! #18

var data1 = [48,34,43,54,56,64,43,51,52,53,55,51,48,45,40,42,44,45];
var data2 = [76,74,43,55,34,32,45,47,48,53,54,54,50,52,49,47,48,46];
var length = 12; // array length to check
var lookback = 3; // lookback length to check for recent_low / recent_high (please check function code for more info)
var smoother = 1; // smooth divergence lookback period
var threshold_exaggerated = 0.03; // percentual change threshold for 'exaggerated' divergence
var threshold_normal = 0.01; // percentual change threshold for 'normal' and 'hidden' divergence
ta.divergence_state(data1, data2, length, lookback, smoother, threshold_exaggerated, threshold_normal);
// output (array of arrays)
// [['convergence'],['divergence'],['convergence'],['divergence'],['convergence'],['exaggerated_bearish']]
// it is possible for multiple states to exist at once
// possible states are: exaggerated_bearish, exaggerated_bullish, hidden_bearish, hidden_bullish, regular_bearish, regular_bullish and convergence

Contributing

Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

License

MIT