def test_MAVP():
a = pd.Series([1, 5, 3, 4, 7, 3, 8, 1, 4, 6],
index=range(10, 20),
dtype=float)
b = pd.Series([2, 4, 2, 4, 2, 4, 2, 4, 2, 4],
index=range(20, 30),
dtype=float)
result = talib.MAVP(a, b, minperiod=2, maxperiod=4)
assert isinstance(result, pd.Series)
assert_np_arrays_equal(
result.values,
[np.nan, np.nan, np.nan, 3.25, 5.5, 4.25, 5.5, 4.75, 2.5, 4.75])
assert_np_arrays_equal(result.index, range(10, 20))
sma2 = talib.SMA(a, 2)
assert isinstance(sma2, pd.Series)
assert_np_arrays_equal(sma2.index, range(10, 20))
assert_np_arrays_equal(result.values[4::2], sma2.values[4::2])
sma4 = talib.SMA(a, 4)
assert isinstance(sma4, pd.Series)
assert_np_arrays_equal(sma4.index, range(10, 20))
assert_np_arrays_equal(result.values[3::2], sma4.values[3::2])
result = talib.MAVP(a, b, minperiod=2, maxperiod=3)
assert isinstance(result, pd.Series)
assert_np_arrays_equal(result.values, [
np.nan, np.nan, 4, 4, 5.5, 4.666666666666667, 5.5, 4, 2.5,
3.6666666666666665
])
assert_np_arrays_equal(result.index, range(10, 20))
sma3 = talib.SMA(a, 3)
assert isinstance(sma3, pd.Series)
assert_np_arrays_equal(sma3.index, range(10, 20))
assert_np_arrays_equal(result.values[2::2], sma2.values[2::2])
assert_np_arrays_equal(result.values[3::2], sma3.values[3::2])
def MAVP(Close,
periods,
minperiod=2,
maxperiod=30,
matype=0): # periods should be array
return Close.apply(
lambda col: ta.MAVP(col, periods, minperiod, maxperiod, matype),
axis=0)
def overlap_process(event):
print(event.widget.get())
overlap = event.widget.get()
upperband, middleband, lowerband = ta.BBANDS(close,
timeperiod=5,
nbdevup=2,
nbdevdn=2,
matype=0)
fig, axes = plt.subplots(2, 1, sharex=True)
ax1, ax2 = axes[0], axes[1]
axes[0].plot(close, 'rd-', markersize=3)
axes[0].plot(upperband, 'y-')
axes[0].plot(middleband, 'b-')
axes[0].plot(lowerband, 'y-')
axes[0].set_title(overlap, fontproperties="SimHei")
if overlap == '布林线':
pass
elif overlap == '双指数移动平均线':
real = ta.DEMA(close, timeperiod=30)
axes[1].plot(real, 'r-')
elif overlap == '指数移动平均线 ':
real = ta.EMA(close, timeperiod=30)
axes[1].plot(real, 'r-')
elif overlap == '希尔伯特变换——瞬时趋势线':
real = ta.HT_TRENDLINE(close)
axes[1].plot(real, 'r-')
elif overlap == '考夫曼自适应移动平均线':
real = ta.KAMA(close, timeperiod=30)
axes[1].plot(real, 'r-')
elif overlap == '移动平均线':
real = ta.MA(close, timeperiod=30, matype=0)
axes[1].plot(real, 'r-')
elif overlap == 'MESA自适应移动平均':
mama, fama = ta.MAMA(close, fastlimit=0, slowlimit=0)
axes[1].plot(mama, 'r-')
axes[1].plot(fama, 'g-')
elif overlap == '变周期移动平均线':
real = ta.MAVP(close, periods, minperiod=2, maxperiod=30, matype=0)
axes[1].plot(real, 'r-')
elif overlap == '简单移动平均线':
real = ta.SMA(close, timeperiod=30)
axes[1].plot(real, 'r-')
elif overlap == '三指数移动平均线(T3)':
real = ta.T3(close, timeperiod=5, vfactor=0)
axes[1].plot(real, 'r-')
elif overlap == '三指数移动平均线':
real = ta.TEMA(close, timeperiod=30)
axes[1].plot(real, 'r-')
elif overlap == '三角形加权法 ':
real = ta.TRIMA(close, timeperiod=30)
axes[1].plot(real, 'r-')
elif overlap == '加权移动平均数':
real = ta.WMA(close, timeperiod=30)
axes[1].plot(real, 'r-')
plt.show()
def MAVP(close, periods, minperiod=2, maxperiod=30, matype=0):
''' Moving average with variable period
分组: Overlap Studies 重叠研究
简介:
分析和应用:
real = MAVP(close, periods, minperiod=2, maxperiod=30, matype=0)
'''
return talib.MAVP(close, periods, minperiod, maxperiod, matype)
def mavp(close, graph=False, **kwargs):
'''
MAVP - Moving average with variable period
'''
result = talib.MAVP(close, **kwargs)
df = pd.concat([pd.DataFrame(close), pd.DataFrame(result)], axis=1)
df.columns = ['close', 'mavp']
if graph:
title = 'MAVP - Moving average with variable period'
style = ['r-'] + ['--'] * (len(df.columns) - 1)
fname = '08_mavp.png'
make_graph(title, df, style=style, fname=fname)
return df
def test_MAVP():
a = pl.Series([1, 5, 3, 4, 7, 3, 8, 1, 4, 6], dtype=pl.Float64)
b = pl.Series([2, 4, 2, 4, 2, 4, 2, 4, 2, 4], dtype=pl.Float64)
result = talib.MAVP(a, b, minperiod=2, maxperiod=4)
assert isinstance(result, pl.Series)
assert_np_arrays_equal(
result.to_numpy(),
[np.nan, np.nan, np.nan, 3.25, 5.5, 4.25, 5.5, 4.75, 2.5, 4.75])
sma2 = talib.SMA(a, 2)
assert isinstance(sma2, pl.Series)
assert_np_arrays_equal(result.to_numpy()[4::2], sma2.to_numpy()[4::2])
sma4 = talib.SMA(a, 4)
assert isinstance(sma4, pl.Series)
assert_np_arrays_equal(result.to_numpy()[3::2], sma4.to_numpy()[3::2])
result = talib.MAVP(a, b, minperiod=2, maxperiod=3)
assert isinstance(result, pl.Series)
assert_np_arrays_equal(result.to_numpy(), [
np.nan, np.nan, 4, 4, 5.5, 4.666666666666667, 5.5, 4, 2.5,
3.6666666666666665
])
sma3 = talib.SMA(a, 3)
assert isinstance(sma3, pl.Series)
assert_np_arrays_equal(result.to_numpy()[2::2], sma2.to_numpy()[2::2])
assert_np_arrays_equal(result.to_numpy()[3::2], sma3.to_numpy()[3::2])
def overlap(self): upper, middle, lower = talib.BBANDS(self.close,timeperiod=5,nbdevup=2,nbdevdn=2,matype=0) EMA = talib.EMA(self.close,self.period) HT_trendline = talib.HT_TRENDLINE(self.close) KAMA = talib.KAMA(self.close,self.period) MA = talib.MA(self.close,self.period,matype=0) mama, fama = talib.MAMA(self.close,fastlimit = 0.5,slowlimit = 0.05) mavp = talib.MAVP(self.close, minperiod = 5,maxperiod = 30,matype=0) midpoint = talib.MIDPOINT(self.close,self.period) midprice = talib.MIDPRICE(self.high,self.low,self.period) sar = talib.SAR(self.high,self.low,acceleration = 0, maximum = 0) sarext = talib.SAREXT(self.high,self.low,startvalue=0,offsetonreverse=0,accelerationinitlong=0, accelerationlong=0, accelerationmaxlong=0, accelerationinitshort=0, accelerationshort=0, accelerationmaxshort=0) sma = talib.SMA(self.close,self.period) t3 = talib.T3(self.close, self.period, vfactor = 0) tema = talib.TEMA(self.close,self.period) trima = talib.TRIMA(self.close,period) wma = talib.WMA(self.close, self.period)
def mavp(
client,
symbol,
timeframe="6m",
col="close",
periods=None,
minperiod=2,
maxperiod=30,
matype=0,
):
"""This will return a dataframe of moving average with variable period
for the given symbol across the given timeframe
Args:
client (pyEX.Client); Client
symbol (string); Ticker
timeframe (string); timeframe to use, for pyEX.chart
col (string); column to use to calculate
periods (int); periods
minperiod (int); minperiod
maxperiod (int); maxperiod
matype (int); matype
Returns:
DataFrame: result
"""
df = client.chartDF(symbol, timeframe)
if periods is None:
periods = [30]
periods = tolist(periods)
df = client.chartDF(symbol, timeframe)
build = {col: df[col].values}
for per in periods:
build["mavp-{}".format(per)] = t.MAVP(
df[col].values.astype(float),
per,
minperiod=minperiod,
maxperiod=maxperiod,
matype=matype,
)
return pd.DataFrame(build)
def add_MAVP(
self,
periods,
minperiod=2,
maxperiod=30,
matype=0,
type="line",
color="secondary",
**kwargs
):
"""Moving Average with Variable Period.
Parameters
----------
periods : Series or array
Moving Average period over timeframe to analyze, as a 1-dimensional
shape of same length as chart.
"""
if not self.has_close:
raise Exception()
utils.kwargs_check(kwargs, VALID_TA_KWARGS)
if "kind" in kwargs:
type = kwargs["kind"]
if isinstance(periods, pd.Series):
periods = periods.values
elif isinstance(periods, np.ndarray):
pass
else:
raise TypeError(
"Invalid periods {0}. " "It should be Series or array.".format(periods)
)
name = "MAVP({},{})".format(str(minperiod), str(maxperiod))
self.pri[name] = dict(type=type, color=color)
self.ind[name] = talib.MAVP(
self.df[self.cl].values, periods, minperiod, maxperiod, matype
)
def create_tas(bars,
verbose=False,
ohlcv_cols=['Adj_High', 'Adj_Low', 'Adj_Open', 'Adj_Close', 'Adj_Volume'],
return_df=False,
cl=True,
tp=True):
"""
This is basically set up for daily stock data. Other time frames would need adapting probably.
:param bars: resampled pandas dataframe with open, high, low, close, volume, and typical_price columns
:param verbose: boolean, if true, prints more debug
:param ohlcv_cols: list of strings; the column names for high, low, open, close, and volume
:param cl: use the close price to make TAs
:param tp: calcuclate typical price and use it for TAs
:returns: pandas dataframe with TA signals calculated (modifies dataframe in place)
"""
h, l, o, c, v = ohlcv_cols
if 'typical_price' not in bars.columns and tp:
bars['typical_price'] = bars[[h, l, c]].mean(axis=1)
# bollinger bands
# strange bug, if values are small, need to multiply to larger value for some reason
mult = 1
last_close = bars.iloc[0][c]
lc_m = last_close * mult
while lc_m < 1:
mult *= 10
lc_m = last_close * mult
if verbose:
print('using multiplier of', mult)
if tp:
mult_tp = bars['typical_price'].values * mult
mult_close = bars[c].values * mult
mult_open = bars[o].values * mult
mult_high = bars[h].values * mult
mult_low = bars[l].values * mult
# for IB data, the volume is integer, but needs to be float for talib
volume = bars[v].astype('float').values
# ADR - average daily range
# http://forextraininggroup.com/using-adr-average-daily-range-find-short-term-trading-opportunities/
# TODO
### overlap studies
# bollinger bands -- should probably put these into another indicator
if cl:
upper_cl, middle_cl, lower_cl = talib.BBANDS(mult_close,
timeperiod=10,
nbdevup=2,
nbdevdn=2)
bars['bband_u_cl'] = upper_cl / mult
bars['bband_m_cl'] = middle_cl / mult
bars['bband_l_cl'] = lower_cl / mult
bars['bband_u_cl_diff'] = bars['bband_u_cl'] - bars[c]
bars['bband_m_cl_diff'] = bars['bband_m_cl'] - bars[c]
bars['bband_l_cl_diff'] = bars['bband_l_cl'] - bars[c]
bars['bband_u_cl_diff_hi'] = bars['bband_u_cl'] - bars[h]
bars['bband_l_cl_diff_lo'] = bars['bband_l_cl'] - bars[l]
# bars['bband_u_cl'].fillna(method='bfill', inplace=True)
# bars['bband_m_cl'].fillna(method='bfill', inplace=True)
# bars['bband_l_cl'].fillna(method='bfill', inplace=True)
if tp:
upper_tp, middle_tp, lower_tp = talib.BBANDS(mult_tp,
timeperiod=10,
nbdevup=2,
nbdevdn=2)
bars['bband_u_tp'] = upper_tp / mult
bars['bband_m_tp'] = middle_tp / mult
bars['bband_l_tp'] = lower_tp / mult
bars['bband_u_tp_diff'] = bars['bband_u_tp'] - bars['typical_price']
bars['bband_m_tp_diff'] = bars['bband_m_tp'] - bars['typical_price']
bars['bband_l_tp_diff'] = bars['bband_l_tp'] - bars['typical_price']
bars['bband_u_tp_diff_hi'] = bars['bband_u_tp'] - bars[h]
bars['bband_l_tp_diff_lo'] = bars['bband_l_tp'] - bars[l]
# think this is already taken care of at the end...check
# bars['bband_u_tp'].fillna(method='bfill', inplace=True)
# bars['bband_m_tp'].fillna(method='bfill', inplace=True)
# bars['bband_l_tp'].fillna(method='bfill', inplace=True)
# Double Exponential Moving Average
if cl:
bars['dema_cl'] = talib.DEMA(mult_close, timeperiod=30) / mult
bars['dema_cl_diff'] = bars['dema_cl'] - bars[c]
if tp:
bars['dema_tp'] = talib.DEMA(mult_tp, timeperiod=30) / mult
bars['dema_tp_diff'] = bars['dema_tp'] - bars['typical_price']
# exponential moving Average
if cl:
bars['ema_cl'] = talib.EMA(mult_close, timeperiod=30) / mult
bars['ema_cl_diff'] = bars['ema_cl'] - bars[c]
if tp:
bars['ema_tp'] = talib.EMA(mult_tp, timeperiod=30) / mult
bars['ema_tp_diff'] = bars['ema_tp'] - bars['typical_price']
# Hilbert Transform - Instantaneous Trendline - like a mva but a bit different, should probably take slope or
# use in another indicator
if cl:
bars['ht_tl_cl'] = talib.HT_TRENDLINE(mult_close) / mult
bars['ht_tl_cl_diff'] = bars['ht_tl_cl'] - bars[c]
if tp:
bars['ht_tl_tp'] = talib.HT_TRENDLINE(mult_tp) / mult
bars['ht_tl_tp_diff'] = bars['ht_tl_tp'] - bars['typical_price']
# KAMA - Kaufman's Adaptative Moving Average -- need to take slope or something
if cl:
bars['kama_cl'] = talib.KAMA(mult_close, timeperiod=30) / mult
bars['kama_cl_diff'] = bars['kama_cl'] - bars[c]
if tp:
bars['kama_tp'] = talib.KAMA(mult_tp, timeperiod=30) / mult
bars['kama_tp_diff'] = bars['kama_tp'] - bars['typical_price']
# MESA Adaptive Moving Average -- getting TA_BAD_PARAM error
# mama_cl, fama_cl = talib.MAMA(mult_close, fastlimit=100, slowlimit=100) / mult
# mama_tp, fama_tp = talib.MAMA(mult_tp, fastlimit=100, slowlimit=100) / mult
# mama_cl_osc = (mama_cl - fama_cl) / mama_cl
# mama_tp_osc = (mama_tp - fama_tp) / mama_tp
# bars['mama_cl'] = mama_cl
# bars['mama_tp'] = mama_tp
# bars['fama_cl'] = fama_cl
# bars['fama_tp'] = fama_tp
# bars['mama_cl_osc'] = mama_cl_osc
# bars['mama_tp_osc'] = mama_tp_osc
# Moving average with variable period
if cl:
bars['mavp_cl'] = talib.MAVP(mult_close, np.arange(mult_close.shape[0]).astype(np.float64), minperiod=2, maxperiod=30, matype=0) / mult
bars['mavp_cl_diff'] = bars['mavp_cl'] - bars[c]
if tp:
bars['mavp_tp'] = talib.MAVP(mult_tp, np.arange(mult_tp.shape[0]).astype(np.float64), minperiod=2, maxperiod=30, matype=0) / mult
bars['mavp_tp_diff'] = bars['mavp_tp'] - bars['typical_price']
# midpoint over period
if cl:
bars['midp_cl'] = talib.MIDPOINT(mult_close, timeperiod=14) / mult
bars['midp_cl_diff'] = bars['midp_cl'] - bars[c]
if tp:
bars['midp_tp'] = talib.MIDPOINT(mult_tp, timeperiod=14) / mult
bars['midp_tp_diff'] = bars['midp_tp'] - bars['typical_price']
# midpoint price over period
bars['midpr'] = talib.MIDPRICE(mult_high, mult_low, timeperiod=14) / mult
if cl:
bars['midpr_diff_cl'] = bars['midpr'] - bars[c]
if tp:
bars['midpr_diff_tp'] = bars['midpr'] - bars['typical_price']
# parabolic sar
bars['sar'] = talib.SAR(mult_high, mult_low, acceleration=0.02, maximum=0.2) / mult
if cl:
bars['sar_diff_cl'] = bars['sar'] - bars[c]
if tp:
bars['sar_diff_tp'] = bars['sar'] - bars['typical_price']
# need to make an oscillator for this
# simple moving average
# 10, 20, 30, 40 day
if cl:
bars['sma_10_cl'] = talib.SMA(mult_close, timeperiod=10) / mult
bars['sma_20_cl'] = talib.SMA(mult_close, timeperiod=20) / mult
bars['sma_30_cl'] = talib.SMA(mult_close, timeperiod=30) / mult
bars['sma_40_cl'] = talib.SMA(mult_close, timeperiod=40) / mult
if tp:
bars['sma_10_tp'] = talib.SMA(mult_tp, timeperiod=10) / mult
bars['sma_20_tp'] = talib.SMA(mult_tp, timeperiod=20) / mult
bars['sma_30_tp'] = talib.SMA(mult_tp, timeperiod=30) / mult
bars['sma_40_tp'] = talib.SMA(mult_tp, timeperiod=40) / mult
# triple exponential moving average
if cl:
bars['tema_cl'] = talib.TEMA(mult_close, timeperiod=30) / mult
bars['tema_cl_diff'] = bars['tema_cl'] - bars[c]
if tp:
bars['tema_tp'] = talib.TEMA(mult_tp, timeperiod=30) / mult
bars['tema_tp_diff'] = bars['tema_tp'] - bars['typical_price']
# triangular ma
if cl:
bars['trima_cl'] = talib.TRIMA(mult_close, timeperiod=30) / mult
bars['trima_cl_diff'] = bars['trima_cl'] - bars[c]
if tp:
bars['trima_tp'] = talib.TRIMA(mult_tp, timeperiod=30) / mult
bars['trima_tp_diff'] = bars['trima_tp'] - bars['typical_price']
# weighted moving average
if cl:
bars['wma_cl'] = talib.WMA(mult_close, timeperiod=30) / mult
bars['wma_cl_diff'] = bars['wma_cl'] - bars[c]
if tp:
bars['wma_tp'] = talib.WMA(mult_tp, timeperiod=30) / mult
bars['wma_tp_diff'] = bars['wma_tp'] - bars['typical_price']
#### momentum indicators -- for now left out some of those with unstable periods (maybe update and included them, not sure)
# Average Directional Movement Index - 0 to 100 I think
bars['adx_14'] = talib.ADX(mult_high, mult_low, mult_close, timeperiod=14)
bars['adx_5'] = talib.ADX(mult_high, mult_low, mult_close, timeperiod=5)
# Average Directional Movement Index Rating
bars['adxr'] = talib.ADXR(mult_high, mult_low, mult_close, timeperiod=14)
# Absolute Price Oscillator
# values around -100 to +100
if cl:
bars['apo_cl'] = talib.APO(mult_close, fastperiod=12, slowperiod=26, matype=0)
if tp:
bars['apo_tp'] = talib.APO(mult_tp, fastperiod=12, slowperiod=26, matype=0)
# Aroon and Aroon Oscillator 0-100, so don't need to renormalize
arup, ardn = talib.AROON(mult_high, mult_low, timeperiod=14)
bars['arup'] = arup
bars['ardn'] = ardn
# linearly related to aroon, just aroon up - aroon down
bars['aroonosc'] = talib.AROONOSC(mult_high, mult_low, timeperiod=14)
# balance of power - ratio of values so don't need to re-normalize
bars['bop'] = talib.BOP(mult_open, mult_high, mult_low, mult_close)
# Commodity Channel Index
# around -100 to + 100
bars['cci'] = talib.CCI(mult_high, mult_low, mult_close, timeperiod=14)
# Chande Momentum Oscillator
if cl:
bars['cmo_cl'] = talib.CMO(mult_close, timeperiod=14)
if tp:
bars['cmo_tp'] = talib.CMO(mult_tp, timeperiod=14)
# dx - Directional Movement Index
bars['dx'] = talib.DX(mult_high, mult_low, mult_close, timeperiod=14)
# Moving Average Convergence/Divergence
# https://www.quantopian.com/posts/how-does-the-talib-compute-macd-why-the-value-is-different
# macd diff btw fast and slow EMA
if cl:
macd_cl, macdsignal_cl, macdhist_cl = talib.MACD(mult_close, fastperiod=12, slowperiod=26, signalperiod=9)
bars['macd_cl'] = macd_cl / mult
bars['macdsignal_cl'] = macdsignal_cl / mult
bars['macdhist_cl'] = macdhist_cl / mult
if tp:
macd_tp, macdsignal_tp, macdhist_tp = talib.MACD(mult_tp, fastperiod=12, slowperiod=26, signalperiod=9)
bars['macd_tp'] = macd_tp / mult
bars['macdsignal_tp'] = macdsignal_tp / mult
bars['macdhist_tp'] = macdhist_tp / mult
# mfi - Money Flow Index
bars['mfi'] = talib.MFI(mult_high, mult_low, mult_close, volume, timeperiod=14)
# minus di - Minus Directional Indicator
bars['mdi'] = talib.MINUS_DI(mult_high, mult_low, mult_close, timeperiod=14)
# Minus Directional Movement
bars['mdm'] = talib.MINUS_DM(mult_high, mult_low, timeperiod=14)
# note: too small of a timeperiod will result in junk data...I think. or at least very discretized
if cl:
bars['mom_cl'] = talib.MOM(mult_close, timeperiod=14) / mult
# bars['mom_cl'].fillna(method='bfill', inplace=True)
if tp:
bars['mom_tp'] = talib.MOM(mult_tp, timeperiod=14) / mult
# bars['mom_tp'].fillna(method='bfill', inplace=True)
# plus di - Plus Directional Indicator
bars['pldi'] = talib.PLUS_DI(mult_high, mult_low, mult_close, timeperiod=14)
# Plus Directional Movement
bars['pldm'] = talib.PLUS_DM(mult_high, mult_low, timeperiod=14)
# percentage price Oscillator
# matype explanation: https://www.quantopian.com/posts/moving-averages
if cl:
bars['ppo_cl'] = talib.PPO(mult_close, fastperiod=12, slowperiod=26, matype=1)
if bars['ppo_cl'].isnull().all():
bars['ppo_cl_signal'] = 0
else:
bars['ppo_cl_signal'] = talib.EMA(bars['ppo_cl'].bfill().values, timeperiod=9)
if tp:
bars['ppo_tp'] = talib.PPO(mult_tp, fastperiod=12, slowperiod=26, matype=1)
# rate of change -- really only need one
# if cl:
# bars['roc_cl'] = talib.ROC(mult_close, timeperiod=10)
#
# if tp:
# bars['roc_tp'] = talib.ROC(mult_tp, timeperiod=10)
# rocp - Rate of change Percentage: (price-prevPrice)/prevPrice
if cl:
bars['rocp_cl'] = talib.ROCP(mult_close, timeperiod=10)
if tp:
bars['rocp_tp'] = talib.ROCP(mult_tp, timeperiod=10)
# rocr - Rate of change ratio: (price/prevPrice)
# bars['rocr_cl'] = talib.ROCR(mult_close, timeperiod=10)
# bars['rocr_tp'] = talib.ROCR(mult_tp, timeperiod=10)
#
# # Rate of change ratio 100 scale: (price/prevPrice)*100
# bars['rocr_cl_100'] = talib.ROCR100(mult_close, timeperiod=10)
# bars['rocr_tp_100'] = talib.ROCR100(mult_tp, timeperiod=10)
# Relative Strength Index
if cl:
bars['rsi_cl_14'] = talib.RSI(mult_close, timeperiod=14)
bars['rsi_cl_5'] = talib.RSI(mult_close, timeperiod=5)
if tp:
bars['rsi_tp'] = talib.RSI(mult_tp, timeperiod=14)
# stochastic oscillator - % of price diffs, so no need to rescale
slowk, slowd = talib.STOCH(mult_high, mult_low, mult_close, fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0)
fastk, fastd = talib.STOCHF(mult_high, mult_low, mult_close, fastk_period=5, fastd_period=3, fastd_matype=0)
bars['slowk'] = slowk
bars['slowd'] = slowd
bars['fastk'] = fastk
bars['fastd'] = fastd
# Stochastic Relative Strength Index
if cl:
fastk_cl, fastd_cl = talib.STOCHRSI(mult_close, timeperiod=14, fastk_period=5, fastd_period=3, fastd_matype=0)
bars['strsi_cl_k'] = fastk_cl
bars['strsi_cl_d'] = fastd_cl
if tp:
fastk_tp, fastd_tp = talib.STOCHRSI(mult_tp, timeperiod=14, fastk_period=5, fastd_period=3, fastd_matype=0)
bars['strsi_tp_k'] = fastk_tp
bars['strsi_tp_d'] = fastd_tp
# trix - 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA
if cl:
if bars.shape[0] > 90:
bars['trix_cl_30'] = talib.TRIX(mult_close, timeperiod=30)
bars['trix_cl_30_signal'] = talib.EMA(bars['trix_cl_30'].bfill().values, timeperiod=20)
bars['trix_cl_14'] = talib.TRIX(mult_close, timeperiod=14)
if bars['trix_cl_14'].isnull().all():
bars['trix_cl_14_signal'] = 0
else:
bars['trix_cl_14_signal'] = talib.EMA(bars['trix_cl_14'].bfill().values, timeperiod=9)
bars['trix_cl_12'] = talib.TRIX(mult_close, timeperiod=12)
if bars['trix_cl_12'].isnull().all():
bars['trix_cl_12_signal'] = 0
else:
bars['trix_cl_12_signal'] = talib.EMA(bars['trix_cl_12'].bfill().values, timeperiod=9)
bars['trix_cl_5'] = talib.TRIX(mult_close, timeperiod=5)
if bars['trix_cl_5'].isnull().all():
bars['trix_cl_5_signal'] = 0
else:
bars['trix_cl_5_signal'] = talib.EMA(bars['trix_cl_5'].bfill().values, timeperiod=3)
if tp:
bars['trix_tp'] = talib.TRIX(mult_tp, timeperiod=30)
# ultimate Oscillator - between 0 and 100
bars['ultosc'] = talib.ULTOSC(mult_high, mult_low, mult_close, timeperiod1=7, timeperiod2=14, timeperiod3=28)
# williams % r -- 0 to 100
bars['willr'] = talib.WILLR(mult_high, mult_low, mult_close, timeperiod=14)
### volume indicators
# Chaikin A/D Line
bars['ad'] = talib.AD(mult_high, mult_low, mult_close, volume)
# Chaikin A/D Oscillator
bars['adosc'] = talib.ADOSC(mult_high, mult_low, mult_close, volume, fastperiod=3, slowperiod=10)
# on balance volume
if cl:
bars['obv_cl'] = talib.OBV(mult_close, volume)
if bars['obv_cl'].isnull().all():
bars['obv_cl_ema_14'] = 0
else:
bars['obv_cl_ema_14'] = talib.EMA(bars['obv_cl'].values, timeperiod=14)
if tp:
bars['obv_tp'] = talib.OBV(mult_tp, volume)
### volatility indicators
# average true range
# Large or increasing ranges suggest traders prepared to continue to bid up or sell down a stock through the course of the day. Decreasing range suggests waning interest.
# https://en.wikipedia.org/wiki/Average_true_range
bars['atr_65'] = talib.ATR(mult_high, mult_low, mult_close, timeperiod=65)
bars['atr_20'] = talib.ATR(mult_high, mult_low, mult_close, timeperiod=20)
bars['atr_14'] = talib.ATR(mult_high, mult_low, mult_close, timeperiod=14)
bars['atr_5'] = talib.ATR(mult_high, mult_low, mult_close, timeperiod=5)
# Normalized Average True Range
bars['natr_14'] = talib.NATR(mult_high, mult_low, mult_close, timeperiod=14)
bars['natr_5'] = talib.NATR(mult_high, mult_low, mult_close, timeperiod=5)
# true range
bars['trange'] = talib.TRANGE(mult_high, mult_low, mult_close) / mult
### Cycle indicators
# Hilbert Transform - Dominant Cycle Period
if cl:
bars['ht_dcp_cl'] = talib.HT_DCPERIOD(mult_close)
if tp:
bars['ht_dcp_tp'] = talib.HT_DCPERIOD(mult_tp)
# Hilbert Transform - Dominant Cycle Phase
if cl:
bars['ht_dcph_cl'] = talib.HT_DCPHASE(mult_close)
if tp:
bars['ht_dcph_tp'] = talib.HT_DCPHASE(mult_tp)
# Hilbert Transform - Phasor Components
if cl:
inphase_cl, quadrature_cl = talib.HT_PHASOR(mult_close)
bars['ht_ph_cl'] = inphase_cl
bars['ht_q_cl'] = quadrature_cl
if tp:
inphase_tp, quadrature_tp = talib.HT_PHASOR(mult_tp)
bars['ht_ph_tp'] = inphase_tp
bars['ht_q_tp'] = quadrature_tp
# Hilbert Transform - SineWave
if cl:
sine_cl, leadsine_cl = talib.HT_SINE(mult_close)
bars['ht_s_cl'] = sine_cl
bars['ht_ls_cl'] = leadsine_cl
if tp:
sine_tp, leadsine_tp = talib.HT_SINE(mult_tp)
bars['ht_s_tp'] = sine_tp
bars['ht_ls_tp'] = leadsine_tp
# Hilbert Transform - Trend vs Cycle Mode
if cl:
bars['ht_tr_cl'] = talib.HT_TRENDMODE(mult_close)
if tp:
bars['ht_tr_tp'] = talib.HT_TRENDMODE(mult_tp)
bars.fillna(method='bfill', inplace=True)
if return_df:
return bars
def add_ta_features(df, ta_settings):
"""Add technial analysis features from typical financial dataset that
typically include columns such as "open", "high", "low", "price" and
"volume".
http://mrjbq7.github.io/ta-lib/
Args:
df(pandas.DataFrame): original DataFrame.
ta_settings(dict): configuration.
Returns:
pandas.DataFrame: DataFrame with new features included.
"""
open = df['open']
high = df['high']
low = df['low']
close = df['price']
volume = df['volume']
if ta_settings['overlap']:
df['ta_overlap_bbands_upper'], df['ta_overlap_bbands_middle'], df[
'ta_overlap_bbands_lower'] = ta.BBANDS(close,
timeperiod=5,
nbdevup=2,
nbdevdn=2,
matype=0)
df['ta_overlap_dema'] = ta.DEMA(
close, timeperiod=15) # NOTE: Changed to avoid a lot of Nan values
df['ta_overlap_ema'] = ta.EMA(close, timeperiod=30)
df['ta_overlap_kama'] = ta.KAMA(close, timeperiod=30)
df['ta_overlap_ma'] = ta.MA(close, timeperiod=30, matype=0)
df['ta_overlap_mama_mama'], df['ta_overlap_mama_fama'] = ta.MAMA(close)
period = np.random.randint(10, 20, size=len(close)).astype(float)
df['ta_overlap_mavp'] = ta.MAVP(close,
period,
minperiod=2,
maxperiod=30,
matype=0)
df['ta_overlap_midpoint'] = ta.MIDPOINT(close, timeperiod=14)
df['ta_overlap_midprice'] = ta.MIDPRICE(high, low, timeperiod=14)
df['ta_overlap_sar'] = ta.SAR(high, low, acceleration=0, maximum=0)
df['ta_overlap_sarext'] = ta.SAREXT(high,
low,
startvalue=0,
offsetonreverse=0,
accelerationinitlong=0,
accelerationlong=0,
accelerationmaxlong=0,
accelerationinitshort=0,
accelerationshort=0,
accelerationmaxshort=0)
df['ta_overlap_sma'] = ta.SMA(close, timeperiod=30)
df['ta_overlap_t3'] = ta.T3(close, timeperiod=5, vfactor=0)
df['ta_overlap_tema'] = ta.TEMA(
close, timeperiod=12) # NOTE: Changed to avoid a lot of Nan values
df['ta_overlap_trima'] = ta.TRIMA(close, timeperiod=30)
df['ta_overlap_wma'] = ta.WMA(close, timeperiod=30)
# NOTE: Commented to avoid a lot of Nan values
# df['ta_overlap_ht_trendline'] = ta.HT_TRENDLINE(close)
if ta_settings['momentum']:
df['ta_momentum_adx'] = ta.ADX(high, low, close, timeperiod=14)
df['ta_momentum_adxr'] = ta.ADXR(high, low, close, timeperiod=14)
df['ta_momentum_apo'] = ta.APO(close,
fastperiod=12,
slowperiod=26,
matype=0)
df['ta_momentum_aroondown'], df['ta_momentum_aroonup'] = ta.AROON(
high, low, timeperiod=14)
df['ta_momentum_aroonosc'] = ta.AROONOSC(high, low, timeperiod=14)
df['ta_momentum_bop'] = ta.BOP(open, high, low, close)
df['ta_momentum_cci'] = ta.CCI(high, low, close, timeperiod=14)
df['ta_momentum_cmo'] = ta.CMO(close, timeperiod=14)
df['ta_momentum_dx'] = ta.DX(high, low, close, timeperiod=14)
df['ta_momentum_macd_macd'], df['ta_momentum_macd_signal'], df[
'ta_momentum_macd_hist'] = ta.MACD(close,
fastperiod=12,
slowperiod=26,
signalperiod=9)
df['ta_momentum_macdext_macd'], df['ta_momentum_macdext_signal'], df[
'ta_momentum_macdext_hist'] = ta.MACDEXT(close,
fastperiod=12,
fastmatype=0,
slowperiod=26,
slowmatype=0,
signalperiod=9,
signalmatype=0)
df['ta_momentum_macdfix_macd'], df['ta_momentum_macdfix_signal'], df[
'ta_momentum_macdfix_hist'] = ta.MACDFIX(close, signalperiod=9)
df['ta_momentum_mfi'] = ta.MFI(high, low, close, volume, timeperiod=14)
df['ta_momentum_minus_di'] = ta.MINUS_DI(high,
low,
close,
timeperiod=14)
df['ta_momentum_minus_dm'] = ta.MINUS_DM(high, low, timeperiod=14)
df['ta_momentum_mom'] = ta.MOM(close, timeperiod=10)
df['ta_momentum_plus_di'] = ta.PLUS_DI(high, low, close, timeperiod=14)
df['ta_momentum_plus_dm'] = ta.PLUS_DM(high, low, timeperiod=14)
df['ta_momentum_ppo'] = ta.PPO(close,
fastperiod=12,
slowperiod=26,
matype=0)
df['ta_momentum_roc'] = ta.ROC(close, timeperiod=10)
df['ta_momentum_rocp'] = ta.ROCP(close, timeperiod=10)
df['ta_momentum_rocr'] = ta.ROCR(close, timeperiod=10)
df['ta_momentum_rocr100'] = ta.ROCR100(close, timeperiod=10)
df['ta_momentum_rsi'] = ta.RSI(close, timeperiod=14)
df['ta_momentum_slowk'], df['ta_momentum_slowd'] = ta.STOCH(
high,
low,
close,
fastk_period=5,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
df['ta_momentum_fastk'], df['ta_momentum_fastd'] = ta.STOCHF(
high, low, close, fastk_period=5, fastd_period=3, fastd_matype=0)
df['ta_momentum_fastk'], df['ta_momentum_fastd'] = ta.STOCHRSI(
close,
timeperiod=14,
fastk_period=5,
fastd_period=3,
fastd_matype=0)
df['ta_momentum_trix'] = ta.TRIX(
close, timeperiod=12) # NOTE: Changed to avoid a lot of Nan values
df['ta_momentum_ultosc'] = ta.ULTOSC(high,
low,
close,
timeperiod1=7,
timeperiod2=14,
timeperiod3=28)
df['ta_momentum_willr'] = ta.WILLR(high, low, close, timeperiod=14)
if ta_settings['volume']:
df['ta_volume_ad'] = ta.AD(high, low, close, volume)
df['ta_volume_adosc'] = ta.ADOSC(high,
low,
close,
volume,
fastperiod=3,
slowperiod=10)
df['ta_volume_obv'] = ta.OBV(close, volume)
if ta_settings['volatility']:
df['ta_volatility_atr'] = ta.ATR(high, low, close, timeperiod=14)
df['ta_volatility_natr'] = ta.NATR(high, low, close, timeperiod=14)
df['ta_volatility_trange'] = ta.TRANGE(high, low, close)
if ta_settings['price']:
df['ta_price_avgprice'] = ta.AVGPRICE(open, high, low, close)
df['ta_price_medprice'] = ta.MEDPRICE(high, low)
df['ta_price_typprice'] = ta.TYPPRICE(high, low, close)
df['ta_price_wclprice'] = ta.WCLPRICE(high, low, close)
if ta_settings['cycle']:
df['ta_cycle_ht_dcperiod'] = ta.HT_DCPERIOD(close)
df['ta_cycle_ht_phasor_inphase'], df[
'ta_cycle_ht_phasor_quadrature'] = ta.HT_PHASOR(close)
df['ta_cycle_ht_trendmode'] = ta.HT_TRENDMODE(close)
# NOTE: Commented to avoid a lot of Nan values
# df['ta_cycle_ht_dcphase'] = ta.HT_DCPHASE(close)
# df['ta_cycle_ht_sine_sine'], df['ta_cycle_ht_sine_leadsine'] = ta.HT_SINE(close)
if ta_settings['pattern']:
df['ta_pattern_cdl2crows'] = ta.CDL2CROWS(open, high, low, close)
df['ta_pattern_cdl3blackrows'] = ta.CDL3BLACKCROWS(
open, high, low, close)
df['ta_pattern_cdl3inside'] = ta.CDL3INSIDE(open, high, low, close)
df['ta_pattern_cdl3linestrike'] = ta.CDL3LINESTRIKE(
open, high, low, close)
df['ta_pattern_cdl3outside'] = ta.CDL3OUTSIDE(open, high, low, close)
df['ta_pattern_cdl3starsinsouth'] = ta.CDL3STARSINSOUTH(
open, high, low, close)
df['ta_pattern_cdl3whitesoldiers'] = ta.CDL3WHITESOLDIERS(
open, high, low, close)
df['ta_pattern_cdlabandonedbaby'] = ta.CDLABANDONEDBABY(open,
high,
low,
close,
penetration=0)
df['ta_pattern_cdladvanceblock'] = ta.CDLADVANCEBLOCK(
open, high, low, close)
df['ta_pattern_cdlbelthold'] = ta.CDLBELTHOLD(open, high, low, close)
df['ta_pattern_cdlbreakaway'] = ta.CDLBREAKAWAY(open, high, low, close)
df['ta_pattern_cdlclosingmarubozu'] = ta.CDLCLOSINGMARUBOZU(
open, high, low, close)
df['ta_pattern_cdlconcealbabyswall'] = ta.CDLCONCEALBABYSWALL(
open, high, low, close)
df['ta_pattern_cdlcounterattack'] = ta.CDLCOUNTERATTACK(
open, high, low, close)
df['ta_pattern_cdldarkcloudcover'] = ta.CDLDARKCLOUDCOVER(
open, high, low, close, penetration=0)
df['ta_pattern_cdldoji'] = ta.CDLDOJI(open, high, low, close)
df['ta_pattern_cdldojistar'] = ta.CDLDOJISTAR(open, high, low, close)
df['ta_pattern_cdldragonflydoji'] = ta.CDLDRAGONFLYDOJI(
open, high, low, close)
df['ta_pattern_cdlengulfing'] = ta.CDLENGULFING(open, high, low, close)
df['ta_pattern_cdleveningdojistar'] = ta.CDLEVENINGDOJISTAR(
open, high, low, close, penetration=0)
df['ta_pattern_cdleveningstar'] = ta.CDLEVENINGSTAR(open,
high,
low,
close,
penetration=0)
df['ta_pattern_cdlgapsidesidewhite'] = ta.CDLGAPSIDESIDEWHITE(
open, high, low, close)
df['ta_pattern_cdlgravestonedoji'] = ta.CDLGRAVESTONEDOJI(
open, high, low, close)
df['ta_pattern_cdlhammer'] = ta.CDLHAMMER(open, high, low, close)
df['ta_pattern_cdlhangingman'] = ta.CDLHANGINGMAN(
open, high, low, close)
df['ta_pattern_cdlharami'] = ta.CDLHARAMI(open, high, low, close)
df['ta_pattern_cdlharamicross'] = ta.CDLHARAMICROSS(
open, high, low, close)
df['ta_pattern_cdlhighwave'] = ta.CDLHIGHWAVE(open, high, low, close)
df['ta_pattern_cdlhikkake'] = ta.CDLHIKKAKE(open, high, low, close)
df['ta_pattern_cdlhikkakemod'] = ta.CDLHIKKAKEMOD(
open, high, low, close)
df['ta_pattern_cdlhomingpigeon'] = ta.CDLHOMINGPIGEON(
open, high, low, close)
df['ta_pattern_cdlidentical3crows'] = ta.CDLIDENTICAL3CROWS(
open, high, low, close)
df['ta_pattern_cdlinneck'] = ta.CDLINNECK(open, high, low, close)
df['ta_pattern_cdlinvertedhammer'] = ta.CDLINVERTEDHAMMER(
open, high, low, close)
df['ta_pattern_cdlkicking'] = ta.CDLKICKING(open, high, low, close)
df['ta_pattern_cdlkickingbylength'] = ta.CDLKICKINGBYLENGTH(
open, high, low, close)
df['ta_pattern_cdlladderbottom'] = ta.CDLLADDERBOTTOM(
open, high, low, close)
df['ta_pattern_cdllongleggeddoji'] = ta.CDLLONGLEGGEDDOJI(
open, high, low, close)
df['ta_pattern_cdllongline'] = ta.CDLLONGLINE(open, high, low, close)
df['ta_pattern_cdlmarubozu'] = ta.CDLMARUBOZU(open, high, low, close)
df['ta_pattern_cdlmatchinglow'] = ta.CDLMATCHINGLOW(
open, high, low, close)
df['ta_pattern_cdlmathold'] = ta.CDLMATHOLD(open,
high,
low,
close,
penetration=0)
df['ta_pattern_cdlmorningdojistar'] = ta.CDLMORNINGDOJISTAR(
open, high, low, close, penetration=0)
df['ta_pattern_cdlmorningstar'] = ta.CDLMORNINGSTAR(open,
high,
low,
close,
penetration=0)
df['ta_pattern_cdllonneck'] = ta.CDLONNECK(open, high, low, close)
df['ta_pattern_cdlpiercing'] = ta.CDLPIERCING(open, high, low, close)
df['ta_pattern_cdlrickshawman'] = ta.CDLRICKSHAWMAN(
open, high, low, close)
df['ta_pattern_cdlrisefall3methods'] = ta.CDLRISEFALL3METHODS(
open, high, low, close)
df['ta_pattern_cdlseparatinglines'] = ta.CDLSEPARATINGLINES(
open, high, low, close)
df['ta_pattern_cdlshootingstar'] = ta.CDLSHOOTINGSTAR(
open, high, low, close)
df['ta_pattern_cdlshortline'] = ta.CDLSHORTLINE(open, high, low, close)
df['ta_pattern_cdlspinningtop'] = ta.CDLSPINNINGTOP(
open, high, low, close)
df['ta_pattern_cdlstalledpattern'] = ta.CDLSTALLEDPATTERN(
open, high, low, close)
df['ta_pattern_cdlsticksandwich'] = ta.CDLSTICKSANDWICH(
open, high, low, close)
df['ta_pattern_cdltakuri'] = ta.CDLTAKURI(open, high, low, close)
df['ta_pattern_cdltasukigap'] = ta.CDLTASUKIGAP(open, high, low, close)
df['ta_pattern_cdlthrusting'] = ta.CDLTHRUSTING(open, high, low, close)
df['ta_pattern_cdltristar'] = ta.CDLTRISTAR(open, high, low, close)
df['ta_pattern_cdlunique3river'] = ta.CDLUNIQUE3RIVER(
open, high, low, close)
df['ta_pattern_cdlupsidegap2crows'] = ta.CDLUPSIDEGAP2CROWS(
open, high, low, close)
df['ta_pattern_cdlxsidegap3methods'] = ta.CDLXSIDEGAP3METHODS(
open, high, low, close)
if ta_settings['statistic']:
df['ta_statistic_beta'] = ta.BETA(high, low, timeperiod=5)
df['ta_statistic_correl'] = ta.CORREL(high, low, timeperiod=30)
df['ta_statistic_linearreg'] = ta.LINEARREG(close, timeperiod=14)
df['ta_statistic_linearreg_angle'] = ta.LINEARREG_ANGLE(close,
timeperiod=14)
df['ta_statistic_linearreg_intercept'] = ta.LINEARREG_INTERCEPT(
close, timeperiod=14)
df['ta_statistic_linearreg_slope'] = ta.LINEARREG_SLOPE(close,
timeperiod=14)
df['ta_statistic_stddev'] = ta.STDDEV(close, timeperiod=5, nbdev=1)
df['ta_statistic_tsf'] = ta.TSF(close, timeperiod=14)
df['ta_statistic_var'] = ta.VAR(close, timeperiod=5, nbdev=1)
if ta_settings['math_transforms']:
df['ta_math_transforms_atan'] = ta.ATAN(close)
df['ta_math_transforms_ceil'] = ta.CEIL(close)
df['ta_math_transforms_cos'] = ta.COS(close)
df['ta_math_transforms_floor'] = ta.FLOOR(close)
df['ta_math_transforms_ln'] = ta.LN(close)
df['ta_math_transforms_log10'] = ta.LOG10(close)
df['ta_math_transforms_sin'] = ta.SIN(close)
df['ta_math_transforms_sqrt'] = ta.SQRT(close)
df['ta_math_transforms_tan'] = ta.TAN(close)
if ta_settings['math_operators']:
df['ta_math_operators_add'] = ta.ADD(high, low)
df['ta_math_operators_div'] = ta.DIV(high, low)
df['ta_math_operators_min'], df['ta_math_operators_max'] = ta.MINMAX(
close, timeperiod=30)
df['ta_math_operators_minidx'], df[
'ta_math_operators_maxidx'] = ta.MINMAXINDEX(close, timeperiod=30)
df['ta_math_operators_mult'] = ta.MULT(high, low)
df['ta_math_operators_sub'] = ta.SUB(high, low)
df['ta_math_operators_sum'] = ta.SUM(close, timeperiod=30)
return df
def MAVP(close, periods):
"MAVP - Moving average with variable period"
real = talib.MAVP(close, minperiod=2, maxperiod=30, matype=0)
return [real]
def MAVP(self, name, **parameters):
data = self.__data[name]
return talib.MAVP(data, **parameters)
cols = list(stock)[0:13]
#Preprocess data
stock = stock[cols].astype(str)
for i in cols:
for j in range(0, len(stock)):
stock[i][j] = stock[i][j].replace(",", "")
stock = stock.astype(float)
periods = np.double(np.array(list(range(0, len(stock['Close'])))))
HT = talib.HT_TRENDMODE(stock['Close'])
rsi = talib.RSI(stock['Close'], timeperiod=5)
wma = talib.WMA(stock['Close'], timeperiod=20)
mavp = talib.MAVP(stock['Close'], periods, minperiod=2, maxperiod=30, matype=0)
upperband, middleband, lowerband = talib.BBANDS(stock['Close'],
timeperiod=10,
nbdevup=2,
nbdevdn=2,
matype=0)
Roc = talib.ROC(stock['Close'], timeperiod=5)
Atr = talib.ATR(stock['High'], stock['Low'], stock['Close'], timeperiod=10)
div = stock.Close - wma
voldiff = stock.Volume.diff()
VolROC = (stock.Volume - stock.Volume.shift(1)) / stock.Volume
opendiff = stock.Open - stock.Open.shift(1)
X = stock.Close.values
size = int(len(X) * 0.66)
train, test = X[0:size], X
def MAVP(data, **kwargs):
_check_talib_presence()
prices = _extract_series(data)
return talib.MAVP(prices, **kwargs)
def MAVP(self, window1=2, window2=30):
real = talib.MAVP(self.close, self.periods, minperiod=window1, maxperiod=window2, matype=0)
return real
data = yf.download("AAPL", start="2020-01-02", end="2021-01-02")
data.reset_index(drop=False,inplace=True)
"""
indicators
"""
#Relative Strength Index
rsi = ta.RSI(data.Close, timeperiod=14) #skip 14 days to have real values
print("Relative Strength Index : \n")
print(rsi)
print("\n")
#Moving Average
periods = data.Date
mvag = ta.MAVP(data.Close, periods, minperiod=2, maxperiod=30, matype=0)
print("Moving Average : \n")
print(mvag)
print("\n")
#Moving Average Convergence Divergence
mvacd = ta.MACD(data.Close, 12, 26, 9)
print("Moving Average Convergence Divergence : \n")
print(mvacd)
print("\n")
#On Balance Volume
obv = ta.OBV(data.Close, data.Volume)
print("On Balance Volume : \n")
print(obv)
def MAVP_factor(self, df, periods, minperiod=30, maxperiod=30, matype=0):
return talib.MAVP(df.loc[:, self.map_dict['default']].values,
periods, minperiod,
maxperiod, matype)
def MAVP(raw_df, minperiod=2, maxperiod=30, matype=0):
# extract necessary data from raw dataframe (close)
return ta.MAVP(raw_df.Close.values, raw_df.Open.values, minperiod,
maxperiod, matype)
def mavp(real, periods, minperiod=2, maxperiod=30, matype=0):
values = ta.MAVP(real, periods, minperiod, maxperiod, matype)
return {"mavp":values}
def calculate(self, para):
self.t = self.inputdata[:, 0]
self.op = self.inputdata[:, 1]
self.high = self.inputdata[:, 2]
self.low = self.inputdata[:, 3]
self.close = self.inputdata[:, 4]
#adjusted close
self.close1 = self.inputdata[:, 5]
self.volume = self.inputdata[:, 6]
#Overlap study
#Overlap Studies
#Overlap Studies
if para is 'BBANDS': #Bollinger Bands
upperband, middleband, lowerband = ta.BBANDS(self.close,
timeperiod=self.tp,
nbdevup=2,
nbdevdn=2,
matype=0)
self.output = [upperband, middleband, lowerband]
elif para is 'DEMA': #Double Exponential Moving Average
self.output = ta.DEMA(self.close, timeperiod=self.tp)
elif para is 'EMA': #Exponential Moving Average
self.output = ta.EMA(self.close, timeperiod=self.tp)
elif para is 'HT_TRENDLINE': #Hilbert Transform - Instantaneous Trendline
self.output = ta.HT_TRENDLINE(self.close)
elif para is 'KAMA': #Kaufman Adaptive Moving Average
self.output = ta.KAMA(self.close, timeperiod=self.tp)
elif para is 'MA': #Moving average
self.output = ta.MA(self.close, timeperiod=self.tp, matype=0)
elif para is 'MAMA': #MESA Adaptive Moving Average
mama, fama = ta.MAMA(self.close, fastlimit=0, slowlimit=0)
elif para is 'MAVP': #Moving average with variable period
self.output = ta.MAVP(self.close,
periods=10,
minperiod=self.tp,
maxperiod=self.tp1,
matype=0)
elif para is 'MIDPOINT': #MidPoint over period
self.output = ta.MIDPOINT(self.close, timeperiod=self.tp)
elif para is 'MIDPRICE': #Midpoint Price over period
self.output = ta.MIDPRICE(self.high, self.low, timeperiod=self.tp)
elif para is 'SAR': #Parabolic SAR
self.output = ta.SAR(self.high,
self.low,
acceleration=0,
maximum=0)
elif para is 'SAREXT': #Parabolic SAR - Extended
self.output = ta.SAREXT(self.high,
self.low,
startvalue=0,
offsetonreverse=0,
accelerationinitlong=0,
accelerationlong=0,
accelerationmaxlong=0,
accelerationinitshort=0,
accelerationshort=0,
accelerationmaxshort=0)
elif para is 'SMA': #Simple Moving Average
self.output = ta.SMA(self.close, timeperiod=self.tp)
elif para is 'T3': #Triple Exponential Moving Average (T3)
self.output = ta.T3(self.close, timeperiod=self.tp, vfactor=0)
elif para is 'TEMA': #Triple Exponential Moving Average
self.output = ta.TEMA(self.close, timeperiod=self.tp)
elif para is 'TRIMA': #Triangular Moving Average
self.output = ta.TRIMA(self.close, timeperiod=self.tp)
elif para is 'WMA': #Weighted Moving Average
self.output = ta.WMA(self.close, timeperiod=self.tp)
#Momentum Indicators
elif para is 'ADX': #Average Directional Movement Index
self.output = ta.ADX(self.high,
self.low,
self.close,
timeperiod=self.tp)
elif para is 'ADXR': #Average Directional Movement Index Rating
self.output = ta.ADXR(self.high,
self.low,
self.close,
timeperiod=self.tp)
elif para is 'APO': #Absolute Price Oscillator
self.output = ta.APO(self.close,
fastperiod=12,
slowperiod=26,
matype=0)
elif para is 'AROON': #Aroon
aroondown, aroonup = ta.AROON(self.high,
self.low,
timeperiod=self.tp)
self.output = [aroondown, aroonup]
elif para is 'AROONOSC': #Aroon Oscillator
self.output = ta.AROONOSC(self.high, self.low, timeperiod=self.tp)
elif para is 'BOP': #Balance Of Power
self.output = ta.BOP(self.op, self.high, self.low, self.close)
elif para is 'CCI': #Commodity Channel Index
self.output = ta.CCI(self.high,
self.low,
self.close,
timeperiod=self.tp)
elif para is 'CMO': #Chande Momentum Oscillator
self.output = ta.CMO(self.close, timeperiod=self.tp)
elif para is 'DX': #Directional Movement Index
self.output = ta.DX(self.high,
self.low,
self.close,
timeperiod=self.tp)
elif para is 'MACD': #Moving Average Convergence/Divergence
macd, macdsignal, macdhist = ta.MACD(self.close,
fastperiod=12,
slowperiod=26,
signalperiod=9)
self.output = [macd, macdsignal, macdhist]
elif para is 'MACDEXT': #MACD with controllable MA type
macd, macdsignal, macdhist = ta.MACDEXT(self.close,
fastperiod=12,
fastmatype=0,
slowperiod=26,
slowmatype=0,
signalperiod=9,
signalmatype=0)
self.output = [macd, macdsignal, macdhist]
elif para is 'MACDFIX': #Moving Average Convergence/Divergence Fix 12/26
macd, macdsignal, macdhist = ta.MACDFIX(self.close, signalperiod=9)
self.output = [macd, macdsignal, macdhist]
elif para is 'MFI': #Money Flow Index
self.output = ta.MFI(self.high,
self.low,
self.close,
self.volume,
timeperiod=self.tp)
elif para is 'MINUS_DI': #Minus Directional Indicator
self.output = ta.MINUS_DI(self.high,
self.low,
self.close,
timeperiod=self.tp)
elif para is 'MINUS_DM': #Minus Directional Movement
self.output = ta.MINUS_DM(self.high, self.low, timeperiod=self.tp)
elif para is 'MOM': #Momentum
self.output = ta.MOM(self.close, timeperiod=10)
elif para is 'PLUS_DI': #Plus Directional Indicator
self.output = ta.PLUS_DI(self.high,
self.low,
self.close,
timeperiod=self.tp)
elif para is 'PLUS_DM': #Plus Directional Movement
self.output = ta.PLUS_DM(self.high, self.low, timeperiod=self.tp)
elif para is 'PPO': #Percentage Price Oscillator
self.output = ta.PPO(self.close,
fastperiod=12,
slowperiod=26,
matype=0)
elif para is 'ROC': #Rate of change : ((price/prevPrice)-1)*100
self.output = ta.ROC(self.close, timeperiod=10)
elif para is 'ROCP': #Rate of change Percentage: (price-prevPrice)/prevPrice
self.output = ta.ROCP(self.close, timeperiod=10)
elif para is 'ROCR': #Rate of change ratio: (price/prevPrice)
self.output = ta.ROCR(self.close, timeperiod=10)
elif para is 'ROCR100': #Rate of change ratio 100 scale: (price/prevPrice)*100
self.output = ta.ROCR100(self.close, timeperiod=10)
elif para is 'RSI': #Relative Strength Index
self.output = ta.RSI(self.close, timeperiod=self.tp)
elif para is 'STOCH': #Stochastic
slowk, slowd = ta.STOCH(self.high,
self.low,
self.close,
fastk_period=5,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
self.output = [slowk, slowd]
elif para is 'STOCHF': #Stochastic Fast
fastk, fastd = ta.STOCHF(self.high,
self.low,
self.close,
fastk_period=5,
fastd_period=3,
fastd_matype=0)
self.output = [fastk, fastd]
elif para is 'STOCHRSI': #Stochastic Relative Strength Index
fastk, fastd = ta.STOCHRSI(self.close,
timeperiod=self.tp,
fastk_period=5,
fastd_period=3,
fastd_matype=0)
self.output = [fastk, fastd]
elif para is 'TRIX': #1-day Rate-Of-Change (ROC) of a Triple Smooth EMA
self.output = ta.TRIX(self.close, timeperiod=self.tp)
elif para is 'ULTOSC': #Ultimate Oscillator
self.output = ta.ULTOSC(self.high,
self.low,
self.close,
timeperiod1=self.tp,
timeperiod2=self.tp1,
timeperiod3=self.tp2)
elif para is 'WILLR': #Williams' %R
self.output = ta.WILLR(self.high,
self.low,
self.close,
timeperiod=self.tp)
# Volume Indicators : #
elif para is 'AD': #Chaikin A/D Line
self.output = ta.AD(self.high, self.low, self.close, self.volume)
elif para is 'ADOSC': #Chaikin A/D Oscillator
self.output = ta.ADOSC(self.high,
self.low,
self.close,
self.volume,
fastperiod=3,
slowperiod=10)
elif para is 'OBV': #On Balance Volume
self.output = ta.OBV(self.close, self.volume)
# Volatility Indicators: #
elif para is 'ATR': #Average True Range
self.output = ta.ATR(self.high,
self.low,
self.close,
timeperiod=self.tp)
elif para is 'NATR': #Normalized Average True Range
self.output = ta.NATR(self.high,
self.low,
self.close,
timeperiod=self.tp)
elif para is 'TRANGE': #True Range
self.output = ta.TRANGE(self.high, self.low, self.close)
#Price Transform : #
elif para is 'AVGPRICE': #Average Price
self.output = ta.AVGPRICE(self.op, self.high, self.low, self.close)
elif para is 'MEDPRICE': #Median Price
self.output = ta.MEDPRICE(self.high, self.low)
elif para is 'TYPPRICE': #Typical Price
self.output = ta.TYPPRICE(self.high, self.low, self.close)
elif para is 'WCLPRICE': #Weighted Close Price
self.output = ta.WCLPRICE(self.high, self.low, self.close)
#Cycle Indicators : #
elif para is 'HT_DCPERIOD': #Hilbert Transform - Dominant Cycle Period
self.output = ta.HT_DCPERIOD(self.close)
elif para is 'HT_DCPHASE': #Hilbert Transform - Dominant Cycle Phase
self.output = ta.HT_DCPHASE(self.close)
elif para is 'HT_PHASOR': #Hilbert Transform - Phasor Components
inphase, quadrature = ta.HT_PHASOR(self.close)
self.output = [inphase, quadrature]
elif para is 'HT_SINE': #Hilbert Transform - SineWave #2
sine, leadsine = ta.HT_SINE(self.close)
self.output = [sine, leadsine]
elif para is 'HT_TRENDMODE': #Hilbert Transform - Trend vs Cycle Mode
self.integer = ta.HT_TRENDMODE(self.close)
#Pattern Recognition : #
elif para is 'CDL2CROWS': #Two Crows
self.integer = ta.CDL2CROWS(self.op, self.high, self.low,
self.close)
elif para is 'CDL3BLACKCROWS': #Three Black Crows
self.integer = ta.CDL3BLACKCROWS(self.op, self.high, self.low,
self.close)
elif para is 'CDL3INSIDE': #Three Inside Up/Down
self.integer = ta.CDL3INSIDE(self.op, self.high, self.low,
self.close)
elif para is 'CDL3LINESTRIKE': #Three-Line Strike
self.integer = ta.CDL3LINESTRIKE(self.op, self.high, self.low,
self.close)
elif para is 'CDL3OUTSIDE': #Three Outside Up/Down
self.integer = ta.CDL3OUTSIDE(self.op, self.high, self.low,
self.close)
elif para is 'CDL3STARSINSOUTH': #Three Stars In The South
self.integer = ta.CDL3STARSINSOUTH(self.op, self.high, self.low,
self.close)
elif para is 'CDL3WHITESOLDIERS': #Three Advancing White Soldiers
self.integer = ta.CDL3WHITESOLDIERS(self.op, self.high, self.low,
self.close)
elif para is 'CDLABANDONEDBABY': #Abandoned Baby
self.integer = ta.CDLABANDONEDBABY(self.op,
self.high,
self.low,
self.close,
penetration=0)
elif para is 'CDLBELTHOLD': #Belt-hold
self.integer = ta.CDLBELTHOLD(self.op, self.high, self.low,
self.close)
elif para is 'CDLBREAKAWAY': #Breakaway
self.integer = ta.CDLBREAKAWAY(self.op, self.high, self.low,
self.close)
elif para is 'CDLCLOSINGMARUBOZU': #Closing Marubozu
self.integer = ta.CDLCLOSINGMARUBOZU(self.op, self.high, self.low,
self.close)
elif para is 'CDLCONCEALBABYSWALL': #Concealing Baby Swallow
self.integer = ta.CDLCONCEALBABYSWALL(self.op, self.high, self.low,
self.close)
elif para is 'CDLCOUNTERATTACK': #Counterattack
self.integer = ta.CDLCOUNTERATTACK(self.op, self.high, self.low,
self.close)
elif para is 'CDLDARKCLOUDCOVER': #Dark Cloud Cover
self.integer = ta.CDLDARKCLOUDCOVER(self.op,
self.high,
self.low,
self.close,
penetration=0)
elif para is 'CDLDOJI': #Doji
self.integer = ta.CDLDOJI(self.op, self.high, self.low, self.close)
elif para is 'CDLDOJISTAR': #Doji Star
self.integer = ta.CDLDOJISTAR(self.op, self.high, self.low,
self.close)
elif para is 'CDLDRAGONFLYDOJI': #Dragonfly Doji
self.integer = ta.CDLDRAGONFLYDOJI(self.op, self.high, self.low,
self.close)
elif para is 'CDLENGULFING': #Engulfing Pattern
self.integer = ta.CDLENGULFING(self.op, self.high, self.low,
self.close)
elif para is 'CDLEVENINGDOJISTAR': #Evening Doji Star
self.integer = ta.CDLEVENINGDOJISTAR(self.op,
self.high,
self.low,
self.close,
penetration=0)
elif para is 'CDLEVENINGSTAR': #Evening Star
self.integer = ta.CDLEVENINGSTAR(self.op,
self.high,
self.low,
self.close,
penetration=0)
elif para is 'CDLGAPSIDESIDEWHITE': #Up/Down-gap side-by-side white lines
self.integer = ta.CDLGAPSIDESIDEWHITE(self.op, self.high, self.low,
self.close)
elif para is 'CDLGRAVESTONEDOJI': #Gravestone Doji
self.integer = ta.CDLGRAVESTONEDOJI(self.op, self.high, self.low,
self.close)
elif para is 'CDLHAMMER': #Hammer
self.integer = ta.CDLHAMMER(self.op, self.high, self.low,
self.close)
elif para is 'CDLHANGINGMAN': #Hanging Man
self.integer = ta.CDLHANGINGMAN(self.op, self.high, self.low,
self.close)
elif para is 'CDLHARAMI': #Harami Pattern
self.integer = ta.CDLHARAMI(self.op, self.high, self.low,
self.close)
elif para is 'CDLHARAMICROSS': #Harami Cross Pattern
self.integer = ta.CDLHARAMICROSS(self.op, self.high, self.low,
self.close)
elif para is 'CDLHIGHWAVE': #High-Wave Candle
self.integer = ta.CDLHIGHWAVE(self.op, self.high, self.low,
self.close)
elif para is 'CDLHIKKAKE': #Hikkake Pattern
self.integer = ta.CDLHIKKAKE(self.op, self.high, self.low,
self.close)
elif para is 'CDLHIKKAKEMOD': #Modified Hikkake Pattern
self.integer = ta.CDLHIKKAKEMOD(self.op, self.high, self.low,
self.close)
elif para is 'CDLHOMINGPIGEON': #Homing Pigeon
self.integer = ta.CDLHOMINGPIGEON(self.op, self.high, self.low,
self.close)
elif para is 'CDLIDENTICAL3CROWS': #Identical Three Crows
self.integer = ta.CDLIDENTICAL3CROWS(self.op, self.high, self.low,
self.close)
elif para is 'CDLINNECK': #In-Neck Pattern
self.integer = ta.CDLINNECK(self.op, self.high, self.low,
self.close)
elif para is 'CDLINVERTEDHAMMER': #Inverted Hammer
self.integer = ta.CDLINVERTEDHAMMER(self.op, self.high, self.low,
self.close)
elif para is 'CDLKICKING': #Kicking
self.integer = ta.CDLKICKING(self.op, self.high, self.low,
self.close)
elif para is 'CDLKICKINGBYLENGTH': #Kicking - bull/bear determined by the longer marubozu
self.integer = ta.CDLKICKINGBYLENGTH(self.op, self.high, self.low,
self.close)
elif para is 'CDLLADDERBOTTOM': #Ladder Bottom
self.integer = ta.CDLLADDERBOTTOM(self.op, self.high, self.low,
self.close)
elif para is 'CDLLONGLEGGEDDOJI': #Long Legged Doji
self.integer = ta.CDLLONGLEGGEDDOJI(self.op, self.high, self.low,
self.close)
elif para is 'CDLLONGLINE': #Long Line Candle
self.integer = ta.CDLLONGLINE(self.op, self.high, self.low,
self.close)
elif para is 'CDLMARUBOZU': #Marubozu
self.integer = ta.CDLMARUBOZU(self.op, self.high, self.low,
self.close)
elif para is 'CDLMATCHINGLOW': #Matching Low
self.integer = ta.CDLMATCHINGLOW(self.op, self.high, self.low,
self.close)
elif para is 'CDLMATHOLD': #Mat Hold
self.integer = ta.CDLMATHOLD(self.op,
self.high,
self.low,
self.close,
penetration=0)
elif para is 'CDLMORNINGDOJISTAR': #Morning Doji Star
self.integer = ta.CDLMORNINGDOJISTAR(self.op,
self.high,
self.low,
self.close,
penetration=0)
elif para is 'CDLMORNINGSTAR': #Morning Star
self.integer = ta.CDLMORNINGSTAR(self.op,
self.high,
self.low,
self.close,
penetration=0)
elif para is 'CDLONNECK': #On-Neck Pattern
self.integer = ta.CDLONNECK(self.op, self.high, self.low,
self.close)
elif para is 'CDLPIERCING': #Piercing Pattern
self.integer = ta.CDLPIERCING(self.op, self.high, self.low,
self.close)
elif para is 'CDLRICKSHAWMAN': #Rickshaw Man
self.integer = ta.CDLRICKSHAWMAN(self.op, self.high, self.low,
self.close)
elif para is 'CDLRISEFALL3METHODS': #Rising/Falling Three Methods
self.integer = ta.CDLRISEFALL3METHODS(self.op, self.high, self.low,
self.close)
elif para is 'CDLSEPARATINGLINES': #Separating Lines
self.integer = ta.CDLSEPARATINGLINES(self.op, self.high, self.low,
self.close)
elif para is 'CDLSHOOTINGSTAR': #Shooting Star
self.integer = ta.CDLSHOOTINGSTAR(self.op, self.high, self.low,
self.close)
elif para is 'CDLSHORTLINE': #Short Line Candle
self.integer = ta.CDLSHORTLINE(self.op, self.high, self.low,
self.close)
elif para is 'CDLSPINNINGTOP': #Spinning Top
self.integer = ta.CDLSPINNINGTOP(self.op, self.high, self.low,
self.close)
elif para is 'CDLSTALLEDPATTERN': #Stalled Pattern
self.integer = ta.CDLSTALLEDPATTERN(self.op, self.high, self.low,
self.close)
elif para is 'CDLSTICKSANDWICH': #Stick Sandwich
self.integer = ta.CDLSTICKSANDWICH(self.op, self.high, self.low,
self.close)
elif para is 'CDLTAKURI': #Takuri (Dragonfly Doji with very long lower shadow)
self.integer = ta.CDLTAKURI(self.op, self.high, self.low,
self.close)
elif para is 'CDLTASUKIGAP': #Tasuki Gap
self.integer = ta.CDLTASUKIGAP(self.op, self.high, self.low,
self.close)
elif para is 'CDLTHRUSTING': #Thrusting Pattern
self.integer = ta.CDLTHRUSTING(self.op, self.high, self.low,
self.close)
elif para is 'CDLTRISTAR': #Tristar Pattern
self.integer = ta.CDLTRISTAR(self.op, self.high, self.low,
self.close)
elif para is 'CDLUNIQUE3RIVER': #Unique 3 River
self.integer = ta.CDLUNIQUE3RIVER(self.op, self.high, self.low,
self.close)
elif para is 'CDLUPSIDEGAP2CROWS': #Upside Gap Two Crows
self.integer = ta.CDLUPSIDEGAP2CROWS(self.op, self.high, self.low,
self.close)
elif para is 'CDLXSIDEGAP3METHODS': #Upside/Downside Gap Three Methods
self.integer = ta.CDLXSIDEGAP3METHODS(self.op, self.high, self.low,
self.close)
#Statistic Functions : #
elif para is 'BETA': #Beta
self.output = ta.BETA(self.high, self.low, timeperiod=5)
elif para is 'CORREL': #Pearson's Correlation Coefficient (r)
self.output = ta.CORREL(self.high, self.low, timeperiod=self.tp)
elif para is 'LINEARREG': #Linear Regression
self.output = ta.LINEARREG(self.close, timeperiod=self.tp)
elif para is 'LINEARREG_ANGLE': #Linear Regression Angle
self.output = ta.LINEARREG_ANGLE(self.close, timeperiod=self.tp)
elif para is 'LINEARREG_INTERCEPT': #Linear Regression Intercept
self.output = ta.LINEARREG_INTERCEPT(self.close,
timeperiod=self.tp)
elif para is 'LINEARREG_SLOPE': #Linear Regression Slope
self.output = ta.LINEARREG_SLOPE(self.close, timeperiod=self.tp)
elif para is 'STDDEV': #Standard Deviation
self.output = ta.STDDEV(self.close, timeperiod=5, nbdev=1)
elif para is 'TSF': #Time Series Forecast
self.output = ta.TSF(self.close, timeperiod=self.tp)
elif para is 'VAR': #Variance
self.output = ta.VAR(self.close, timeperiod=5, nbdev=1)
else:
print('You issued command:' + para)
df['Adj Close'].shift(1)),
timeperiod=n,
nbdevup=2,
nbdevdn=2,
matype=0)
df['DEMA'] = ta.DEMA(np.array(df['Adj Close'].shift(1)), timeperiod=n)
df['EMA'] = ta.EMA(np.array(df['Adj Close'].shift(1)), timeperiod=n)
df['HT_TRENDLINE'] = ta.HT_TRENDLINE(np.array(df['Adj Close'].shift(1)))
df['KAMA'] = ta.KAMA(np.array(df['Adj Close'].shift(1)), timeperiod=n)
df['MA'] = ta.MA(np.array(df['Adj Close'].shift(1)), timeperiod=n, matype=0)
df['mama'], df['fama'] = ta.MAMA(np.array(df['Adj Close'].shift(1)),
fastlimit=0,
slowlimit=0)
df['MAVP'] = ta.MAVP(np.array(df['Adj Close'].shift(1)),
periods,
minperiod=2,
maxperiod=30,
matype=0)
df['MIDPOINT'] = ta.MIDPOINT(np.array(df['Adj Close'].shift(1)), timeperiod=n)
df['MIDPRICE'] = ta.MIDPRICE(np.array(df['High'].shift(1)),
np.array(df['Low'].shift(1)),
timeperiod=n)
df['SAR'] = ta.SAR(np.array(df['High'].shift(1)),
np.array(df['Low'].shift(1)),
acceleration=0,
maximum=0)
df['SAREXT'] = ta.SAREXT(np.array(df['High'].shift(1)),
np.array(df['Low'].shift(1)),
startvalue=0,
offsetonreverse=0,
