Technical Analysis (ta.py)

ta.py is a Python package for dealing with financial technical analysis.

Installation

pip

Use the package manager pip to install ta.py.

pip install ta_py

Usage

import ta_py as ta;

Examples

• Simple Moving Average
• Smoothed Moving Average
• Weighted Moving Average
• Wilder's Smoothing Moving Average
• Parabolic Weighted Moving Average
• Hyperbolic Weighted Moving Average
• Hull Moving Average
• Kaufman Adaptive Moving Average
• Volume Weighted Moving Average
• Exponential Moving Average
• Least Squares Moving Average
• Moving Average Convergence / Divergence
• Relative Strength Index
• Wilder's Relative Strength Index
• True Strength Index
• Balance Of Power
• Force Index
• Accumulative Swing Index
• Awesome Oscillator
• Accelerator Oscillator
• Fibonacci Retracement
• Williams %R
• Recent High
• Recent Low
• Stochastics
• Variance
• Standard Deviation
• Inverse Normal Distribution
• Monte Carlo Simulation
• Percentile
• Correlation
• Percentage Difference
• Drawdown
• Median
• K-means Clustering
• Normalize
• Denormalize
• Median Absolute Deviation
• Average Absolute Deviation
• Sum Squared Differences
• Bollinger Bands
• Bollinger Bandwidth
• Keltner Channels
• Donchian Channels
• Envelope
• Ichimoku Cloud
• Average True Range
• Aroon Up
• Aroon Down
• Aroon Oscillator
• Money Flow Index
• Rate Of Change
• Coppock Curve
• Know Sure Thing
• On-Balance Volume
• Volume-Weighted Average Price
• Chande Momentum Oscillator
• Chaikin Oscillator
• Fractals
• Momentum
• Heikin Ashi
• Renko

Experimental

• Support Line
• Resistance Line

Simple Moving Average (SMA)

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

Smoothed Moving Average (SMMA)

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

Weighted Moving Average (WMA)

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

Wilder's Smoothing Moving Average

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

Parabolic Weighted Moving Average

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

Hyperbolic Weighted Moving Average

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

Hull Moving Average

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

Kaufman Adaptive Moving Average (KAMA)

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

Volume Weighted Moving Average (VWMA)

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

Exponential Moving Average (EMA)

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

Least Squares Moving Average (LSMA)

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

Moving Average Convergence / Divergence (MACD)

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

Relative Strength Index (RSI)

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

True Strength Index (TSI)

data = [1.32, 1.27, 1.42, 1.47, 1.42, 1.45, 1.59];
longlength = 3; # default = 25
shortlength = 2; # default = 13
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

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

Force Index

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

Accumulative Swing Index

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

Awesome Oscillator

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

Accelerator Oscillator

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

Fibonacci Retracement

start = 1;
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]

Williams %R

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

Recent High

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

Recent Low

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

Stochastics

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

Variance

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

Standard Deviation

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

Inverse Normal Distribution

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

Monte Carlo Simulation

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

Percentile

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

Correlation

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

Percentage Difference

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

Drawdown

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

Median

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

K-means Clustering

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

Normalize

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

Denormalize

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

Median Absolute Deviation

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

Average Absolute Deviation

data = [4, 6, 8, 6, 8, 9, 10, 11];
length = 7; # default = len(data)
ta.aad(data, length);
# output (array)
# [1.673, 1.469]

Sum Squared Differences

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

Bollinger Bands

data = [1, 2, 3, 4, 5, 6];
length = 5; # default = 14
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]

Bollinger Bandwidth

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

Keltner Channels

data = [[3,2,1], [2,2,1], [4,3,1], [2,2,1], [3,3,1]]; # [high, close, low]
length = 5; # default = 14
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

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

Envelope

data = [6,7,8,7,6,7,8,7,8,7,8,7,8];
length = 11, # default = 10
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]

Ichimoku Cloud

data = [[6, 3, 2], [5, 4, 2], [5, 4, 3], [6, 4, 3], [7, 6, 4], [6, 5, 3]]; # [high, close, low]
length1 = 9; # default = 9
length2 = 26; # default = 26
length3 = 52; # default = 52
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)

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

Aroon Up

data = [5, 4, 5, 2];
length = 3; # default = 10
ta.aroon_up(data, length);
# output (array)
# [100.0, 50.0]

Aroon Down

data = [2, 5, 4, 5];
length = 3; # default = 10
ta.aroon_down(data, length);
# output (array)
# [0.0, 50.0]

Aroon Oscillator

data = [2, 5, 4, 5];
length = 3; # default = 25
ta.aroon_osc(data, length);
# output (array)
# [50.0, 50.0]

Money Flow Index

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

Rate Of Change

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

Coppock Curve

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

Know Sure Thing

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

On-Balance Volume

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

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

Chande Momentum Oscillator

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

Chaikin Oscillator

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]
length1 = 2; # default = 3
length2 = 4; # default = 10
ta.chaikin_osc(data, length1, length2);
# output (array)
# [-1.667, -0.289, -0.736]

Fractals

data = [[7,6],[8,6],[9,6],[8,5],[7,4],[6,3],[7,4],[8,5]];
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]

Momentum

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

Heikin Ashi

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

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

Experimental Functions

Support Line

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

Resistance Line

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

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