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
• Williams %R
• Stochastics
• Variance
• Standard Deviation
• Correlation
• Percentage Difference
• Median
• K-means Clustering
• Normalize
• Denormalize
• Median Absolute Deviation
• Average Absolute Deviation
• Bollinger Bands
• Bollinger Bandwidth
• Keltner Channels
• Donchian Channels
• 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
• Momentum
• Heikin Ashi
• Renko

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;
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, 72.77]

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;
longlength = 5;
ta.ao(data, shortlength, longlength);
# output (array)
# [0, 0.9]

Williams %R

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

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;
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

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

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;
ta.mad(data, length);
# output (array)
# [1, 2]

Average Absolute Deviation

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

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]

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)
# [66.67, 33.36]

Aroon Down

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

Aroon Oscillator

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

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]]
# [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)
# [31.6, -31.6]

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]

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