def DEMA(close, timeperiod=30):
"DEMA - Double Exponential Moving Average"
real = talib.DEMA(np.asarray(close), timeperiod=30)
return [real]
def technical_indicators_panda_dataframe(df_price):
open = df_price['Open']
high = df_price['High']
low = df_price['Low']
close = df_price['Close']
volume = df_price['Volume']
## Commoditty Channel Index
cci = tb.CCI(high, low, close, timeperiod=20)
## Rate of change
roc = tb.ROC(close, timeperiod=21)
## Momentum Indicators Functions
#Aroon
aroondown, aroonup = tb.AROON(high, low, timeperiod=14)
#Average Directional Movement Index
adx = tb.ADX(high, low, close, timeperiod=14)
di_plus = tb.PLUS_DI(high, low, close, timeperiod=14)
di_minus = tb.MINUS_DI(high, low, close, timeperiod=14)
#Money Flow Index
mfi = tb.MFI(high, low, close, volume, timeperiod=14)
#Relative Strength Index
rsi = tb.RSI(close, timeperiod=14)
#Stochastic
slowk, slowd = tb.STOCH(high,
low,
close,
fastk_period=5,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
#STOCHF - Stochastic Fast
fastk, fastd = tb.STOCHF(high,
low,
close,
fastk_period=5,
fastd_period=3,
fastd_matype=0)
#Moving Average Convergence/Divergence
macd, macdema, macdhist = tb.MACD(close,
fastperiod=12,
slowperiod=26,
signalperiod=9)
## Overlap Studies Functions
#Bollinger Bands
upperband, middleband, lowerband = tb.BBANDS(close,
timeperiod=5,
nbdevup=2,
nbdevdn=2,
matype=0)
#Weighted Moving Average
wma5 = tb.WMA(close, timeperiod=5)
wma30 = tb.WMA(close, timeperiod=30)
#Exponential Moving Average
ema5 = tb.EMA(close, timeperiod=5)
ema21 = tb.EMA(close, timeperiod=21)
#Double Exponential Moving Average
dema5 = tb.DEMA(close, timeperiod=5)
dema21 = tb.DEMA(close, timeperiod=21)
#Triple Exponential Moving Average
tema = tb.TEMA(close, timeperiod=30)
#Triangular Moving Average
trima5 = tb.DEMA(close, timeperiod=5)
trima30 = tb.TRIMA(close, timeperiod=30)
## Volume indicators Functions
#AD - Chaikin A/D Line
chaikin = tb.AD(high, low, close, volume)
##=> MERGE
kwargs = {"cci":cci, "roc": roc, "aroondown": aroondown, "aroonup": aroonup, "adx": adx, "di_plus":di_plus, "di_minus":di_minus, "mfi": mfi, "rsi": rsi, "slowk": slowk, "slowd": slowd, "fastk": fastk, "fastd": fastd, "macd": macd, "macdema": macdema, "macdhist": macdhist,\
"upperband": upperband , "middleband": middleband , "lowerband": lowerband, "wma5" : wma5, "wma30" : wma30, "ema5" : ema5, "ema21" : ema21, "dema21": dema21, "dema5": dema5, "tema": tema, "trima5": trima5,"trima30": trima30,\
"chaikin": chaikin}
return df_price.assign(**kwargs)
data['ATR'] = ATR_usual
# WILLR指标
WILLR_usual = talib.WILLR(arrHigh, arrLow, arrClose)
data['WILLR'] = WILLR_usual
# BOV指标
OBV_usual = talib.OBV(arrClose, arrVolume)
data['OBV'] = OBV_usual
# SAR指标
SAR_usual = talib.SAR(arrHigh, arrLow)
data['SAR'] = SAR_usual
# DEMA指标
DEMA_usual = talib.DEMA(arrClose)
data['DEMA'] = DEMA_usual
#MOM指标
MOM_usual = talib.MOM(arrClose)
data['MOM'] = MOM_usual
"""
#DEMA
DEMA=talib.DEMA(arrClose)
data['DEMA_30min']=DEMA
#WMA
WMA=talib.WMA(arrClose)
data['WMA_30min']=WMA
#ADX
shortperiod = 5
medperiod = 10
longperiod = 20
close = np.array([float(x) for x in data.close.values])
high = np.array([float(x) for x in data.high.values])
low = np.array([float(x) for x in data.low.values])
volume = np.array([float(x) for x in data.volume.values])
price = np.array([high, low, close]) #收集所有价格数据
price_list = ['high', 'low', 'close']
feavec = [] #存放特征向量名称
for i in range(len(price)):
data['EMA_' + price_list[i]] = ta.EMA(price[i], timeperiod=medperiod)
data['DEMA_' + price_list[i]] = ta.DEMA(price[i], timeperiod=medperiod)
data['DIF_' + price_list[i]] = ta.MACD(price[i],
fastperiod=shortperiod,
slowperiod=longperiod)[0]
data['DEA_' + price_list[i]] = ta.MACD(price[i],
fastperiod=shortperiod,
slowperiod=longperiod)[1]
data['MACD_' + price_list[i]] = ta.MACD(price[i],
fastperiod=shortperiod,
slowperiod=longperiod)[2]
data['TRIX_' + price_list[i]] = ta.TRIX(price[i], timeperiod=longperiod)
data['RSI_' + price_list[i]] = ta.RSI(price[i], timeperiod=longperiod)
data['ROC_' + price_list[i]] = ta.ROC(price[i], timeperiod=medperiod)
data['STD_' + price_list[i]] = ta.STDDEV(price[i], timeperiod=shortperiod)
data['OBV_' + price_list[i]] = ta.OBV(price[i], volume)
for j in range(-3, 0):
def add_ratio(df,
ratio_name,
price_field='Close',
parameter=1,
new_field_name=-1):
"""
Loads csv into a dataframe
:param df_path: The name of the file if in the same folder or the path to the file
:param dataset_type: Integer that tells the dataset inserted. 0 if fundamentals, 1 if stock prices, 2 if constituents.
:returns: returns a Pandas Dataframe with the data of the csv requested
"""
ratios = [
'ema', 'sma', 'dema', 'kama', 'tema', 'trima', 'wma', 'ols', 'std',
'atr', 'aroon', 'mfi', 'ssl', 'ssl_s', 'macd_s', 'macd_diff', 'rsi',
'cmf', 'cmo', 'aroon_s', 'sar', 'sar_s', 'ema_slope'
]
first_level_headers = list(dm.unique_headers(df, 1))
if new_field_name == -1:
new_field_name = ratio_name + str(parameter)
if ratio_name not in ratios:
raise Exception("\nError! Ratio [{}] doesn't exist.".format(
str(ratio_name)))
return None
for level in first_level_headers:
if ratio_name == 'sma':
df[level, new_field_name] = df[level, price_field].rolling(
window=parameter).mean()
elif ratio_name == 'ema':
df[level, new_field_name] = df[level, price_field].ewm(
span=parameter, adjust=False, min_periods=parameter).mean()
elif ratio_name == 'dema':
df[level, new_field_name] = talib.DEMA(df[level, price_field],
parameter)
elif ratio_name == 'kama':
df[level, new_field_name] = talib.KAMA(df[level, price_field],
parameter)
elif ratio_name == 'tema':
df[level, new_field_name] = talib.TEMA(df[level, price_field],
parameter)
elif ratio_name == 'trima':
df[level, new_field_name] = talib.TRIMA(df[level, price_field],
parameter)
elif ratio_name == 'wma':
df[level, new_field_name] = talib.WMA(df[level, price_field],
parameter)
elif ratio_name == 'std':
df = add_std(df, parameter, level, price_field)
elif ratio_name == 'ols':
df = add_average_ols(df,
level,
'ema' + str(parameter),
divisions=10,
length=parameter)
elif ratio_name == 'atr':
df = add_atr(df, parameter, level)
elif ratio_name == 'aroon':
df = ra.add_aroon(df, parameter, level)
elif ratio_name == 'mfi':
df = ra.add_mfi(df, parameter, level)
elif ratio_name == 'ssl':
df = ra.add_ssl(df, parameter, level)
elif ratio_name == 'ssl_s':
df = ra.add_ssl_s(df, parameter, level)
elif ratio_name == 'rsi':
df = ra.add_rsi(df, parameter, level)
elif ratio_name == 'cmf':
df = ra.add_cmf(df, parameter, level)
elif ratio_name == 'cmo':
df = ra.add_cmo(df, parameter, level)
elif ratio_name == 'macd_diff':
df = ra.add_macd_diff(df, parameter, level)
elif ratio_name == 'aroon_s':
df = ra.add_aroon_s(df, parameter, level)
elif ratio_name == 'sar':
df = ra.add_sar(df, parameter, level)
elif ratio_name == 'sar_s':
df = ra.add_sar_s(df, parameter, level)
elif ratio_name == 'ema_slope':
df = ra.add_ema_slope(df, parameter, level)
elif ratio_name == 'macd_s':
df[level, new_field_name] = ta.trend.macd(df[level, price_field],
n_fast=parameter,
n_slow=parameter * 2,
fillna=False)
df = df.sort_index(axis=1)
return df
def dema(np_array):
if check_np_array(np_array):
return talib.DEMA(np_array)
model.add(Dropout(0.5))
model.add(Dense(1))
opt = Nadam(lr=0.005) # 0.005, 0.002, 0.001, 0.01
model.compile(loss='mse', optimizer=opt)
model.load_weights(MODEL_FILE_PATH)
predictions = model.predict(test_X)
score = model.evaluate(test_X, test_Y, verbose=0)
print('Test loss:', score) # this is mean_squared_error
###########################################################
df_result = pd.DataFrame(test_Y, columns=['real'])
df_result['pred'] = pd.Series(predictions.reshape(-1))
yhat = ta.DEMA(np.array(df_result['pred'].astype(float)),
timeperiod=3) # 디노이징 이동평균
df_result['pred_dn'] = pd.Series(yhat, index=df_result.index)
df_result['pred_change'] = (df_result['pred_dn'] -
df_result['pred_dn'].shift(3))
df_result['classify'] = df_result['pred_change'].transform(
classify_trinary)
print(df_result.shape)
df_result_all = pd.merge(stock_df[['종가', '시가']].iloc[TIME_SEQ_LEN -
1:].reset_index(),
df_result,
left_index=True,
right_index=True)
df_result_all.rename(columns={
'index': 'date',
'종가': 'close',
def DEMA(Close, timeperiod=30):
return Close.apply(lambda col: ta.DEMA(col, timeperiod), axis=0)
def DEMA(self, name, **parameters):
data = self.__data[name]
return talib.DEMA(data, **parameters)
def ta_indicators(df):
dfa = pd.DataFrame()
# BBANDS Bollinger Bands
# 函数名：BBANDS
# 名称： 布林线指标
# 简介：其利用统计原理，求出股价的标准差及其信赖区间，从而确定股价的波动
# 范围及未来走势，利用波带显示股价的安全高低价位，因而也被称为布林带。
# 分析和应用： 百度百科 同花顺学院
# upperband, middleband, df.lowerband = BBANDS(
# df.close, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)
dfa["BBANDS_upper"], dfa["BBANDS_middle"], dfa["BBANDS_lower"] = ta.BBANDS(
df.close, matype=MA_Type.T3)
# DEMA - Double Exponential Moving Average 双移动平均线
# 函数名：DEMA
# 名称： 双移动平均线
# 简介：两条移动平均线来产生趋势信号，较长期者用来识别趋势，较短期者用来选择时机。正是两条平均线及价格三者的相互作用，才共同产生了趋势信号。
# real = DEMA(df.close, timeperiod=30)
dfa["DEMA"] = ta.DEMA(df.close, timeperiod=30)
# MA - Moving average 移动平均线
# 函数名：MA
# 名称： 移动平均线
# 简介：移动平均线，Moving Average，简称MA，原本的意思是移动平均，
# 由于我们将其制作成线形，所以一般称之为移动平均线，简称均线。
# 它是将某一段时间的收盘价之和除以该周期。 比如日线MA5指5天内的收盘价除以5 。
# real = MA(df.close, timeperiod=30, matype=0)
dfa["MA"] = ta.MA(df.close, timeperiod=30, matype=0)
# EMA和MACD
# 调用ta计算6日指数移动平均线的值
dfa['EMA12'] = ta.EMA(np.array(df.close), timeperiod=6)
dfa['EMA26'] = ta.EMA(np.array(df.close), timeperiod=12)
# KAMA - Kaufman Adaptive Moving Average 考夫曼的自适应移动平均线
# 函数名：KAMA
# 名称： 考夫曼的自适应移动平均线
# 简介：短期均线贴近价格走势，灵敏度高，但会有很多噪声，产生虚假信号；
# 长期均线在判断趋势上一般比较准确 ，但是长期均线有着严重滞后的问题。
# 我们想得到这样的均线，当价格沿一个方向快速移动时，短期的移动平均线是
# 最合适的；当价格在横盘的过程中，长期移动平均线是合适的。
# NOTE: The KAMA function has an unstable period.
dfa["KAMA"] = ta.KAMA(df.close, timeperiod=30)
# SMA （简单移动平均线）
# （参数1：收盘价序列，参数2：时间周期（均线的计算长度 即 几日均线））
# SAREXT - Parabolic SAR - Extended
# real = SAREXT(df.high, df.low, startvalue=0, offsetonreverse=0,
# accelerationinitlong=0, accelerationlong=0, accelerationmaxlong=0,
# accelerationinitshort=0, accelerationshort=0, accelerationmaxshort=0)
# SMA - Simple Moving Average 简单移动平均线
# 函数名：SMA
# 名称： 简单移动平均线
# 简介：移动平均线，Moving Average，简称MA，原本的意思是移动平均，
# 由于我们将其制作成线形，所以一般称之为移动平均线，简称均线。
# 它是将某一段时间的收盘价之和除以该周期。 比如日线MA5指5天内的收盘价除以5 。
# 百度百科 同花顺学院
# real = SMA(df.close, timeperiod=30)
dfa['SMA'] = ta.SMA(df.close, timeperiod=30)
# MIDPRICE - Midpoint Price over period
dfa["MIDPOINT"] = ta.MIDPOINT(df.close, timeperiod=14)
# SAR - Parabolic SAR 抛物线指标
# 函数名：SAR
# 名称： 抛物线指标
# 简介：抛物线转向也称停损点转向，是利用抛物线方式，随时调整停损点位置
# 以观察买卖点。由于停损点（又称转向点SAR）以弧形的方式移动，
# 故称之为抛物线转向指标 。
# real = SAR(df.high, df.low, acceleration=0, maximum=0)
dfa["SAR"] = ta.SAR(df.high, df.low, acceleration=0, maximum=0)
# T3 - Triple Exponential Moving Average (T3) 三重指数移动平均线
# 函数名：T3
# 名称：三重指数移动平均线
# 简介：TRIX长线操作时采用本指标的讯号，长时间按照本指标讯号交易，
# 获利百分比大于损失百分比，利润相当可观。 比如日线MA5指5天内的收盘价除以5 。
# NOTE: The T3 function has an unstable period
# real = T3(df.close, timeperiod=5, vfactor=0)
dfa["T3"] = ta.T3(df.close, timeperiod=5, vfactor=0)
# TEMA - Triple Exponential Moving Average
# 函数名：TEMA（T3 区别？） 名称：三重指数移动平均线
# real = TEMA(df.close, timeperiod=30)
dfa["TEMA"] = ta.TEMA(df.close, timeperiod=30)
# MIDPRICE - Midpoint Price over period
# real = MIDPRICE(df.high, df.low, timeperiod=14)
dfa["MIDPRICE"] = ta.MIDPRICE(df.high, df.low, timeperiod=14)
# TRIMA - Triangular Moving Average
dfa["TRIMA"] = ta.TRIMA(df.close, timeperiod=30)
# dfa["SAREXT"]=ta.SAREXT(df.high, df.low, maximum=0)
# SAREXT - Parabolic SAR - Extended
dfa["SAREXT"] = ta.SAREXT(df.high,
df.low,
startvalue=0,
offsetonreverse=0,
accelerationinitlong=0,
accelerationlong=0,
accelerationmaxlong=0,
accelerationinitshort=0,
accelerationshort=0,
accelerationmaxshort=0)
# WMA - Weighted Moving Average 移动加权平均法
# 函数名：WMA
# 名称：加权移动平均线
# 简介：移动加权平均法是指以每次进货的成本加上原有库存存货的成本，
# 除以每次进货数量与原有库存存货的数量之和，据以计算加权平均单位成本，
# 以此为基础计算当月发出存货的成本和期末存货的成本的一种方法。
dfa["WMA"] = ta.WMA(df.close, timeperiod=30)
# Volatility Indicator Functions 波动率指标函数
# ATR - Average True Range
# 函数名：ATR
# 名称：真实波动幅度均值
# 简介：真实波动幅度均值（ATR)是以N天的指数移动平均数平均後的交易波动幅度。
# 计算公式：一天的交易幅度只是单纯地 最大值 - 最小值。
# 而真实波动幅度则包含昨天的收盘价，若其在今天的幅度之外：
# 真实波动幅度 = max(最大值,昨日收盘价) − min(最小值,昨日收盘价) 真实波动
# 幅度均值便是「真实波动幅度」的 N 日 指数移动平均数。
# 特性：：
# 波动幅度的概念表示可以显示出交易者的期望和热情。
# 大幅的或增加中的波动幅度表示交易者在当天可能准备持续买进或卖出股票。
# 波动幅度的减少则表示交易者对股市没有太大的兴趣。
# NOTE: The ATR function has an unstable period.
# real = ATR(df.high, df.low, df.close, timeperiod=14)
# ATR（平均真实波幅）
# （参数1：最高价序列，参数2：最低价序列，参数3：收盘价序列，参数4：时间周期）
dfa["ATR"] = ta.ATR(df.high, df.low, df.close, timeperiod=14)
# NATR - Normalized Average True Range
# 函数名：NATR
# 名称：归一化波动幅度均值
# 简介：归一化波动幅度均值（NATR)是
# NOTE: The NATR function has an unstable period.
# real = NATR(df.high, df.low, df.close, timeperiod=14)
dfa["NATR"] = ta.NATR(df.high, df.low, df.close, timeperiod=14)
# TRANGE - True Range
# 函数名：TRANGE
# 名称：真正的范围
# real = TRANGE(df.high, df.low, df.close)
dfa["TRANGE"] = ta.TRANGE(df.high, df.low, df.close)
# Volume Indicators 成交量指标
# AD - Chaikin A/D Line 量价指标
# 函数名：AD
# 名称：Chaikin A/D Line 累积/派发线（Accumulation/Distribution Line）
# 简介：Marc Chaikin提出的一种平衡交易量指标，以当日的收盘价位来估算成交流量
# 用于估定一段时间内该证券累积的资金流量。
# 计算公式：
# 多空对比 = [（收盘价- 最低价） - （最高价 - 收盘价）] / （最高价 - 最低价)
# 若最高价等于最低价： 多空对比 = （收盘价 / 昨收盘） - 1
# 研判：
# 1、A/D测量资金流向，向上的A/D表明买方占优势，而向下的A/D表明卖方占优势
# 2、A/D与价格的背离可视为买卖信号，即底背离考虑买入，顶背离考虑卖出
# 3、应当注意A/D忽略了缺口的影响，事实上，跳空缺口的意义是不能轻易忽略的
# A/D指标无需设置参数，但在应用时，可结合指标的均线进行分析
# real = AD(df.high, df.low, df.close, df.volume)
dfa["AD"] = ta.AD(df.high, df.low, df.close, df.volume)
# ADOSC - Chaikin A/D Oscillator
# 函数名：ADOSC
# 名称：Chaikin A/D Oscillator Chaikin震荡指标
# 简介：将资金流动情况与价格行为相对比，检测市场中资金流入和流出的情况
# 计算公式：fastperiod A/D - slowperiod A/D
# 研判：
# 1、交易信号是背离：看涨背离做多，看跌背离做空
# 2、股价与90天移动平均结合，与其他指标结合
# 3、由正变负卖出，由负变正买进
# real = ADOSC(df.high, df.low, df.close, df.volume,
# fastperiod=3, slowperiod=10)
dfa["ADOSC"] = ta.ADOSC(df.high,
df.low,
df.close,
df.volume,
fastperiod=3,
slowperiod=10)
# OBV - On Balance Volume
# 函数名：OBV
# 名称：On Balance Volume 能量潮
# 简介：Joe Granville提出，通过统计成交量变动的趋势推测股价趋势
# 计算公式：以某日为基期，逐日累计每日上市股票总成交量，
# 若隔日指数或股票上涨 ，则基期OBV加上本日成交量为本日OBV。
# 隔日指数或股票下跌， 则基期OBV减去本日成交量为本日OBV
# 研判：
# 1、以“N”字型为波动单位，一浪高于一浪称“上升潮”，下跌称“跌潮”；上升潮买进，跌潮卖出
# 2、须配合K线图走势
# 3、用多空比率净额法进行修正，但不知TA-Lib采用哪种方法
# 计算公式： 多空比率净额= [（收盘价－最低价）－（最高价-收盘价）] ÷（ 最高价－最低价）×成交量
# real = OBV(df.close, df.volume)
dfa["OBV"] = ta.OBV(df.close, df.volume)
# Cycle Indicator Functions
# HT_DCPERIOD - Hilbert Transform - Dominant Cycle Period
# 函数名：HT_DCPERIOD
# 名称： 希尔伯特变换-主导周期
# 简介：将价格作为信息信号，计算价格处在的周期的位置，作为择时的依据。
# NOTE: The HT_DCPERIOD function has an unstable period.
# real = HT_DCPERIOD(df.close)
dfa["HT_DCPERIOD"] = ta.HT_DCPERIOD(df.close)
# HT_DCPHASE - Hilbert Transform - Dominant Cycle Phase
# 函数名：HT_DCPHASE
# 名称： 希尔伯特变换-主导循环阶段
# NOTE: The HT_DCPHASE function has an unstable period.
# real = HT_DCPHASE(df.close)
dfa["HT_DCPHASE"] = ta.HT_DCPHASE(df.close)
# HT_PHASOR - Hilbert Transform - Phasor Components
# 函数名：HT_DCPHASE
# 名称： 希尔伯特变换-希尔伯特变换相量分量
# NOTE: The HT_PHASOR function has an unstable period.
# inphase, quadrature = HT_PHASOR(df.close)
dfa["HT_PHASOR_inphase"], dfa["HT_PHASOR_quadrature"] = ta.HT_PHASOR(
df.close)
# HT_SINE - Hilbert Transform - SineWave
# 函数名：HT_DCPHASE
# 名称： 希尔伯特变换-正弦波 NOTE: The HT_SINE function has an unstable period.
# sine, leadsine = HT_SINE(df.close)
dfa["HT_SINE_sine"], dfa["HT_SINE_leadsine"] = ta.HT_SINE(df.close)
# HT_TRENDMODE - Hilbert Transform - Trend vs Cycle Mode
# 函数名：HT_DCPHASE
# 名称： 希尔伯特变换-趋势与周期模式
# NOTE: The HT_TRENDMODE function has an unstable period.
# integer = HT_TRENDMODE(df.close)
dfa["HT_TRENDMODE"] = ta.HT_TRENDMODE(df.close)
# Price Transform Functions
# AVGPRICE - Average Price
# 函数名：AVGPRICE
# 名称：平均价格函数
# real = AVGPRICE(open, df.high, df.low, df.close)
dfa["AVGPRICE"] = ta.AVGPRICE(df.open, df.high, df.low, df.close)
# MEDPRICE - Median Price
# 函数名：MEDPRICE
# 名称：中位数价格
# real = MEDPRICE(df.high, df.low)
dfa["MEDPRICE"] = ta.MEDPRICE(df.high, df.low)
# TYPPRICE - Typical Price
# 函数名：TYPPRICE
# 名称：代表性价格
# real = TYPPRICE(df.high, df.low, df.close)
dfa["TYPPRICE"] = ta.TYPPRICE(df.high, df.low, df.close)
# WCLPRICE - Weighted Close Price
# 函数名：WCLPRICE
# 名称：加权收盘价
# real = WCLPRICE(df.high, df.low, df.close)
dfa["WCLPRICE"] = ta.WCLPRICE(df.high, df.low, df.close)
# Momentum Indicator Functions
# ADX - Average Directional Movement Index
# 函数名：ADX
# 名称：平均趋向指数
# 简介：使用ADX指标，指标判断盘整、振荡和单边趋势。
# 公式：
# 一、先决定股价趋势（Directional Movement，DM）是上涨或下跌：
# “所谓DM值，今日股价波动幅度大于昨日股价波动幅部分的最大值，可能是创高价的部分或创低价的部分；如果今日股价波动幅度较前一日小，则DM = 0。”
# 若股价高点持续走高，为上涨趋势，记作 +DM。
# 若为下跌趋势，记作 -DM。-DM的负号（–）是表示反向趋势（下跌），并非数值为负数。
# 其他状况：DM = 0。
# 二、寻找股价的真实波幅（True Range，TR）：
# 所谓真实波幅（TR）是以最高价，最低价，及前一日收盘价三个价格做比较，求出当日股价波动的最大幅度。
# 三、趋势方向需经由一段时间来观察，研判上才有意义。一般以14天为指标的观察周期：
# 先计算出 +DM、–DM及TR的14日算术平均数，得到 +DM14、–DM14及TR14三组数据作为起始值，再计算各自的移动平均值（EMA）。
# +DI14 = +DM/TR14*100
# -DI14 = +DM/TR14*100
# DX = |(+DI14)-(-DI14)| / |(+DI14)+(-DI14)|
# DX运算结果取其绝对值，再将DX作移动平均，得到ADX。
# 特点：
# ADX无法告诉你趋势的发展方向。
# 如果趋势存在，ADX可以衡量趋势的强度。不论上升趋势或下降趋势，
# ADX看起来都一样。
# ADX的读数越大，趋势越明显。衡量趋势强度时，需要比较几天的ADX 读数，
# 观察ADX究竟是上升或下降。ADX读数上升，代表趋势转强；
# 如果ADX读数下降，意味着趋势转弱。
# 当ADX曲线向上攀升，趋势越来越强，应该会持续发展。
# 如果ADX曲线下滑，代表趋势开始转弱，反转的可能性增加。
# 单就ADX本身来说，由于指标落后价格走势，所以算不上是很好的指标，
# 不适合单就ADX进行操作。可是，如果与其他指标配合运用，
# ADX可以确认市场是否存在趋势，并衡量趋势的强度。
# 指标应用：
# +DI与–DI表示多空相反的二个动向，当据此绘出的两条曲线彼此纠结相缠时，
# 代表上涨力道与下跌力道相当，多空势均力敌。当 +DI与–DI彼此穿越时，
# 由下往上的一方其力道开始压过由上往下的另一方，此时出现买卖讯号。
# ADX可作为趋势行情的判断依据，当行情明显朝多空任一方向进行时，
# ADX数值都会显著上升，趋势走强。
# 若行情呈现盘整格局时，ADX会低于 +DI与–DI二条线。
# 若ADX数值低于20，则不论DI表现如何，均显示市场没有明显趋势。
# ADX持续偏高时，代表“超买”（Overbought）或“超卖”（Oversold）的现象，
# 行情反转的机会将增加，此时则不适宜顺势操作。
# 当ADX数值从上升趋势转为下跌时，则代表行情即将反转；
# 若ADX数值由下跌趋势转为上升时，行情将止跌回升。
# 总言之，DMI指标包含4条线：+DI、-DI、ADX和ADXR。
# +DI代表买盘的强度、-DI代表卖盘的强度；
# ADX代表趋势的强度、ADXR则为ADX的移动平均。
# NOTE: The ADX function has an unstable period.
# real = ADX(df.high, df.low, df.close, timeperiod=14)
dfa["ADX"] = ta.ADX(df.high, df.low, df.close, timeperiod=14)
# ADXR- Average Directional Movement Index Rating
# 函数名：ADXR
# 名称：平均趋向指数的趋向指数
# 简介：使用ADXR指标，指标判断ADX趋势。
# NOTE: The ADXR function has an unstable period.
# real = ADXR(df.high, df.low, df.close, timeperiod=14)
dfa["ADXR"] = ta.ADXR(df.high, df.low, df.close, timeperiod=14)
# APO - Absolute Price Oscillator
# real = APO(df.close, fastperiod=12, slowperiod=26, matype=0)
dfa["APO"] = ta.APO(df.close, fastperiod=12, slowperiod=26, matype=0)
# AROON - Aroon
# 函数名：AROON
# 名称：阿隆指标
# 简介：该指标是通过计算自价格达到近期最高值和最低值以来所经过的期间数，
# 阿隆指标帮助你预测价格趋势到趋势区域
# （或者反过来，从趋势区域到趋势）的变化。
# 计算公式：
# Aroon(上升)=[(计算期天数-最高价后的天数)/计算期天数]*100
# Aroon(下降)=[(计算期天数-最低价后的天数)/计算期天数]*100
# 指数应用
# 1、极值0和100
# 当UP线达到100时，市场处于强势；如果维持在70100之间，表示一个上升趋势。
# 同样，如果Down线达到0，表示处于弱势，如果维持在030之间，表示处于下跌趋势。
# 如果两条线同处于极值水平，则表明一个更强的趋势。
# 2、平行运动
# 如果两条线平行运动时，表明市场趋势被打破。
# 可以预期该状况将持续下去，只到由极值水平或交叉穿行西安市出方向性运动为止。
# 3、交叉穿行
# 当下行线上穿上行线时，表明潜在弱势，预期价格开始趋于下跌。
# 反之，表明潜在强势，预期价格趋于走高。
# aroondown, aroonup = AROON(df.high, df.low, timeperiod=14)
dfa["AROON_aroondown"], dfa["AROON_aroonup"] = ta.AROON(df.high,
df.low,
timeperiod=14)
# AROONOSC - Aroon Oscillator
# 函数名：AROONOSC
# 名称：阿隆振荡
# 简介：
# real = AROONOSC(df.high, df.low, timeperiod=14)
dfa["AROONOSC"] = ta.AROONOSC(df.high, df.low, timeperiod=14)
# BOP - Balance Of Power 均势
# 函数名：BOP
# 名称：均势指标
# 简介
# real = BOP(open, df.high, df.low, df.close)
dfa["BOP"] = ta.BOP(df.open, df.high, df.low, df.close)
# CCI - Commodity Channel Index
# 函数名：CCI
# 名称：顺势指标
# 简介：CCI指标专门测量股价是否已超出常态分布范围
# 指标应用
# 1.当CCI指标曲线在+100线～-100线的常态区间里运行时,CCI指标参考意义不大，
# 可以用KDJ等其它技术指标进行研判。
# 2.当CCI指标曲线从上向下突破+100线而重新进入常态区间时，
# 表明市场价格的上涨阶段可能结束，将进入一个比较长时间的震荡整理阶段，
# 应及时平多做空。
# 3.当CCI指标曲线从上向下突破-100线而进入另一个非常态区间（超卖区）时，
# 表明市场价格的弱势状态已经形成，将进入一个比较长的寻底过程，
# 可以持有空单等待更高利润。如果CCI指标曲线在超卖区运行了相当长的一段
# 时间后开始掉头向上，表明价格的短期底部初步探明，可以少量建仓。
# CCI指标曲线在超卖区运行的时间越长，确认短期的底部的准确度越高。
# 4.CCI指标曲线从下向上突破-100线而重新进入常态区间时，表明市场价格的
# 探底阶段可能结束，有可能进入一个盘整阶段，可以逢低少量做多。
# 5.CCI指标曲线从下向上突破+100线而进入非常态区间(超买区)时，
# 表明市场价格已经脱离常态而进入强势状态，如果伴随较大的市场交投，
# 应及时介入成功率将很大。
# 6.CCI指标曲线从下向上突破+100线而进入非常态区间(超买区)后，
# 只要CCI指标曲线一直朝上运行，表明价格依然保持强势可以继续持有待涨。
# 但是，如果在远离+100线的地方开始掉头向下时，则表明市场价格的强势状态
# 将可能难以维持，涨势可能转弱，应考虑卖出。如果前期的短期涨幅过高同时
# 价格回落时交投活跃，则应该果断逢高卖出或做空。
# CCI主要是在超买和超卖区域发生作用，对急涨急跌的行情检测性相对准确。
# 非常适用于股票、外汇、贵金属等市场的短期操作。[1]
# real = CCI(df.high, df.low, df.close, timeperiod=14)
dfa["CCI"] = ta.CCI(df.high, df.low, df.close, timeperiod=14)
# CMO - Chande Momentum Oscillator 钱德动量摆动指标
# 函数名：CMO
# 名称：钱德动量摆动指标
# 简介：与其他动量指标摆动指标如相对强弱指标（RSI）和随机指标（KDJ）不同，
# 钱德动量指标在计算公式的分子中采用上涨日和下跌日的数据。
# 计算公式：CMO=（Su－Sd）*100/（Su+Sd）
# 其中：Su是今日收盘价与昨日收盘价（上涨日）差值加总。
# 若当日下跌，则增加值为0；
# Sd是今日收盘价与做日收盘价（下跌日）差值的绝对值加总。
# 若当日上涨，则增加值为0；
# 指标应用
# 本指标类似RSI指标。
# 当本指标下穿-50水平时是买入信号，上穿+50水平是卖出信号。
# 钱德动量摆动指标的取值介于-100和100之间。
# 本指标也能给出良好的背离信号。
# 当股票价格创出新低而本指标未能创出新低时，出现牛市背离；
# 当股票价格创出新高而本指标未能创出新高时，当出现熊市背离时。
# 我们可以用移动均值对该指标进行平滑。
# NOTE: The CMO function has an unstable period.
# real = CMO(df.close, timeperiod=14)
dfa["CMO"] = ta.CMO(df.close, timeperiod=14)
# DX - Directional Movement Index DMI指标又叫动向指标或趋向指标
# 函数名：DX
# 名称：动向指标或趋向指标
# 简介：通过分析股票价格在涨跌过程中买卖双方力量均衡点的变化情况，
# 即多空双方的力量的变化受价格波动的影响而发生由均衡到失衡的循环过程，
# 从而提供对趋势判断依据的一种技术指标。
# 分析和应用：百度百科 维基百科 同花顺学院
# NOTE: The DX function has an unstable period.
# real = DX(df.high, df.low, df.close, timeperiod=14)
dfa["DX"] = ta.DX(df.high, df.low, df.close, timeperiod=14)
# MACD - Moving Average Convergence/Divergence
# 函数名：MACD
# 名称：平滑异同移动平均线
# 简介：利用收盘价的短期（常用为12日）指数移动平均线与长期（常用为26日）
# 指数移动平均线之间的聚合与分离状况，对买进、卖出时机作出研判的技术指标。
# 分析和应用：百度百科 维基百科 同花顺学院
# macd, macdsignal, macdhist = MACD(df.close, fastperiod=12,
# slowperiod=26, signalperiod=9)
dfa["MACD_macd"], dfa["MACD_macdsignal"], dfa["MACD_macdhist"] = ta.MACD(
df.close, fastperiod=12, slowperiod=26, signalperiod=9)
# MACDEXT - MACD with controllable MA type
# 函数名：MACDEXT (这个是干啥的(⊙o⊙)?)
# 名称：
# macd, macdsignal, macdhist = MACDEXT(df.close, fastperiod=12,
# fastmatype=0, slowperiod=26,
# slowmatype=0, signalperiod=9,
# signalmatype=0)
dfa["MACDEXT_macd"], dfa["MACDEXT_macdsignal"], dfa[
"MACDEXT_macdhist"] = ta.MACDEXT(df.close,
fastperiod=12,
fastmatype=0,
slowperiod=26,
slowmatype=0,
signalperiod=9,
signalmatype=0)
# MACDFIX - Moving Average Convergence/Divergence Fix 12/26
# macd, macdsignal, macdhist = MACDFIX(df.close, signalperiod=9)
dfa["MACDFIX_macd"], dfa["MACDFIX_macdsignal"], dfa[
"MACDFIX_macdhist"] = ta.MACDFIX(df.close, signalperiod=9)
# MFI - Money Flow Index 资金流量指标
# 函数名：MFI
# 名称：资金流量指标
# 简介：属于量价类指标，反映市场的运行趋势
# 分析和应用：百度百科 同花顺学院
# NOTE: The MFI function has an unstable period.
# real = MFI(df.high, df.low, df.close, df.volume, timeperiod=14)
dfa["MFI"] = ta.MFI(df.high, df.low, df.close, df.volume, timeperiod=14)
# MINUS_DI - Minus Directional Indicator
# 函数名：DMI 中的DI指标 负方向指标
# 名称：下升动向值
# 简介：通过分析股票价格在涨跌过程中买卖双方力量均衡点的变化情况，
# 即多空双方的力量的变化受价格波动的影响而发生由均衡到失衡的循环过程，
# 从而提供对趋势判断依据的一种技术指标。
# 分析和应用：百度百科 维基百科 同花顺学院
# NOTE: The MINUS_DI function has an unstable period.
# real = MINUS_DI(df.high, df.low, df.close, timeperiod=14)
dfa["MINUS_DI"] = ta.MINUS_DI(df.high, df.low, df.close, timeperiod=14)
# MINUS_DM - Minus Directional Movement
# 函数名：MINUS_DM
# 名称： 上升动向值 DMI中的DM代表正趋向变动值即上升动向值
# 简介：通过分析股票价格在涨跌过程中买卖双方力量均衡点的变化情况，
# 即多空双方的力量的变化受价格波动的影响而发生由均衡到失衡的循环过程，
# 从而提供对趋势判断依据的一种技术指标。
# 分析和应用：百度百科 维基百科 同花顺学院
# NOTE: The MINUS_DM function has an unstable period.
# real = MINUS_DM(df.high, df.low, timeperiod=14)
dfa["MINUS_DM"] = ta.MINUS_DM(df.high, df.low, timeperiod=14)
# MOM - Momentum 动量
# 函数名：MOM
# 名称： 上升动向值
# 简介：投资学中意思为续航，指股票(或经济指数)持续增长的能力。研究发现，
# 赢家组合在牛市中存在着正的动量效应，输家组合在熊市中存在着负的动量效应。
# real = MOM(df.close, timeperiod=10)
dfa["MOM"] = ta.MOM(df.close, timeperiod=10)
# PLUS_DI - Plus Directional Indicator
# NOTE: The PLUS_DI function has an unstable period.
# real = PLUS_DI(df.high, df.low, df.close, timeperiod=14)
dfa["PLUS_DI"] = ta.PLUS_DI(df.high, df.low, df.close, timeperiod=14)
# PLUS_DM - Plus Directional Movement
# NOTE: The PLUS_DM function has an unstable period.
# real = PLUS_DM(df.high, df.low, timeperiod=14)
dfa["PLUS_DM"] = ta.PLUS_DM(df.high, df.low, timeperiod=14)
# PPO - Percentage Price Oscillator 价格震荡百分比指数
# 函数名：PPO 名称： 价格震荡百分比指数
# 简介：价格震荡百分比指标（PPO）是一个和MACD指标非常接近的指标。
# PPO标准设定和MACD设定非常相似：12,26,9和PPO，
# 和MACD一样说明了两条移动平均线的差距，
# 但是它们有一个差别是PPO是用百分比说明。
# real = PPO(df.close, fastperiod=12, slowperiod=26, matype=0)
dfa["PPO"] = ta.PPO(df.close, fastperiod=12, slowperiod=26, matype=0)
# ROC - Rate of change : ((price/prevPrice)-1)*100 变动率指标
# 函数名：ROC
# 名称： 变动率指标
# 简介：ROC是由当天的股价与一定的天数之前的某一天股价比较，
# 其变动速度的大小,来反映股票市变动的快慢程度
# 分析和应用：百度百科 同花顺学院
# real = ROC(df.close, timeperiod=10)
dfa["ROC"] = ta.ROC(df.close, timeperiod=10)
# ROCP - Rate of change Percentage: (price-prevPrice)/prevPrice
# real = ROCP(df.close, timeperiod=10)
dfa["ROCP"] = ta.ROCP(df.close, timeperiod=10)
# ROCR - Rate of change ratio: (price/prevPrice)
# real = ROCR(df.close, timeperiod=10)
dfa["ROCR"] = ta.ROCR(df.close, timeperiod=10)
# ROCR100 - Rate of change ratio 100 scale: (price/prevPrice)*100
# real = ROCR100(df.close, timeperiod=10)
dfa["ROCR100"] = ta.ROCR100(df.close, timeperiod=10)
# RSI - Relative Strength Index 相对强弱指数
# 函数名：RSI
# 名称：相对强弱指数
# 简介：是通过比较一段时期内的平均收盘涨数和平均收盘跌数来分析市场买沽盘的
# 意向和实力，从而作出未来市场的走势。
# NOTE: The RSI function has an unstable period.
# real = RSI(df.close, timeperiod=14)
dfa["RSI"] = ta.RSI(df.close, timeperiod=14)
# STOCH - Stochastic 随机指标,俗称KD
# 函数名：STOCH
# 名称：随机指标,俗称KD
# slowk, slowd = STOCH(df.high, df.low, df.close, fastk_period=5,
# slowk_period=3, slowk_matype=0, slowd_period=3,
# slowd_matype=0)
dfa["STOCH_slowk"], dfa["STOCH_slowd"] = ta.STOCH(df.high,
df.low,
df.close,
fastk_period=5,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
# STOCHF - Stochastic Fast
# fastk, fastd = STOCHF(df.high, df.low, df.close, fastk_period=5,
# fastd_period=3, fastd_matype=0)
dfa["STOCHF_fastk"], dfa["STOCHF_fastd"] = ta.STOCHF(df.high,
df.low,
df.close,
fastk_period=5,
fastd_period=3,
fastd_matype=0)
# STOCHRSI - Stochastic Relative Strength Index
# NOTE: The STOCHRSI function has an unstable period.
# fastk, fastd = STOCHRSI(df.close, timeperiod=14, fastk_period=5,
# fastd_period=3, fastd_matype=0)
dfa["STOCHRSI_fastk"], dfa["STOCHRSI_fastd"] = ta.STOCHRSI(df.close,
timeperiod=14,
fastk_period=5,
fastd_period=3,
fastd_matype=0)
# TRIX - 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA
# real = TRIX(df.close, timeperiod=30)
dfa["TRIX"] = ta.TRIX(df.close, timeperiod=30)
# ULTOSC - Ultimate Oscillator 终极波动指标
# 函数名：ULTOSC
# 名称：终极波动指标
# 简介：UOS是一种多方位功能的指标，除了趋势确认及超买超卖方面的作用之外，
# 它的“突破”讯号不仅可以提供最适当的交易时机之外，
# 更可以进一步加强指标的可靠度。
# 分析和应用：百度百科 同花顺学院
# real = ULTOSC(df.high, df.low, df.close, timeperiod1=7, timeperiod2=14,
# timeperiod3=28)
dfa["ULTOSC"] = ta.ULTOSC(df.high,
df.low,
df.close,
timeperiod1=7,
timeperiod2=14,
timeperiod3=28)
# WILLR - Williams' %R 威廉指标
# 函数名：WILLR
# 名称：威廉指标
# 简介：WMS表示的是市场处于超买还是超卖状态。
# 股票投资分析方法主要有如下三种：基本分析、技术分析、演化分析。
# 在实际应用中，它们既相互联系，又有重要区别。
# 分析和应用：百度百科 维基百科 同花顺学院
# real = WILLR(df.high, df.low, df.close, timeperiod=14)
dfa["WILLR"] = ta.WILLR(df.high, df.low, df.close, timeperiod=14)
# Statistic Functions 统计学指标
# BETA - Beta
# 函数名：BETA
# 名称：β系数也称为贝塔系数
# 简介：一种风险指数，用来衡量个别股票或股票基金相对于整个股市的价格波动情况
# 贝塔系数衡量股票收益相对于业绩评价基准收益的总体波动性，是一个相对指标。
# β 越高，意味着股票相对于业绩评价基准的波动性越大。
# β 大于 1 ， 则股票的波动性大于业绩评价基准的波动性。反之亦然。
# 用途：
# 1）计算资本成本，做出投资决策（只有回报率高于资本成本的项目才应投资）；
# 2）计算资本成本，制定业绩考核及激励标准；
# 3）计算资本成本，进行资产估值（Beta是现金流贴现模型的基础）；
# 4）确定单个资产或组合的系统风险，用于资产组合的投资管理，
# 特别是股指期货或其他金融衍生品的避险（或投机）
# real = BETA(df.high, df.low, timeperiod=5)
dfa["BETA"] = ta.BETA(df.high, df.low, timeperiod=5)
# CORREL - Pearson's Correlation Coefficient (r)
# 函数名：CORREL
# 名称：皮尔逊相关系数
# 简介：用于度量两个变量X和Y之间的相关（线性相关），其值介于-1与1之间
# 皮尔逊相关系数是一种度量两个变量间相关程度的方法。
# 它是一个介于 1 和 -1 之间的值，
# 其中，1 表示变量完全正相关， 0 表示无关，-1 表示完全负相关。
# real = CORREL(df.high, df.low, timeperiod=30)
dfa["CORREL"] = ta.CORREL(df.high, df.low, timeperiod=30)
# LINEARREG - Linear Regression
# 直线回归方程：当两个变量x与y之间达到显著地线性相关关系时,
# 应用最小二乘法原理确定一条最优直线的直线方程y=a+bx,
# 这条回归直线与个相关点的距离比任何其他直线与相关点的距离都小,
# 是最佳的理想直线. 回归截距a：表示直线在y轴上的截距,代表直线的起点.
# 回归系数b：表示直线的斜率,他的实际意义是说明x每变化一个单位时,
# 影响y平均变动的数量. 即x每增加1单位,y变化b个单位.
# 函数名：LINEARREG
# 名称：线性回归
# 简介：来确定两种或两种以上变量间相互依赖的定量关系的一种统计分析方法
# 其表达形式为y = w'x+e，e为误差服从均值为0的正态分布。
# real = LINEARREG(df.close, timeperiod=14)
dfa["LINEARREG"] = ta.LINEARREG(df.close, timeperiod=14)
# LINEARREG_ANGLE - Linear Regression Angle
# 函数名：LINEARREG_ANGLE
# 名称：线性回归的角度
# 简介：来确定价格的角度变化. 参考
# real = LINEARREG_ANGLE(df.close, timeperiod=14)
dfa["LINEARREG_ANGLE"] = ta.LINEARREG_ANGLE(df.close, timeperiod=14)
# LINEARREG_INTERCEPT - Linear Regression Intercept
# 函数名：LINEARREG_INTERCEPT
# 名称：线性回归截距
# real = LINEARREG_INTERCEPT(df.close, timeperiod=14)
dfa["LINEARREG_INTERCEPT"] = ta.LINEARREG_INTERCEPT(df.close,
timeperiod=14)
# LINEARREG_SLOPE - Linear Regression Slope
# 函数名：LINEARREG_SLOPE
# 名称：线性回归斜率指标
# real = LINEARREG_SLOPE(df.close, timeperiod=14)
dfa["LINEARREG_SLOPE"] = ta.LINEARREG_SLOPE(df.close, timeperiod=14)
# STDDEV - Standard Deviation
# 函数名：STDDEV
# 名称：标准偏差
# 简介：种量度数据分布的分散程度之标准，用以衡量数据值偏离算术平均值的程度。
# 标准偏差越小，这些值偏离平均值就越少，反之亦然。
# 标准偏差的大小可通过标准偏差与平均值的倍率关系来衡量。
# real = STDDEV(df.close, timeperiod=5, nbdev=1)
dfa["STDDEV"] = ta.STDDEV(df.close, timeperiod=5, nbdev=1)
# TSF - Time Series Forecast
# 函数名：TSF
# 名称：时间序列预测
# 简介：一种历史资料延伸预测，也称历史引伸预测法。
# 是以时间数列所能反映的社会经济现象的发展过程和规律性，
# 进行引伸外推，预测其发展趋势的方法
# real = TSF(df.close, timeperiod=14)
dfa["TSF"] = ta.TSF(df.close, timeperiod=14)
# VAR - VAR
# 函数名： VAR 名称：方差
# 简介：方差用来计算每一个变量（观察值）与总体均数之间的差异。
# 为避免出现离均差总和为零，离均差平方和受样本含量的影响，
# 统计学采用平均离均差平方和来描述变量的变异程度
# real = VAR(df.close, timeperiod=5, nbdev=1)
dfa["VAR"] = ta.VAR(df.close, timeperiod=5, nbdev=1)
return dfa
def get_talib_indicators(df, freq_lst=(5, 15, 30), divided_by_close=False):
"""
Additional indicators with different indicator parameters customized
:param df: pandas.DataFrame with {'open', 'close', 'high', 'low', 'volume'} and index == date
:return: pandas.DataFrame
"""
for n in freq_lst:
# Overlap Studies Functions
#BBANDS
df['BBANDS_' + str(n) + '_UP'], df['BBANDS_' + str(n) +
'_MID'], df['BBANDS_' + str(n) +
'_LOW'] = ta.BBANDS(
df.close,
timeperiod=n,
nbdevup=2,
nbdevdn=2,
matype=0)
#DEMA
df['DEMA' + str(n)] = ta.DEMA(df.close, timeperiod=n)
#EMA
df['EMA' + str(n)] = ta.EMA(df.close, timeperiod=n)
#KAMA
df['KAMA' + str(n)] = ta.KAMA(df.close, timeperiod=n)
#MA
df['MA' + str(n)] = ta.MA(df.close, timeperiod=n)
#MAMA(ERROR)
#df['MAMA' + str(n)] = ta.MAMA(df.close, fastlimit=0, slowlimit=0)
#MAVP(periods 参数暂时无法确定)
#df['' + str(n)] = ta.MAVP(df.close, periods, minperiod=2, maxperiod=30, matype=0)
#MIDPOINT
df['MIDPOINT' + str(n)] = ta.MIDPOINT(df.close, timeperiod=n)
#MIDPRICE
df['MIDPRICE' + str(n)] = ta.MIDPRICE(df.high, df.low, timeperiod=n)
#SAR
df['SAR' + str(n)] = ta.SAR(df.high, df.low, acceleration=0, maximum=0)
#SAREXT（参数太多，暂时无法知道如何设置）
#df['SAREXT' + str(n)] = ta.SAREXT(df.high, df.low, startvalue=0, offsetonreverse=0, accelerationinitlong=0, accelerationlong=0, accelerationmaxlong=0, accelerationinitshort=0, accelerationshort=0, accelerationmaxshort=0)
#SMA
df['SMA' + str(n)] = ta.SMA(df.close, timeperiod=n)
#T3
df['T3' + str(n)] = ta.T3(df.close, timeperiod=n, vfactor=0.7)
#TEMA
df['TEMA' + str(n)] = ta.TEMA(df.close, timeperiod=n)
#TRIMA
df['TRIMA' + str(n)] = ta.TRIMA(df.close, timeperiod=n)
#WMA
df['WMA' + str(n)] = ta.WMA(df.close, timeperiod=n)
#Momentum Indicator Functions
#ADX
df['ADX' + str(n)] = ta.ADX(df.high, df.low, df.close, timeperiod=n)
#ADXR
df['ADXR' + str(n)] = ta.ADXR(df.high, df.low, df.close, timeperiod=n)
#APO
df['APO' + str(n)] = ta.APO(df.close,
fastperiod=12,
slowperiod=26,
matype=0)
#AROON
df['AROON_DOWN_' + str(n)], df['AROON_UP_' + str(n)] = ta.AROON(
df.high, df.low, timeperiod=n)
#AROONOSC
df['AROONOSC' + str(n)] = ta.AROONOSC(df.high, df.low, timeperiod=n)
#CCI
df['CCI' + str(n)] = ta.CCI(df.high, df.low, df.close, timeperiod=n)
#CMO
df['CMO' + str(n)] = ta.CMO(df.close, timeperiod=n)
#DX
df['DX' + str(n)] = ta.DX(df.high, df.low, df.close, timeperiod=n)
#MFI
df['MFI' + str(n)] = ta.MFI(df.high,
df.low,
df.close,
df.volume,
timeperiod=n)
#MINUS_DI
df['MINUS_DI' + str(n)] = ta.MINUS_DI(df.high,
df.low,
df.close,
timeperiod=n)
#MINUS_DM
df['MINUS_DM' + str(n)] = ta.MINUS_DM(df.high, df.low, timeperiod=n)
#MOM
df['MOM' + str(n)] = ta.MOM(df.close, timeperiod=n)
#PLUS_DI
df['PLUS_DI' + str(n)] = ta.PLUS_DI(df.high,
df.low,
df.close,
timeperiod=n)
#PLUS_DM
df['PLUS_DM' + str(n)] = ta.PLUS_DM(df.high, df.low, timeperiod=n)
#ROC
df['ROC' + str(n)] = ta.ROC(df.close, timeperiod=n)
#ROCP
df['ROCP' + str(n)] = ta.ROCP(df.close, timeperiod=n)
#ROCR
df['ROCR' + str(n)] = ta.ROCR(df.close, timeperiod=n)
#ROCR100
df['ROCR100_' + str(n)] = ta.ROCR100(df.close, timeperiod=n)
#RSI
df['RSI' + str(n)] = ta.RSI(df.close, timeperiod=n)
#TRIX
df['TRIX' + str(n)] = ta.TRIX(df.close, timeperiod=n)
#WILLR
df['WILLR' + str(n)] = ta.WILLR(df.high,
df.low,
df.close,
timeperiod=n)
#Volatility Indicator Functions
#ATR
df['ATR' + str(n)] = ta.ATR(df.high, df.low, df.close, timeperiod=n)
#NATR
df['NATR' + str(n)] = ta.NATR(df.high, df.low, df.close, timeperiod=n)
# Statistic Functions
#BETA
df['BETA' + str(n)] = ta.BETA(df.high, df.low, timeperiod=n)
#CORREL
df['CORREL' + str(n)] = ta.CORREL(df.high, df.low, timeperiod=n)
#LINEARREG
df['LINEARREG' + str(n)] = ta.LINEARREG(df.close, timeperiod=n)
#LINEARREG_ANGLE
df['LINEARREG_ANGLE' + str(n)] = ta.LINEARREG_ANGLE(df.close,
timeperiod=n)
#LINEARREG_INTERCEPT
df['LINEARREG_INTERCEPT' + str(n)] = ta.LINEARREG_INTERCEPT(
df.close, timeperiod=n)
#LINEARREG_SLOPE
df['LINEARREG_SLOPE' + str(n)] = ta.LINEARREG_SLOPE(df.close,
timeperiod=n)
#STDDEV
df['STDDEV' + str(n)] = ta.STDDEV(df.close, timeperiod=n, nbdev=1)
#TSF
df['TSF' + str(n)] = ta.TSF(df.close, timeperiod=n)
#VAR
df['VAR' + str(n)] = ta.VAR(df.close, timeperiod=n, nbdev=1)
# Math Operator Functions
#MAX
df['MAX' + str(n)] = ta.MAX(df.close, timeperiod=n)
#MAXINDEX
#df['MAXINDEX' + str(n)] = ta.MAXINDEX(df.close, timeperiod=n)
#MIN
df['MIN' + str(n)] = ta.MIN(df.close, timeperiod=n)
#MININDEX
#df['MININDEX' + str(n)] = ta.MININDEX(df.close, timeperiod=n)
#SUM
#df['SUM' + str(n)] = ta.SUM(df.close, timeperiod=n)
# HT_TRENDLINE
df['HT_TRENDLINE'] = ta.HT_TRENDLINE(df.close)
# BOP
df['BOP'] = ta.BOP(df.open, df.high, df.low, df.close)
# MACD
df['MACD'], df['MACD_SIGNAL'], df['MACD_HIST'] = ta.MACD(df.close,
fastperiod=12,
slowperiod=26,
signalperiod=9)
# STOCH
df['slowk'], df['slowd'] = ta.STOCH(df.high,
df.low,
df.close,
fastk_period=5,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
# STOCHF
df['fsatk'], df['fastd'] = ta.STOCHF(df.high,
df.low,
df.close,
fastk_period=5,
fastd_period=3,
fastd_matype=0)
# STOCHRSI
df['fsatk_RSI'], df['fastd_RSI'] = ta.STOCHRSI(df.close,
timeperiod=n,
fastk_period=5,
fastd_period=3,
fastd_matype=0)
# PPO
df['PPO'] = ta.PPO(df.close, fastperiod=12, slowperiod=26, matype=0)
# ULTOSC
df['ULTOSC'] = ta.ULTOSC(df.high,
df.low,
df.close,
timeperiod1=7,
timeperiod2=14,
timeperiod3=28)
# Volume Indicator Functions
# AD
#df['AD'] = ta.AD(df.high, df.low, df.close, df.volume)
# ADOSC
#df['ADOSC'] = ta.ADOSC(df.high, df.low, df.close, df.volume, fastperiod=3, slowperiod=10)
# OBV
# OBV is too large
#df['OBV'] = ta.OBV(df.close, df.volume)
# TRANGE
df['TRANGE'] = ta.TRANGE(df.high, df.low, df.close)
# Price Indicator Functions
# AVGPRICE
df['AVGPRICE'] = ta.AVGPRICE(df.open, df.high, df.low, df.close)
# MEDPRICE
df['MEDPRICE'] = ta.MEDPRICE(df.high, df.low)
# TYPPRICE
df['TYPPRICE'] = ta.TYPPRICE(df.high, df.low, df.close)
# WCLPRICE
df['WCLPRICE'] = ta.WCLPRICE(df.high, df.low, df.close)
# Cycle Indicator Functions
# HT_DCPERIOD
df['HT_DCPERIOD'] = ta.HT_DCPERIOD(df.close)
# HT_DCPHASE
df['HT_DCPHASE'] = ta.HT_DCPHASE(df.close)
# HT_PHASOR
df['HT_PHASOR_inphase'], df['HT_PHASOR_quadrature'] = ta.HT_PHASOR(
df.close)
# HT_SINE
df['HT_SINE_sine'], df['HT_SINE_leadsine'] = ta.HT_SINE(df.close)
# HT_TRENDMODE
df['HT_TRENDMODE'] = ta.HT_TRENDMODE(df.close)
#Indicators regardless of time_period
#Pattern Recognition Functions
#CDL2CROWS
'''df['CDL2CROWS'] = ta.CDL2CROWS(df.open, df.high, df.low, df.close)
# CDL3BLACKCROWS
df['CDL3BLACKCROWS'] = ta.CDL3BLACKCROWS(df.open, df.high, df.low, df.close)
# CDL3INSIDE
df['CDL3INSIDE'] = ta.CDL3INSIDE(df.open, df.high, df.low, df.close)
# CDL3LINESTRIKE
df['CDL3LINESTRIKE'] = ta.CDL3LINESTRIKE(df.open, df.high, df.low, df.close)
# CDL3OUTSIDE
df['CDL3OUTSIDE'] = ta.CDL3OUTSIDE(df.open, df.high, df.low, df.close)
# CDL3STARSINSOUTH
df['CDL3STARSINSOUTH'] = ta.CDL3STARSINSOUTH(df.open, df.high, df.low, df.close)
# CDL3WHITESOLDIERS
df['CDL3WHITESOLDIERS'] = ta.CDL3WHITESOLDIERS(df.open, df.high, df.low, df.close)
# CDLABANDONEDBABY
df['CDLABANDONEDBABY'] = ta.CDLABANDONEDBABY(df.open, df.high, df.low, df.close, penetration=0)
# CDLADVANCEBLOCK
df['CDLADVANCEBLOCK'] = ta.CDLADVANCEBLOCK(df.open, df.high, df.low, df.close)
# CDLBELTHOLD
df['CDLBELTHOLD'] = ta.CDLBELTHOLD(df.open, df.high, df.low, df.close)
# CDLBREAKAWAY
df['CDLBREAKAWAY'] = ta.CDLBREAKAWAY(df.open, df.high, df.low, df.close)
# CDLCLOSINGMARUBOZU
df['CDLCLOSINGMARUBOZU'] = ta.CDLCLOSINGMARUBOZU(df.open, df.high, df.low, df.close)
# CDLCONCEALBABYSWALL
df['CDLCONCEALBABYSWALL'] = ta.CDLCONCEALBABYSWALL(df.open, df.high, df.low, df.close)
# CDLCOUNTERATTACK
df['CDLCOUNTERATTACK'] = ta.CDLCOUNTERATTACK(df.open, df.high, df.low, df.close)
# CDLDARKCLOUDCOVER
df['CDLDARKCLOUDCOVER'] = ta.CDLDARKCLOUDCOVER(df.open, df.high, df.low, df.close, penetration=0)
# CDLDOJI
df['CDLDOJI'] = ta.CDLDOJI(df.open, df.high, df.low, df.close)
# CDLDOJISTAR
df['CDLDOJISTAR'] = ta.CDLDOJISTAR(df.open, df.high, df.low, df.close)
# CDLDRAGONFLYDOJI
df['CDLDRAGONFLYDOJI'] = ta.CDLDRAGONFLYDOJI(df.open, df.high, df.low, df.close)
# CDLENGULFING
df['CDLENGULFING'] = ta.CDLENGULFING(df.open, df.high, df.low, df.close)
# CDLEVENINGDOJISTAR
df['CDLEVENINGDOJISTAR'] = ta.CDLEVENINGDOJISTAR(df.open, df.high, df.low, df.close, penetration=0)
# CDLEVENINGSTAR
df['CDLEVENINGSTAR'] = ta.CDLEVENINGSTAR(df.open, df.high, df.low, df.close, penetration=0)
# CDLGAPSIDESIDEWHITE
df['CDLGAPSIDESIDEWHITE'] = ta.CDLGAPSIDESIDEWHITE(df.open, df.high, df.low, df.close)
# CDLGRAVESTONEDOJI
df['CDLGRAVESTONEDOJI'] = ta.CDLGRAVESTONEDOJI(df.open, df.high, df.low, df.close)
# CDLHAMMER
df['CDLHAMMER'] = ta.CDLHAMMER(df.open, df.high, df.low, df.close)
# CDLHANGINGMAN
df['CDLHANGINGMAN'] = ta.CDLHANGINGMAN(df.open, df.high, df.low, df.close)
# CDLHARAMI
df['CDLHARAMI'] = ta.CDLHARAMI(df.open, df.high, df.low, df.close)
# CDLHARAMICROSS
df['CDLHARAMICROSS'] = ta.CDLHARAMICROSS(df.open, df.high, df.low, df.close)
# CDLHIGHWAVE
df['CDLHIGHWAVE'] = ta.CDLHIGHWAVE(df.open, df.high, df.low, df.close)
# CDLHIKKAKE
df['CDLHIKKAKE'] = ta.CDLHIKKAKE(df.open, df.high, df.low, df.close)
# CDLHIKKAKEMOD
df['CDLHIKKAKEMOD'] = ta.CDLHIKKAKEMOD(df.open, df.high, df.low, df.close)
# CDLHOMINGPIGEON
df['CDLHOMINGPIGEON'] = ta.CDLHOMINGPIGEON(df.open, df.high, df.low, df.close)
# CDLIDENTICAL3CROWS
df['CDLIDENTICAL3CROWS'] = ta.CDLIDENTICAL3CROWS(df.open, df.high, df.low, df.close)
# CDLINNECK
df['CDLINNECK'] = ta.CDLINNECK(df.open, df.high, df.low, df.close)
# CDLINVERTEDHAMMER
df['CDLINVERTEDHAMMER'] = ta.CDLINVERTEDHAMMER(df.open, df.high, df.low, df.close)
# CDLKICKING
df['CDLKICKING'] = ta.CDLKICKING(df.open, df.high, df.low, df.close)
# CDLKICKINGBYLENGTH
df['CDLKICKINGBYLENGTH'] = ta.CDLKICKINGBYLENGTH(df.open, df.high, df.low, df.close)
# CDLLADDERBOTTOM
df['CDLLADDERBOTTOM'] = ta.CDLLADDERBOTTOM(df.open, df.high, df.low, df.close)
# CDLLONGLEGGEDDOJI
df['CDLLONGLEGGEDDOJI'] = ta.CDLLONGLEGGEDDOJI(df.open, df.high, df.low, df.close)
# CDLLONGLINE
df['CDLLONGLINE'] = ta.CDLLONGLINE(df.open, df.high, df.low, df.close)
# CDLMARUBOZU
df['CDLMARUBOZU'] = ta.CDLMARUBOZU(df.open, df.high, df.low, df.close)
# CDLMATCHINGLOW
df['CDLMATCHINGLOW'] = ta.CDLMATCHINGLOW(df.open, df.high, df.low, df.close)
# CDLMATHOLD
df['CDLMATHOLD'] = ta.CDLMATHOLD(df.open, df.high, df.low, df.close, penetration=0)
# CDLMORNINGDOJISTAR
df['CDLMORNINGDOJISTAR'] = ta.CDLMORNINGDOJISTAR(df.open, df.high, df.low, df.close, penetration=0)
# CDLMORNINGSTAR
df['CDLMORNINGSTAR'] = ta.CDLMORNINGSTAR(df.open, df.high, df.low, df.close, penetration=0)
# CDLONNECK
df['CDLONNECK'] = ta.CDLONNECK(df.open, df.high, df.low, df.close)
# CDLPIERCING
df['CDLPIERCING'] = ta.CDLPIERCING(df.open, df.high, df.low, df.close)
# CDLRICKSHAWMAN
df['CDLRICKSHAWMAN'] = ta.CDLRICKSHAWMAN(df.open, df.high, df.low, df.close)
# CDLRISEFALL3METHODS
df['CDLRISEFALL3METHODS'] = ta.CDLRISEFALL3METHODS(df.open, df.high, df.low, df.close)
# CDLSEPARATINGLINES
df['CDLSEPARATINGLINES'] = ta.CDLSEPARATINGLINES(df.open, df.high, df.low, df.close)
# CDLSHOOTINGSTAR
df['CDLSHOOTINGSTAR'] = ta.CDLSHOOTINGSTAR(df.open, df.high, df.low, df.close)
# CDLSHORTLINE
df['CDLSHORTLINE'] = ta.CDLSHORTLINE(df.open, df.high, df.low, df.close)
# CDLSPINNINGTOP
df['CDLSPINNINGTOP'] = ta.CDLSPINNINGTOP(df.open, df.high, df.low, df.close)
# CDLSTALLEDPATTERN
df['CDLSTALLEDPATTERN'] = ta.CDLSTALLEDPATTERN(df.open, df.high, df.low, df.close)
# CDLSTICKSANDWICH
df['CDLSTICKSANDWICH'] = ta.CDLSTICKSANDWICH(df.open, df.high, df.low, df.close)
# CDLTAKURI
df['CDLTAKURI'] = ta.CDLTAKURI(df.open, df.high, df.low, df.close)
# CDLTASUKIGAP
df['CDLTASUKIGAP'] = ta.CDLTASUKIGAP(df.open, df.high, df.low, df.close)
# CDLTHRUSTING
df['CDLTHRUSTING'] = ta.CDLTHRUSTING(df.open, df.high, df.low, df.close)
# CDLTRISTAR
df['CDLTRISTAR'] = ta.CDLTRISTAR(df.open, df.high, df.low, df.close)
# CDLUNIQUE3RIVER
df['CDLUNIQUE3RIVER'] = ta.CDLUNIQUE3RIVER(df.open, df.high, df.low, df.close)
# CDLUPSIDEGAP2CROWS
df['CDLUPSIDEGAP2CROWS'] = ta.CDLUPSIDEGAP2CROWS(df.open, df.high, df.low, df.close)
# CDLXSIDEGAP3METHODS
df['CDLXSIDEGAP3METHODS'] = ta.CDLXSIDEGAP3METHODS(df.open, df.high, df.low, df.close)'''
# Math Transform Functions
#ACOS
#df['ACOS'] = ta.ACOS(df.close)
#ASIN
#df['ASIN'] = ta.ASIN(df.close)
#ATAN
df['ATAN'] = ta.ATAN(df.close)
#CEIL
#df['CEIL'] = ta.CEIL(df.close)
#COS
df['COS'] = ta.COS(df.close)
#COSH
#df['COSH'] = ta.COSH(df.close)
#EXP
#df['EXP'] = ta.EXP(df.close)
#FLOOR
#df['FLOOR'] = ta.FLOOR(df.close)
#LN
df['LN'] = ta.LN(df.close)
#LOG10
df['LOG10'] = ta.LOG10(df.close)
#SIN
df['SIN'] = ta.SIN(df.close)
#SINH
#df['SINH'] = ta.SINH(df.close)
#SQRT
df['SQRT'] = ta.SQRT(df.close)
#TAN
df['TAN'] = ta.TAN(df.close)
#TANH
df['TANH'] = ta.TANH(df.close)
# Math Operator Functions
# ADD
#df['ADD'] = ta.ADD(df.high, df.low)
# DIV
#df['DIV'] = ta.DIV(df.high, df.low)
# MULT
#df['MULT'] = ta.MULT(df.high, df.low)
# ADD
#df['SUB'] = ta.SUB(df.high, df.low)
if divided_by_close:
bias = 1
df['BBANDS_5_UP'] = df['BBANDS_5_UP'] / df.close - bias
df['BBANDS_5_MID'] = df['BBANDS_5_MID'] / df.close - bias
df['BBANDS_5_LOW'] = df['BBANDS_5_LOW'] / df.close - bias
df['DEMA5'] = df['DEMA5'] / df.close - bias
df['EMA5'] = df['EMA5'] / df.close - bias
df['KAMA5'] = df['KAMA5'] / df.close - bias
df['MA5'] = df['MA5'] / df.close - bias
df['MIDPOINT5'] = df['MIDPOINT5'] / df.close - bias
df['MIDPRICE5'] = df['MIDPRICE5'] / df.close - bias
df['SMA5'] = df['SMA5'] / df.close - bias
df['T35'] = df['T35'] / df.close - bias
df['TEMA5'] = df['TEMA5'] / df.close - bias
df['TRIMA5'] = df['TRIMA5'] / df.close - bias
df['WMA5'] = df['WMA5'] / df.close - bias
df['LINEARREG5'] = df['LINEARREG5'] / df.close - bias
df['LINEARREG_INTERCEPT5'] = df[
'LINEARREG_INTERCEPT5'] / df.close - bias
df['TSF5'] = df['TSF5'] / df.close - bias
df['MAX5'] = df['MAX5'] / df.close - bias
df['MIN5'] = df['MIN5'] / df.close - bias
df['BBANDS_15_UP'] = df['BBANDS_15_UP'] / df.close - bias
df['BBANDS_15_MID'] = df['BBANDS_15_MID'] / df.close - bias
df['BBANDS_15_LOW'] = df['BBANDS_15_LOW'] / df.close - bias
df['DEMA15'] = df['DEMA15'] / df.close - bias
df['EMA15'] = df['EMA15'] / df.close - bias
df['KAMA15'] = df['KAMA15'] / df.close - bias
df['MA15'] = df['MA15'] / df.close - bias
df['MIDPOINT15'] = df['MIDPOINT15'] / df.close - bias
df['MIDPRICE15'] = df['MIDPRICE15'] / df.close - bias
df['SMA15'] = df['SMA15'] / df.close - bias
df['T315'] = df['T315'] / df.close - bias
df['TEMA15'] = df['TEMA15'] / df.close - bias
df['TRIMA15'] = df['TRIMA15'] / df.close - bias
df['WMA15'] = df['WMA15'] / df.close - bias
df['LINEARREG15'] = df['LINEARREG15'] / df.close - bias
df['LINEARREG_INTERCEPT15'] = df[
'LINEARREG_INTERCEPT15'] / df.close - bias
df['TSF15'] = df['TSF15'] / df.close - bias
df['MAX15'] = df['MAX15'] / df.close - bias
df['MIN15'] = df['MIN15'] / df.close - bias
df['BBANDS_30_UP'] = df['BBANDS_30_UP'] / df.close - bias
df['BBANDS_30_MID'] = df['BBANDS_30_MID'] / df.close - bias
df['BBANDS_30_LOW'] = df['BBANDS_30_LOW'] / df.close - bias
df['DEMA30'] = df['DEMA30'] / df.close - bias
df['EMA30'] = df['EMA30'] / df.close - bias
df['KAMA30'] = df['KAMA30'] / df.close - bias
df['MA30'] = df['MA30'] / df.close - bias
df['MIDPOINT30'] = df['MIDPOINT30'] / df.close - bias
df['MIDPRICE30'] = df['MIDPRICE30'] / df.close - bias
df['SMA30'] = df['SMA30'] / df.close - bias
df['T330'] = df['T330'] / df.close - bias
df['TEMA30'] = df['TEMA30'] / df.close - bias
df['TRIMA30'] = df['TRIMA30'] / df.close - bias
df['WMA30'] = df['WMA30'] / df.close - bias
df['LINEARREG_INTERCEPT30'] = df[
'LINEARREG_INTERCEPT30'] / df.close - bias
df['TSF30'] = df['TSF30'] / df.close - bias
df['MAX30'] = df['MAX30'] / df.close - bias
df['MIN30'] = df['MIN30'] / df.close - bias
df['HT_TRENDLINE'] = df['HT_TRENDLINE'] / df.close - bias
df['AVGPRICE'] = df['AVGPRICE'] / df.close - bias
df['MEDPRICE'] = df['MEDPRICE'] / df.close - bias
df['TYPPRICE'] = df['TYPPRICE'] / df.close - bias
df['WCLPRICE'] = df['WCLPRICE'] / df.close - bias
df['open'] = df['open'] / df.close - bias
df['high'] = df['high'] / df.close - bias
df['low'] = df['low'] / df.close - bias
def double_ema(close, n):
try:
dema_data = talib.DEMA(close, n)
return dema_data
except Exception as e:
raise (e)
def calc_dema(cls, term, close):
return list(ta.DEMA(np.array(close, dtype='f8'), timeperiod=term))
def lista_de_indicadores(self):
df_num = self.data['stock']
date = self.data['date']
time = self.data['time']
oopen = self.data['open']
high = self.data['high']
low = self.data['low']
close = self.data['close']
volume = self.data['volume']
frame = {
'DATE_{}'.format(df_num): date,
'TIME_{}'.format(df_num): time,
'OPEN_{}'.format(df_num): oopen,
'HIGH_{}'.format(df_num): high,
'LOW_{}'.format(df_num): low,
'CLOSE_{}'.format(df_num): close,
'VOL_{}'.format(df_num): volume
}
# Cria um DataFrame usando o frame com nome da coluna seguido dos dados
dataframe = pd.DataFrame(frame)
#############################
# Overlap Studies Functions #
#############################
##### BBANDS - Bollinger Bands - 5 / 10 / 20 -----------------------------------------------
upper5, _, lower5 = talib.BBANDS(self.data['close'], 5)
upper10, _, lower10 = talib.BBANDS(self.data['close'], 10)
upper20, _, lower20 = talib.BBANDS(self.data['close'], 20)
dataframe['BBANDS_Upper_5_{}'.format(df_num)] = pd.Series(upper5)
dataframe['BBANDS_Lower_5_{}'.format(df_num)] = pd.Series(lower5)
dataframe['BBANDS_Upper_10_{}'.format(df_num)] = pd.Series(upper10)
dataframe['BBANDS_Lower_10_{}'.format(df_num)] = pd.Series(lower10)
dataframe['BBANDS_Upper_20_{}'.format(df_num)] = pd.Series(upper20)
dataframe['BBANDS_Lower_20_{}'.format(df_num)] = pd.Series(lower20)
##### DEMA - Double Exponential Moving Average - 10 ----------------------------------------
dema = talib.DEMA(self.data['close'], timeperiod=10)
# Adiciona um Series à direita de um DataFrame
dataframe['DEMA_20_{}'.format(df_num)] = pd.Series(dema)
##### EMA - Exponential Moving Average - 20 ------------------------------------------------
ema = talib.EMA(self.data['close'], timeperiod=20)
dataframe['EMA_20_{}'.format(df_num)] = pd.Series(ema)
# ##### KAMA - Kaufman Adaptive Moving Average - 5/10/20 -------------------------------------
# kama5 = talib.KAMA(close, timeperiod=5)
# kama10 = talib.KAMA(close, timeperiod=10)
# kama20 = talib.KAMA(close, timeperiod=20)
# dataframe['KAMA_5'] = pd.Series(kama5)
# dataframe['KAMA_10'] = pd.Series(kama10)
# dataframe['KAMA_20'] = pd.Series(kama20)
##### MIDPOINT - MidPoint over period - 3/12 -----------------------------------------------
midpoint3 = talib.MIDPOINT(close, timeperiod=3)
midpoint12 = talib.MIDPOINT(close, timeperiod=12)
dataframe['MIDPOINT_3_{}'.format(df_num)] = pd.Series(midpoint3)
dataframe['MIDPOINT_12_{}'.format(df_num)] = pd.Series(midpoint12)
##### MIDPRICE - Midpoint Price over period - 3/12 -----------------------------------------
midprice3 = talib.MIDPRICE(high, low, timeperiod=3)
midprice12 = talib.MIDPRICE(high, low, timeperiod=12)
dataframe['MIDPRICE_3_{}'.format(df_num)] = pd.Series(midprice3)
dataframe['MIDPRICE_12_{}'.format(df_num)] = pd.Series(midprice12)
##### SAR - Parabolic SAR - 0.02/0.06/0.10/0.14/0.18 ---------------------------------------
sar2 = talib.SAR(high, low, acceleration=0.02)
sar6 = talib.SAR(high, low, acceleration=0.06)
sar10 = talib.SAR(high, low, acceleration=0.10)
sar14 = talib.SAR(high, low, acceleration=0.14)
sar18 = talib.SAR(high, low, acceleration=0.18)
dataframe['SAR_2_{}'.format(df_num)] = pd.Series(sar2)
dataframe['SAR_6_{}'.format(df_num)] = pd.Series(sar6)
dataframe['SAR_10_{}'.format(df_num)] = pd.Series(sar10)
dataframe['SAR_14_{}'.format(df_num)] = pd.Series(sar14)
dataframe['SAR_18_{}'.format(df_num)] = pd.Series(sar18)
##### TEMA - Triple Exponential Moving Average - 5 -----------------------------------------
tema5 = talib.TEMA(close, timeperiod=5)
dataframe['TEMA_5_{}'.format(df_num)] = pd.Series(tema5)
##### TRIMA - Triangular Moving Average - 5/10/20 ------------------------------------------
trima5 = talib.TRIMA(close, timeperiod=5)
trima10 = talib.TRIMA(close, timeperiod=10)
trima20 = talib.TRIMA(close, timeperiod=20)
dataframe['TRIMA_5_{}'.format(df_num)] = pd.Series(trima5)
dataframe['TRIMA_10_{}'.format(df_num)] = pd.Series(trima10)
dataframe['TRIMA_20_{}'.format(df_num)] = pd.Series(trima20)
##### WMA - Weighted Moving Average - 5/10/20 ----------------------------------------------
wma5 = talib.WMA(close, timeperiod=5)
wma10 = talib.WMA(close, timeperiod=10)
wma20 = talib.WMA(close, timeperiod=20)
dataframe['WMA_5_{}'.format(df_num)] = pd.Series(wma5)
dataframe['WMA_10_{}'.format(df_num)] = pd.Series(wma10)
dataframe['WMA_20_{}'.format(df_num)] = pd.Series(wma20)
################################
# Momentum Indicator Functions #
################################
##### ADX - Average Directional Movement Index 3/6/10 --------------------------------------
adx3 = talib.ADX(high, low, close, timeperiod=3)
adx6 = talib.ADX(high, low, close, timeperiod=6)
adx10 = talib.ADX(high, low, close, timeperiod=10)
dataframe['ADX_3_{}'.format(df_num)] = pd.Series(adx3)
dataframe['ADX_6_{}'.format(df_num)] = pd.Series(adx6)
dataframe['ADX_10_{}'.format(df_num)] = pd.Series(adx10)
# ##### ADXR - Average Directional Movement Index Rating 3/6 ---------------------------------
# adxr3 = talib.ADXR(high, low, close, timeperiod=3)
# adxr6 = talib.ADXR(high, low, close, timeperiod=6)
# dataframe['ADXR_3'] = pd.Series(adxr3)
# dataframe['ADXR_6'] = pd.Series(adxr6)
##### APO - Absolute Price Oscillator 3-12/5-12 --------------------------------------------
apo3_12 = talib.APO(close, fastperiod=3, slowperiod=12, matype=0)
apo5_12 = talib.APO(close, fastperiod=5, slowperiod=12, matype=0)
dataframe['APO_3_12_{}'.format(df_num)] = pd.Series(apo3_12)
dataframe['APO_5_12_{}'.format(df_num)] = pd.Series(apo5_12)
# ##### AROONOSC - Aroon Oscillator 3/6/12 ---------------------------------------------------
# aroonosc3 = talib.AROONOSC(high, low, timeperiod=3)
# aroonosc6 = talib.AROONOSC(high, low, timeperiod=6)
# aroonosc12 = talib.AROONOSC(high, low, timeperiod=12)
# dataframe['AROONOSC_3'] = pd.Series(aroonosc3)
# dataframe['AROONOSC_6'] = pd.Series(aroonosc6)
# dataframe['AROONOSC_12'] = pd.Series(aroonosc12)
##### BOP - Balance Of Power
bop = talib.BOP(oopen, high, low, close)
dataframe['BOP_{}'.format(df_num)] = pd.Series(bop)
##### CCI - Commodity Channel Index 3/6/12/20 ----------------------------------------------
cci3 = talib.CCI(high, low, close, timeperiod=3)
cci6 = talib.CCI(high, low, close, timeperiod=6)
cci12 = talib.CCI(high, low, close, timeperiod=12)
cci20 = talib.CCI(high, low, close, timeperiod=20)
dataframe['CCI_3_{}'.format(df_num)] = pd.Series(cci3)
dataframe['CCI_6_{}'.format(df_num)] = pd.Series(cci6)
dataframe['CCI_12_{}'.format(df_num)] = pd.Series(cci12)
dataframe['CCI_20_{}'.format(df_num)] = pd.Series(cci20)
##### CMO - Chande Momentum Oscillator 3/6/12/20 -------------------------------------------
# cmo3 = talib.CMO(close, timeperiod=3)
# cmo6 = talib.CMO(close, timeperiod=6)
# cmo12 = talib.CMO(close, timeperiod=12)
# cmo20 = talib.CMO(close, timeperiod=20)
# dataframe['CMO_3'] = pd.Series(cmo3)
# dataframe['CMO_6'] = pd.Series(cmo6)
# dataframe['CMO_12'] = pd.Series(cmo12)
# dataframe['CMO_20'] = pd.Series(cmo20)
# ##### DX - Directional Movement Index 3/6/12/20 --------------------------------------------
# dx3 = talib.DX(high, low, close, timeperiod=3)
# dx6 = talib.DX(high, low, close, timeperiod=6)
# dx12 = talib.DX(high, low, close, timeperiod=12)
# dx20 = talib.DX(high, low, close, timeperiod=20)
# dataframe['DX_3'] = pd.Series(dx3)
# dataframe['DX_6'] = pd.Series(dx6)
# dataframe['DX_12'] = pd.Series(dx12)
# dataframe['DX_20'] = pd.Series(dx20)
##### MFI - Money Flow Index 3/6/12 --------------------------------------------------------
mfi3 = talib.MFI(high, low, close, volume, timeperiod=3)
mfi6 = talib.MFI(high, low, close, volume, timeperiod=6)
mfi12 = talib.MFI(high, low, close, volume, timeperiod=12)
dataframe['MFI_3_{}'.format(df_num)] = pd.Series(mfi3)
dataframe['MFI_6_{}'.format(df_num)] = pd.Series(mfi6)
dataframe['MFI_12_{}'.format(df_num)] = pd.Series(mfi12)
# ##### MINUS_DI - Minus Directional Indicator 3/6/12/20 -------------------------------------
# minusdi3 = talib.MINUS_DI(high, low, close, timeperiod=3)
# minusdi6 = talib.MINUS_DI(high, low, close, timeperiod=6)
# minusdi12 = talib.MINUS_DI(high, low, close, timeperiod=12)
# minusdi20 = talib.MINUS_DI(high, low, close, timeperiod=20)
# dataframe['MINUS_DI_3'] = pd.Series(minusdi3)
# dataframe['MINUS_DI_6'] = pd.Series(minusdi6)
# dataframe['MINUS_DI_12'] = pd.Series(minusdi12)
# dataframe['MINUS_DI_20'] = pd.Series(minusdi20)
# ##### MINUS_DM - Minus Directional Movement 3/6/12/20 --------------------------------------
# minusdm3 = talib.MINUS_DM(high, low, timeperiod=3)
# minusdm6 = talib.MINUS_DM(high, low, timeperiod=6)
# minusdm12 = talib.MINUS_DM(high, low, timeperiod=12)
# minusdm20 = talib.MINUS_DM(high, low, timeperiod=20)
# dataframe['MINUS_DM_3'] = pd.Series(minusdm3)
# dataframe['MINUS_DM_6'] = pd.Series(minusdm6)
# dataframe['MINUS_DM_12'] = pd.Series(minusdm12)
# dataframe['MINUS_DM_20'] = pd.Series(minusdm20)
##### MOM - Momentum 3/6/10/14 -------------------------------------------------------------
mom3 = talib.MOM(close, timeperiod=3)
mom6 = talib.MOM(close, timeperiod=6)
mom10 = talib.MOM(close, timeperiod=10)
mom14 = talib.MOM(close, timeperiod=14)
dataframe['MOM_3_{}'.format(df_num)] = pd.Series(mom3)
dataframe['MOM_6_{}'.format(df_num)] = pd.Series(mom6)
dataframe['MOM_10_{}'.format(df_num)] = pd.Series(mom10)
dataframe['MOM_14_{}'.format(df_num)] = pd.Series(mom14)
# ##### PLUS_DI - Plus Directional Indicator 3/6/12/20 ---------------------------------------
# plusdi3 = talib.PLUS_DI(high, low, close, timeperiod=3)
# plusdi6 = talib.PLUS_DI(high, low, close, timeperiod=6)
# plusdi12 = talib.PLUS_DI(high, low, close, timeperiod=12)
# plusdi20 = talib.PLUS_DI(high, low, close, timeperiod=20)
# dataframe['PLUS_DI_3'] = pd.Series(plusdi3)
# dataframe['PLUS_DI_6'] = pd.Series(plusdi6)
# dataframe['PLUS_DI_12'] = pd.Series(plusdi12)
# dataframe['PLUS_DI_20'] = pd.Series(plusdi20)
# ##### PLUS_DM - Plus Directional Movement 3/6/12/20 ----------------------------------------
# plusdm3 = talib.PLUS_DM(high, low, timeperiod=3)
# plusdm6 = talib.PLUS_DM(high, low, timeperiod=6)
# plusdm12 = talib.PLUS_DM(high, low, timeperiod=12)
# plusdm20 = talib.PLUS_DM(high, low, timeperiod=20)
# dataframe['PLUS_DM_3'] = pd.Series(plusdm3)
# dataframe['PLUS_DM_6'] = pd.Series(plusdm6)
# dataframe['PLUS_DM_12'] = pd.Series(plusdm12)
# dataframe['PLUS_DM_20'] = pd.Series(plusdm20)
##### PPO - Percentage Price Oscillator 3-12/12-20 -----------------------------------------
ppo3_12 = talib.PPO(close, fastperiod=3, slowperiod=12, matype=0)
ppo12_20 = talib.PPO(close, fastperiod=12, slowperiod=20, matype=0)
dataframe['PPO_3_12_{}'.format(df_num)] = pd.Series(ppo3_12)
dataframe['PPO_12_20_{}'.format(df_num)] = pd.Series(ppo12_20)
##### ROC - Rate of change : ((price/prevPrice)-1)*100 3/5/7/10 ----------------------------
roc3 = talib.ROC(close, timeperiod=3)
roc5 = talib.ROC(close, timeperiod=5)
roc7 = talib.ROC(close, timeperiod=7)
roc10 = talib.ROC(close, timeperiod=10)
dataframe['ROC_3_{}'.format(df_num)] = pd.Series(roc3)
dataframe['ROC_5_{}'.format(df_num)] = pd.Series(roc5)
dataframe['ROC_7_{}'.format(df_num)] = pd.Series(roc7)
dataframe['ROC_10_{}'.format(df_num)] = pd.Series(roc10)
# ##### ROCP - Rate of change Percentage: (price-prevPrice)/prevPrice 3/5/7/10 ---------------
# rocp3 = talib.ROCP(close, timeperiod=3)
# rocp5 = talib.ROCP(close, timeperiod=5)
# rocp7 = talib.ROCP(close, timeperiod=7)
# rocp10 = talib.ROCP(close, timeperiod=10)
# dataframe['ROCP_3'] = pd.Series(rocp3)
# dataframe['ROCP_5'] = pd.Series(rocp5)
# dataframe['ROCP_7'] = pd.Series(rocp7)
# dataframe['ROCP_10'] = pd.Series(rocp10)
# ##### ROCR - Rate of change ratio: (price/prevPrice) 3/5/7/10 ------------------------------
# rocr3 = talib.ROCR(close, timeperiod=3)
# rocr5 = talib.ROCR(close, timeperiod=5)
# rocr7 = talib.ROCR(close, timeperiod=7)
# rocr10 = talib.ROCR(close, timeperiod=10)
# dataframe['ROCR_3'] = pd.Series(rocr3)
# dataframe['ROCR_5'] = pd.Series(rocr5)
# dataframe['ROCR_7'] = pd.Series(rocr7)
# dataframe['ROCR_10'] = pd.Series(rocr10)
##### RSI - Relative Strength Index 3/6/10/14 ----------------------------------------------
rsi3 = talib.RSI(close, timeperiod=3)
rsi6 = talib.RSI(close, timeperiod=6)
rsi10 = talib.RSI(close, timeperiod=10)
rsi14 = talib.RSI(close, timeperiod=14)
dataframe['RSI_3_{}'.format(df_num)] = pd.Series(rsi3)
dataframe['RSI_6_{}'.format(df_num)] = pd.Series(rsi6)
dataframe['RSI_10_{}'.format(df_num)] = pd.Series(rsi10)
dataframe['RSI_14_{}'.format(df_num)] = pd.Series(rsi14)
##### TRIX - 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA 3/5/7 -----------------------
trix3 = talib.TRIX(close, timeperiod=3)
trix5 = talib.TRIX(close, timeperiod=5)
trix7 = talib.TRIX(close, timeperiod=7)
dataframe['TRIX_3_{}'.format(df_num)] = pd.Series(trix3)
dataframe['TRIX_5_{}'.format(df_num)] = pd.Series(trix5)
dataframe['TRIX_7_{}'.format(df_num)] = pd.Series(trix7)
# ##### ULTOSC - Ultimate Oscillator 3-6-12/5-10-20 ------------------------------------------
# ultosc3612 = talib.ULTOSC(high, low, close, timeperiod1=3, timeperiod2=6, timeperiod3=12)
# ultosc51020 = talib.ULTOSC(high, low, close, timeperiod1=5, timeperiod2=10, timeperiod3=20)
# dataframe['ULTOSC_3_6_12'] = pd.Series(ultosc3612)
# dataframe['ULTOSC_5_10_20'] = pd.Series(ultosc51020)
# ##### WILLR - Williams' %R 3/6/12/20 -------------------------------------------------------
# willr3 = talib.WILLR(high, low, close, timeperiod=3)
# willr6 = talib.WILLR(high, low, close, timeperiod=6)
# willr12 = talib.WILLR(high, low, close, timeperiod=12)
# willr20 = talib.WILLR(high, low, close, timeperiod=20)
# dataframe['WILLR_3'] = pd.Series(willr3)
# dataframe['WILLR_6'] = pd.Series(willr6)
# dataframe['WILLR_12'] = pd.Series(willr12)
# dataframe['WILLR_20'] = pd.Series(willr20)
'''
##### MACD - Moving Average Convergence/Divergence
macd, macdsignal, macdhist = talib.MACD(close, fastperiod=12, slowperiod=26, signalperiod=9)
##### MACDEXT - MACD with controllable MA type
macd, macdsignal, macdhist = MACDEXT(close, fastperiod=12, fastmatype=0, slowperiod=26, slowmatype=0, signalperiod=9, signalmatype=0)
##### MACDFIX - Moving Average Convergence/Divergence Fix 12/26
macd, macdsignal, macdhist = MACDFIX(close, signalperiod=9)
##### ROCR100 - Rate of change ratio 100 scale: (price/prevPrice)*100 3/5/7/10 -------------
rocr1003 = talib.ROCR100(close, timeperiod=3)
rocr1005 = talib.ROCR100(close, timeperiod=5)
rocr1007 = talib.ROCR100(close, timeperiod=7)
rocr10010 = talib.ROCR100(close, timeperiod=10)
dataframe['ROCR100_3'] = pd.Series(rocr1003)
dataframe['ROCR100_5'] = pd.Series(rocr1005)
dataframe['ROCR100_7'] = pd.Series(rocr1007)
dataframe['ROCR100_10'] = pd.Series(rocr10010)
##### STOCH - Stochastic
slowk, slowd = STOCH(high, low, close, fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0)
##### STOCHF - Stochastic Fast
fastk, fastd = STOCHF(high, low, close, fastk_period=5, fastd_period=3, fastd_matype=0)
##### STOCHRSI - Stochastic Relative Strength Index
fastk, fastd = STOCHRSI(close, timeperiod=14, fastk_period=5, fastd_period=3, fastd_matype=0)
'''
##############################
# Volume Indicator Functions #
##############################
##### AD - Chaikin A/D Line ----------------------------------------------------------------
ad = talib.AD(high, low, close, volume)
dataframe['AD_{}'.format(df_num)] = pd.Series(ad)
##### ADOSC - Chaikin A/D Oscillator -------------------------------------------------------
adosc = talib.ADOSC(high,
low,
close,
volume,
fastperiod=3,
slowperiod=12)
dataframe['ADOSC_{}'.format(df_num)] = pd.Series(adosc)
##### OBV - On Balance Volume --------------------------------------------------------------
obv = talib.OBV(close, volume)
dataframe['OBV_{}'.format(df_num)] = pd.Series(obv)
##################################
# Volatility Indicator Functions #
##################################
##### ATR - Average True Range 3/6/12/20 ---------------------------------------------------
atr3 = talib.ATR(high, low, close, timeperiod=3)
atr6 = talib.ATR(high, low, close, timeperiod=6)
atr12 = talib.ATR(high, low, close, timeperiod=12)
atr20 = talib.ATR(high, low, close, timeperiod=20)
dataframe['ATR_3_{}'.format(df_num)] = pd.Series(atr3)
dataframe['ATR_6_{}'.format(df_num)] = pd.Series(atr6)
dataframe['ATR_12_{}'.format(df_num)] = pd.Series(atr12)
dataframe['ATR_20_{}'.format(df_num)] = pd.Series(atr20)
##### TRANGE - True Range ------------------------------------------------------------------
trange = talib.TRANGE(high, low, close)
dataframe['TRANGE_{}'.format(df_num)] = pd.Series(trange)
return (dataframe)
def add_technical_indicators_with_intervals(df,
indicators=[],
intervals=[],
true_value=False,
verbose=False):
indicators_range = range(len(indicators)) if not verbose else tqdm(
range(len(indicators)))
for i in indicators_range:
indicator = indicators[i]
for interval in intervals:
# 1 SMA
if indicator == 'SMA':
if not true_value:
df["SMA_" + str(interval)] = df["Close"] - talib.SMA(
df["Close"], timeperiod=interval)
else:
df["SMA_" + str(interval)] = talib.SMA(df["Close"],
timeperiod=interval)
# 2 KAMA
if indicator == 'KAMA':
if not true_value:
df["KAMA_" + str(interval)] = df["Close"] - talib.KAMA(
df["Close"], timeperiod=interval)
else:
df["KAMA_" + str(interval)] = talib.KAMA(
df["Close"], timeperiod=interval)
# 3 MIDPRICE
if indicator == 'MIDPRICE':
if not true_value:
df["MIDPRICE_" +
str(interval)] = df["Close"] - talib.MIDPRICE(
df["High"], df["Low"], timeperiod=interval)
else:
df["MIDPRICE_" + str(interval)] = talib.MIDPRICE(
df["High"], df["Low"], timeperiod=interval)
# 4 MIDPOINT
if indicator == 'MIDPOINT':
if not true_value:
df["MIDPOINT_" +
str(interval)] = df["Close"] - talib.MIDPOINT(
df["Close"], timeperiod=interval)
else:
df["MIDPOINT_" + str(interval)] = talib.MIDPOINT(
df["Close"], timeperiod=interval)
# 5 EMA
if indicator == 'EMA':
if not true_value:
df["EMA_" + str(interval)] = df["Close"] - talib.EMA(
df["Close"], timeperiod=interval)
else:
df["EMA_" + str(interval)] = talib.EMA(df["Close"],
timeperiod=interval)
# 6 DEMA
if indicator == 'DEMA':
if not true_value:
df["DEMA_" + str(interval)] = df["Close"] - talib.DEMA(
df["Close"], timeperiod=interval)
else:
df["DEMA_" + str(interval)] = talib.DEMA(
df["Close"], timeperiod=interval)
# 7 TEMA
if indicator == 'TEMA':
if not true_value:
df["TEMA_" + str(interval)] = df["Close"] - talib.TEMA(
df["Close"], timeperiod=interval)
else:
df["TEMA_" + str(interval)] = talib.TEMA(
df["Close"], timeperiod=interval)
# 8 TRIMA
if indicator == 'TRIMA':
if not true_value:
df["TRIMA_" + str(interval)] = df["Close"] - talib.TRIMA(
df["Close"], timeperiod=interval)
else:
df["TRIMA_" + str(interval)] = talib.TRIMA(
df["Close"], timeperiod=interval)
# 9 WMA
if indicator == 'WMA':
if not true_value:
df["WMA_" + str(interval)] = df["Close"] - talib.WMA(
df["Close"], timeperiod=interval)
else:
df["WMA_" + str(interval)] = talib.WMA(df["Close"],
timeperiod=interval)
# 10 LINEARREG
if indicator == 'LINEARREG':
if not true_value:
df["LINEARREG_" +
str(interval)] = df["Close"] - talib.LINEARREG(
df["Close"], timeperiod=interval)
else:
df["LINEARREG_" + str(interval)] = talib.LINEARREG(
df["Close"], timeperiod=interval)
# 11 TSF
if indicator == 'TSF':
if not true_value:
df["TSF_" + str(interval)] = df["Close"] - talib.TSF(
df["Close"], timeperiod=interval)
else:
df["TSF_" + str(interval)] = talib.TSF(df["Close"],
timeperiod=interval)
# 12 SMAO
if indicator == 'SMAO':
if not true_value:
df["SMAO_" + str(interval)] = df["Close"] - talib.SMA(
df["Open"], timeperiod=interval)
else:
df["SMAO_" + str(interval)] = talib.SMA(
df["Open"], timeperiod=interval)
# 13 KAMAO
if indicator == 'KAMAO':
if not true_value:
df["KAMAO_" + str(interval)] = df["Close"] - talib.KAMA(
df["Open"], timeperiod=interval)
else:
df["KAMAO_" + str(interval)] = talib.KAMA(
df["Open"], timeperiod=interval)
# 14 MIDPOINTO
if indicator == 'MIDPOINTO':
if not true_value:
df["MIDPOINTO_" +
str(interval)] = df["Close"] - talib.MIDPOINT(
df["Open"], timeperiod=interval)
else:
df["MIDPOINTO_" + str(interval)] = talib.MIDPOINT(
df["Open"], timeperiod=interval)
# 15 EMAO
if indicator == 'EMAO':
if not true_value:
df["EMAO_" + str(interval)] = df["Close"] - talib.EMA(
df["Open"], timeperiod=interval)
else:
df["EMAO_" + str(interval)] = talib.EMA(
df["Open"], timeperiod=interval)
# 16 DEMAO
if indicator == 'DEMAO':
if not true_value:
df["DEMAO_" + str(interval)] = df["Close"] - talib.DEMA(
df["Open"], timeperiod=interval)
else:
df["DEMAO_" + str(interval)] = talib.DEMA(
df["Open"], timeperiod=interval)
# 17 TEMAO
if indicator == 'TEMAO':
if not true_value:
df["TEMAO_" + str(interval)] = df["Close"] - talib.TEMA(
df["Open"], timeperiod=interval)
else:
df["TEMAO_" + str(interval)] = talib.TEMA(
df["Open"], timeperiod=interval)
# 18 TRIMAO
if indicator == 'TRIMAO':
if not true_value:
df["TRIMAO_" + str(interval)] = df["Close"] - talib.TRIMA(
df["Open"], timeperiod=interval)
else:
df["TRIMAO_" + str(interval)] = talib.TRIMA(
df["Open"], timeperiod=interval)
# 19 WMAO
if indicator == 'WMAO':
if not true_value:
df["WMAO_" + str(interval)] = df["Close"] - talib.WMA(
df["Open"], timeperiod=interval)
else:
df["WMAO_" + str(interval)] = talib.WMA(
df["Open"], timeperiod=interval)
# 20 LINEARREGO
if indicator == 'LINEARREGO':
if not true_value:
df["LINEARREGO_" +
str(interval)] = df["Close"] - talib.LINEARREG(
df["Open"], timeperiod=interval)
else:
df["LINEARREGO_" + str(interval)] = talib.LINEARREG(
df["Open"], timeperiod=interval)
# 21 TSFO
if indicator == 'TSFO':
if not true_value:
df["TSFO_" + str(interval)] = df["Close"] - talib.TSF(
df["Open"], timeperiod=interval)
else:
df["TSFO_" + str(interval)] = talib.TSF(
df["Open"], timeperiod=interval)
# 22 MACD
if indicator == 'MACD' or indicator == 'MACDhist':
df["MACD_" + str(interval)], _, df["MACDhist_" +
str(interval)] = talib.MACD(
df["Close"],
fastperiod=interval,
slowperiod=interval * 2,
signalperiod=int(
interval * 1.5))
# 23 MACDFIX
if indicator == 'MACDFIX':
df["MACDFIX_" + str(interval)], _, _ = talib.MACDFIX(
df["Close"], signalperiod=interval)
# 24 MOM
if indicator == 'MOM':
df["MOM_" + str(interval)] = talib.MOM(df["Close"],
timeperiod=interval)
# 25 ROCP
if indicator == 'ROCP':
df["ROCP_" + str(interval)] = talib.ROCP(df["Close"],
timeperiod=interval)
# 26 APO
if indicator == 'APO':
df["APO_" + str(interval)] = talib.APO(df["Close"],
fastperiod=interval,
slowperiod=interval * 2)
# 27 MINUS_DM
if indicator == 'MINUS_DM':
df["MINUS_DM_" + str(interval)] = talib.MINUS_DM(
df["High"], df["Low"], timeperiod=interval)
# 28 PLUS_DM
if indicator == 'PLUS_DM':
df["PLUS_DM_" + str(interval)] = talib.PLUS_DM(
df["High"], df["Low"], timeperiod=interval)
# 29 BETA
if indicator == 'BETA':
df["BETA_" + str(interval)] = talib.BETA(
df["High"], df["Low"], timeperiod=interval) / 100.0
# 30 TRIX
if indicator == 'TRIX':
df["TRIX_" + str(interval)] = talib.TRIX(df["Close"],
timeperiod=interval)
# 31 ATR
if indicator == 'ATR':
df["ATR_" + str(interval)] = talib.ATR(df["High"],
df["Low"],
df["Close"],
timeperiod=interval)
# 32 PPO
if indicator == 'PPO':
df["PPO_" + str(interval)] = talib.PPO(df["Close"],
fastperiod=interval,
slowperiod=interval * 2)
# 33 RSI
if indicator == 'RSI':
df["RSI_" + str(interval)] = talib.RSI(
df["Close"], timeperiod=interval) / 100.0
# 34 RSIO
if indicator == 'RSIO':
df["RSIO_" + str(interval)] = talib.RSI(
df["Open"], timeperiod=interval) / 100.0
# 35 LINEARREG_ANGLE
if indicator == 'LINEARREG_ANGLE':
df["LINEARREG_ANGLE_" + str(interval)] = talib.LINEARREG_ANGLE(
df["Close"], timeperiod=interval) / 100.0
# 36 MINUS_DI
if indicator == 'MINUS_DI':
df["MINUS_DI_" + str(interval)] = talib.MINUS_DI(
df["High"], df["Low"], df["Close"],
timeperiod=interval) / 100.0
# 37 PLUS_DI
if indicator == 'PLUS_DI':
df["PLUS_DI_" + str(interval)] = talib.PLUS_DI(
df["High"], df["Low"], df["Close"],
timeperiod=interval) / 100.0
# 38 DX
if indicator == 'DX':
df["DX_" + str(interval)] = talib.DX(
df["High"], df["Low"], df["Close"],
timeperiod=interval) / 100.0
# 39 ADX
if indicator == 'ADX':
df["ADX_" + str(interval)] = talib.ADX(
df["High"], df["Low"], df["Close"],
timeperiod=interval) / 100.0
# 40 ADXO
if indicator == 'ADXO':
df["ADXO_" + str(interval)] = talib.ADX(
df["High"], df["Low"], df["Open"],
timeperiod=interval) / 100.0
# 41 ADXR
if indicator == 'ADXR':
df["ADXR_" + str(interval)] = talib.ADXR(
df["High"], df["Low"], df["Close"],
timeperiod=interval) / 100.0
# 42 CCI
if indicator == 'CCI':
df["CCI_" + str(interval)] = talib.CCI(
df["High"], df["Low"], df["Close"],
timeperiod=interval) / 100.0
# 42 CCIO
if indicator == 'CCIO':
df["CCIO_" + str(interval)] = talib.CCI(
df["High"], df["Low"], df["Open"],
timeperiod=interval) / 100.0
# 43 WILLR
if indicator == 'WILLR':
df["WILLR_" + str(interval)] = talib.WILLR(
df["High"], df["Low"], df["Close"],
timeperiod=interval) / 100.0
# 44 WILLRO
if indicator == 'WILLRO':
df["WILLRO_" + str(interval)] = talib.WILLR(
df["High"], df["Low"], df["Open"],
timeperiod=interval) / 100.0
# 45 CMO
if indicator == 'CMO':
df["CMO_" + str(interval)] = talib.CMO(
df["Close"], timeperiod=interval) / 100.0
# 46 AROONOSC
if indicator == 'AROONOSC':
df["AROONOSC_" + str(interval)] = talib.AROONOSC(
df["High"], df["Low"], timeperiod=interval) / 100.0
# 47 CORREL
if indicator == 'CORREL':
df["CORREL_" + str(interval)] = talib.CORREL(
df["High"], df["Low"], timeperiod=interval)
return df.dropna()
def __generate_technical_indicators(self, close_values, high_values, low_values, open_values,
volume_values):
features = pd.DataFrame()
features['short_sma'] = talib.SMA(close_values, 5)
features['long_sma'] = talib.SMA(close_values, 20)
features['sma_diff'] = features.long_sma - features.short_sma
features['stochf0'] = talib.STOCHF(high=high_values, low=low_values, close=close_values)[0]
features['stochf1'] = talib.STOCHF(high=high_values, low=low_values, close=close_values)[1]
features['rsi'] = talib.RSI(close_values, 20)
features['ad'] = talib.AD(high=high_values, low=low_values, close=close_values, volume=volume_values)
features['dema'] = talib.DEMA(close_values)
features['ema'] = talib.EMA(close_values)
features['ht_trendiline'] = talib.HT_TRENDLINE(close_values)
features['kama'] = talib.KAMA(close_values)
features['midpoint'] = talib.MIDPOINT(close_values)
features['midprice'] = talib.MIDPRICE(high=high_values, low=low_values)
features['sar'] = talib.SAR(high=high_values, low=low_values)
features['sarext'] = talib.SAREXT(high=high_values, low=low_values)
features['adx'] = talib.ADX(high=high_values, low=low_values, close=close_values)
features['adxr'] = talib.ADXR(high=high_values, low=low_values, close=close_values)
features['apo'] = talib.APO(close_values)
features['aroon0'] = talib.AROON(high=high_values, low=low_values)[0]
features['aroon1'] = talib.AROON(high=high_values, low=low_values)[1]
features['aroonosc'] = talib.AROONOSC(high=high_values, low=low_values)
features['bop'] = talib.BOP(open=open_values, high=high_values, low=low_values, close=close_values)
features['cmo'] = talib.CMO(close_values)
features['dx'] = talib.DX(high=high_values, low=low_values, close=close_values)
features['macdfix0'] = talib.MACDFIX(close_values)[0]
features['macdfix1'] = talib.MACDFIX(close_values)[1]
features['macdfix2'] = talib.MACDFIX(close_values)[2]
features['mfi'] = talib.MFI(high=high_values, low=low_values, close=close_values, volume=volume_values)
features['minus_di'] = talib.MINUS_DI(high=high_values, low=low_values, close=close_values)
features['minus_dm'] = talib.MINUS_DM(high=high_values, low=low_values)
features['mom'] = talib.MOM(close_values)
features['plus_di'] = talib.PLUS_DI(high=high_values, low=low_values, close=close_values)
features['plus_dm'] = talib.PLUS_DM(high=high_values, low=low_values)
features['ppo'] = talib.PPO(close_values)
features['roc'] = talib.ROC(close_values)
features['stochf0'] = talib.STOCHF(high=high_values, low=low_values, close=close_values)[0]
features['stochf1'] = talib.STOCHF(high=high_values, low=low_values, close=close_values)[1]
features['stochrsi0'] = talib.STOCHRSI(close_values)[0]
features['stochrsi1'] = talib.STOCHRSI(close_values)[1]
# data_set['trix'] = talib.TRIX(close_values)
features['ultosc'] = talib.ULTOSC(high=high_values, low=low_values, close=close_values)
features['willr'] = talib.WILLR(high=high_values, low=low_values, close=close_values)
features['adosc'] = talib.ADOSC(high=high_values, low=low_values, close=close_values, volume=volume_values)
features['obv'] = talib.OBV(close_values, volume_values)
features['ht_dcperiod'] = talib.HT_DCPERIOD(close_values)
features['ht_dcphase'] = talib.HT_DCPHASE(close_values)
features['ht_phasor0'] = talib.HT_PHASOR(close_values)[0]
features['ht_phasor1'] = talib.HT_PHASOR(close_values)[1]
features['ht_sine0'] = talib.HT_SINE(close_values)[0]
features['ht_sine1'] = talib.HT_SINE(close_values)[1]
features['ht_trendmode'] = talib.HT_TRENDMODE(close_values)
features['atr'] = talib.ATR(high=high_values, low=low_values, close=close_values)
features['trange'] = talib.TRANGE(high=high_values, low=low_values, close=close_values)
features['CDL2CROWS'] = talib.CDL2CROWS(open=open_values, high=high_values, low=low_values, close=close_values)
features['CDL3BLACKCROWS'] = talib.CDL3BLACKCROWS(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDL3INSIDE'] = talib.CDL3INSIDE(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDL3LINESTRIKE'] = talib.CDL3LINESTRIKE(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDL3OUTSIDE'] = talib.CDL3OUTSIDE(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDL3STARSINSOUTH'] = talib.CDL3STARSINSOUTH(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDL3WHITESOLDIERS'] = talib.CDL3WHITESOLDIERS(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLABANDONEDBABY'] = talib.CDLABANDONEDBABY(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLADVANCEBLOCK'] = talib.CDLADVANCEBLOCK(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLBELTHOLD'] = talib.CDLBELTHOLD(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLBREAKAWAY'] = talib.CDLBREAKAWAY(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLCLOSINGMARUBOZU'] = talib.CDLCLOSINGMARUBOZU(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLCONCEALBABYSWALL'] = talib.CDLCONCEALBABYSWALL(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLCOUNTERATTACK'] = talib.CDLCOUNTERATTACK(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLDARKCLOUDCOVER'] = talib.CDLDARKCLOUDCOVER(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLDOJI'] = talib.CDLDOJI(open=open_values, high=high_values, low=low_values, close=close_values)
features['CDLDOJISTAR'] = talib.CDLDOJISTAR(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLDRAGONFLYDOJI'] = talib.CDLDRAGONFLYDOJI(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLENGULFING'] = talib.CDLENGULFING(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLEVENINGDOJISTAR'] = talib.CDLEVENINGDOJISTAR(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLEVENINGSTAR'] = talib.CDLEVENINGSTAR(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLGAPSIDESIDEWHITE'] = talib.CDLGAPSIDESIDEWHITE(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLGRAVESTONEDOJI'] = talib.CDLGRAVESTONEDOJI(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLHAMMER'] = talib.CDLHAMMER(open=open_values, high=high_values, low=low_values, close=close_values)
features['CDLHANGINGMAN'] = talib.CDLHANGINGMAN(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLHARAMI'] = talib.CDLHARAMI(open=open_values, high=high_values, low=low_values, close=close_values)
features['CDLHARAMICROSS'] = talib.CDLHARAMICROSS(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLHIGHWAVE'] = talib.CDLHIGHWAVE(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLHIKKAKE'] = talib.CDLHIKKAKE(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLHIKKAKEMOD'] = talib.CDLHIKKAKEMOD(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLHOMINGPIGEON'] = talib.CDLHOMINGPIGEON(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLIDENTICAL3CROWS'] = talib.CDLIDENTICAL3CROWS(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLINNECK'] = talib.CDLINNECK(open=open_values, high=high_values, low=low_values, close=close_values)
features['CDLINVERTEDHAMMER'] = talib.CDLINVERTEDHAMMER(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLKICKING'] = talib.CDLKICKING(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLKICKINGBYLENGTH'] = talib.CDLKICKINGBYLENGTH(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLLADDERBOTTOM'] = talib.CDLLADDERBOTTOM(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLLONGLEGGEDDOJI'] = talib.CDLLONGLEGGEDDOJI(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLLONGLINE'] = talib.CDLLONGLINE(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLMARUBOZU'] = talib.CDLMARUBOZU(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLMATCHINGLOW'] = talib.CDLMATCHINGLOW(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLMATHOLD'] = talib.CDLMATHOLD(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLMORNINGDOJISTAR'] = talib.CDLMORNINGDOJISTAR(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLMORNINGSTAR'] = talib.CDLMORNINGSTAR(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLONNECK'] = talib.CDLONNECK(open=open_values, high=high_values, low=low_values, close=close_values)
features['CDLPIERCING'] = talib.CDLPIERCING(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLRICKSHAWMAN'] = talib.CDLRICKSHAWMAN(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLRISEFALL3METHODS'] = talib.CDLRISEFALL3METHODS(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLSEPARATINGLINES'] = talib.CDLSEPARATINGLINES(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLSHOOTINGSTAR'] = talib.CDLSHOOTINGSTAR(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLSHORTLINE'] = talib.CDLSHORTLINE(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLSPINNINGTOP'] = talib.CDLSPINNINGTOP(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLSTALLEDPATTERN'] = talib.CDLSTALLEDPATTERN(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLSTICKSANDWICH'] = talib.CDLSTICKSANDWICH(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLTAKURI'] = talib.CDLTAKURI(open=open_values, high=high_values, low=low_values, close=close_values)
features['CDLTASUKIGAP'] = talib.CDLTASUKIGAP(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLTHRUSTING'] = talib.CDLTHRUSTING(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLTRISTAR'] = talib.CDLTRISTAR(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLUNIQUE3RIVER'] = talib.CDLUNIQUE3RIVER(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLUPSIDEGAP2CROWS'] = talib.CDLUPSIDEGAP2CROWS(open=open_values, high=high_values, low=low_values,
close=close_values)
features['CDLXSIDEGAP3METHODS'] = talib.CDLXSIDEGAP3METHODS(open=open_values, high=high_values, low=low_values,
close=close_values)
return features
# ADD NEXT SMA ROW
btc_state_ma_a = pd.concat([btc_state_ma_a,
next_state_row]) # add to last row
btc_state_ma_a = btc_state_ma_a.drop(
btc_state_ma_a.index[0]) # delete first row
btc_state_ma_a_applied = btc_state_ma_a["Close"].rolling(
window=ma_a, min_periods=0).mean() # apply average
btc_state_ma_a_applied = btc_state_ma_a_applied.loc[
btc_state.index[0]:] # crop the beginning using btc state's range
btc_state_ma_a_price_current = btc_state_ma_a_applied.iloc[-1]
# ADD NEXT EMA ROW
btc_state_ma_b = pd.concat([btc_state_ma_b, next_state_row])
btc_state_ma_b = btc_state_ma_b.drop(btc_state_ma_b.index[0])
btc_state_ma_b_applied = talib.DEMA(btc_state_ma_b["Close"],
timeperiod=ma_b)
btc_state_ma_b_applied = btc_state_ma_b_applied.loc[
btc_state.index[0]:] # crop the beginning using btc state's range
btc_state_ma_b_price_current = btc_state_ma_b_applied.iloc[-1]
if 1 == 1:
fig = plt.figure(figsize=(12, 10))
ax1 = fig.add_subplot(111)
ax1.plot(btc_state["Close"], "-", color='b', linewidth=2)
ax1.plot(btc_state_ma_a_applied,
"-",
color='r',
linewidth=2,
label=("sma" + str(sma_days_A)))
ax1.plot(btc_state_ma_b_applied,
"-",
#for index, row in df_segment.iterrows():
for index in df_segment.index:
#start_time = timeit.default_timer()
#print(index, row['Unix'], row['Close'])
cnt += 1
days = int(np.round((cnt / 96), 0))
if cnt % 96 == 0:
print("DAY", days)
# State segment for MA calculations
state_all_ma = df_BTC['Close'].loc[index - 600 - ma_p_size * 2:index]
# MA Calculations
state_ma_a = np.round((talib.DEMA(state_all_ma, timeperiod=ma_a_size)),
6).dropna() #.astype('float32')
state_ma_b = np.round((talib.DEMA(state_all_ma, timeperiod=ma_b_size)),
6).dropna() #.astype('float32')
state_ma_c = np.round((talib.DEMA(state_all_ma, timeperiod=ma_c_size)),
6).dropna() #.astype('float32')
state_ma_d = np.round((talib.DEMA(state_all_ma, timeperiod=ma_d_size)),
6).dropna() #.astype('float32')
state_ma_e = np.round((talib.DEMA(state_all_ma, timeperiod=ma_e_size)),
6).dropna()
state_ma_f = np.round((talib.DEMA(state_all_ma, timeperiod=ma_f_size)),
6).dropna()
state_ma_g = np.round((talib.DEMA(state_all_ma, timeperiod=ma_g_size)),
6).dropna()
state_ma_h = np.round((talib.DEMA(state_all_ma, timeperiod=ma_h_size)),
6).dropna()
def add_factor_of_price(df: pd.DataFrame,
ohlcav_col_name_list,
drop=False,
log_av=True):
open_key = ohlcav_col_name_list[0]
high_key = ohlcav_col_name_list[1]
low_key = ohlcav_col_name_list[2]
close_key = ohlcav_col_name_list[3]
amount_key = ohlcav_col_name_list[4]
volume_key = ohlcav_col_name_list[5]
open_s = df[open_key]
high_s = df[high_key]
low_s = df[low_key]
close_s = df[close_key]
amount_s = df[amount_key]
volume_s = df[volume_key]
# 平均成交价格
deal_price_s = amount_s / volume_s
deal_price_s[volume_s.isna()] = (
(open_s * 2 + high_s + low_s + close_s * 2) / 6)[volume_s.isna()]
df[f'deal_price'] = deal_price_s
# 均线因子
df[f'rr'] = close_s.to_returns()
for n in [5, 10, 15, 20, 30, 60]:
df[f'ma{n}'] = close_s.rolling(n).mean()
# 波动率因子
expanding = close_s.expanding(5)
df[f'volatility_all'] = expanding.std() / expanding.mean()
for n in [20, 60]:
df[f'volatility{n}'] = close_s.rolling(n).std() / close_s.rolling(
n).mean()
# 收益率方差
rr = close_s.to_returns()
for n in [20, 60]:
df[f'rr_std{n}'] = rr.rolling(n).std()
#累积/派发线（Accumulation / Distribution Line，该指标将每日的成交量通过价格加权累计，
#用以计算成交量的动量。属于趋势型因子
df['AD'] = talib.AD(high_s, low_s, close_s, volume_s)
# 佳庆指标（Chaikin Oscillator），该指标基于AD曲线的指数移动均线而计算得到。属于趋势型因子
df['ADOSC'] = talib.ADOSC(high_s,
low_s,
close_s,
volume_s,
fastperiod=3,
slowperiod=10)
# 平均动向指数，DMI因子的构成部分。属于趋势型因子
df['ADX'] = talib.ADX(high_s, low_s, close_s, timeperiod=14)
# 相对平均动向指数，DMI因子的构成部分。属于趋势型因子
df['ADXR'] = talib.ADXR(high_s, low_s, close_s, timeperiod=14)
# 绝对价格振荡指数
df['APO'] = talib.APO(close_s, fastperiod=12, slowperiod=26)
# Aroon通过计算自价格达到近期最高值和最低值以来所经过的期间数，
# 帮助投资者预测证券价格从趋势到区域区域或反转的变化，
# Aroon指标分为Aroon、AroonUp和AroonDown3个具体指标。属于趋势型因子
df['AROONDown'], df['AROONUp'] = talib.AROON(high_s, low_s, timeperiod=14)
df['AROONOSC'] = talib.AROONOSC(high_s, low_s, timeperiod=14)
# 均幅指标（Average TRUE Ranger），取一定时间周期内的股价波动幅度的移动平均值，
# 是显示市场变化率的指标，主要用于研判买卖时机。属于超买超卖型因子。
for n in [6, 14]:
df[f'ATR{n}'] = talib.ATR(high_s, low_s, close_s, timeperiod=n)
# 布林带
df['Boll_Up'], df['Boll_Mid'], df['Boll_Down'] = \
talib.BBANDS(close_s, timeperiod=20, nbdevup=2, nbdevdn=2, matype=0)
# 均势指标
df['BOP'] = talib.BOP(open_s, high_s, low_s, close_s)
# 5日顺势指标（Commodity Channel Index），专门测量股价是否已超出常态分布范围。属于超买超卖型因子。
for n in [5, 10, 20, 88]:
df[f'CCI{n}'] = talib.CCI(high_s, low_s, close_s, timeperiod=5)
# 钱德动量摆动指标（Chande Momentum Osciliator），与其他动量指标摆动指标如
# 相对强弱指标（RSI）和随机指标（KDJ）不同，
# 钱德动量指标在计算公式的分子中采用上涨日和下跌日的数据。属于超买超卖型因子
df['CMO_Close'] = talib.CMO(close_s, timeperiod=14)
df['CMO_Open'] = talib.CMO(open_s, timeperiod=14)
# DEMA双指数移动平均线
for n in [6, 12, 26]:
df[f'DEMA{n}'] = talib.DEMA(close_s, timeperiod=n)
# DX 动向指数
df['DX'] = talib.DX(high_s, low_s, close_s, timeperiod=14)
# EMA 指数移动平均线
for n in [6, 12, 26, 60]:
df[f'EMA{n}'] = talib.EMA(close_s, timeperiod=n)
# KAMA 适应性移动平均线
df['KAMA'] = talib.KAMA(close_s, timeperiod=30)
# MACD
df['MACD_DIF'], df['MACD_DEA'], df['MACD_bar'] = \
talib.MACD(close_s, fastperiod=12, slowperiod=24, signalperiod=9)
# 中位数价格 不知道是什么意思
df['MEDPRICE'] = talib.MEDPRICE(high_s, low_s)
# 负向指标 负向运动
df['MiNUS_DI'] = talib.MINUS_DI(high_s, low_s, close_s, timeperiod=14)
df['MiNUS_DM'] = talib.MINUS_DM(high_s, low_s, timeperiod=14)
# 动量指标（Momentom Index），动量指数以分析股价波动的速度为目的，研究股价在波动过程中各种加速，
# 减速，惯性作用以及股价由静到动或由动转静的现象。属于趋势型因子
df['MOM'] = talib.MOM(close_s, timeperiod=10)
# 归一化平均值范围
df['NATR'] = talib.NATR(high_s, low_s, close_s, timeperiod=14)
# OBV 能量潮指标（On Balance Volume，OBV），以股市的成交量变化来衡量股市的推动力，
# 从而研判股价的走势。属于成交量型因子
df['OBV'] = talib.OBV(close_s, volume_s)
# PLUS_DI 更向指示器
df['PLUS_DI'] = talib.PLUS_DI(high_s, low_s, close_s, timeperiod=14)
df['PLUS_DM'] = talib.PLUS_DM(high_s, low_s, timeperiod=14)
# PPO 价格振荡百分比
df['PPO'] = talib.PPO(close_s, fastperiod=6, slowperiod=26, matype=0)
# ROC 6日变动速率（Price Rate of Change），以当日的收盘价和N天前的收盘价比较，
# 通过计算股价某一段时间内收盘价变动的比例，应用价格的移动比较来测量价位动量。属于超买超卖型因子。
for n in [6, 20]:
df[f'ROC{n}'] = talib.ROC(close_s, timeperiod=n)
# 12日量变动速率指标（Volume Rate of Change），以今天的成交量和N天前的成交量比较，
# 通过计算某一段时间内成交量变动的幅度，应用成交量的移动比较来测量成交量运动趋向，
# 达到事先探测成交量供需的强弱，进而分析成交量的发展趋势及其将来是否有转势的意愿，
# 属于成交量的反趋向指标。属于成交量型因子
for n in [6, 20]:
df[f'VROC{n}'] = talib.ROC(volume_s, timeperiod=n)
# ROC 6日变动速率（Price Rate of Change），以当日的收盘价和N天前的收盘价比较，
# 通过计算股价某一段时间内收盘价变动的比例，应用价格的移动比较来测量价位动量。属于超买超卖型因子。
for n in [6, 20]:
df[f'ROCP{n}'] = talib.ROCP(close_s, timeperiod=n)
# 12日量变动速率指标（Volume Rate of Change），以今天的成交量和N天前的成交量比较，
# 通过计算某一段时间内成交量变动的幅度，应用成交量的移动比较来测量成交量运动趋向，
# 达到事先探测成交量供需的强弱，进而分析成交量的发展趋势及其将来是否有转势的意愿，
# 属于成交量的反趋向指标。属于成交量型因子
for n in [6, 20]:
df[f'VROCP{n}'] = talib.ROCP(volume_s, timeperiod=n)
# RSI
df['RSI'] = talib.RSI(close_s, timeperiod=14)
# SAR 抛物线转向
df['SAR'] = talib.SAR(high_s, low_s, acceleration=0.02, maximum=0.2)
# TEMA
for n in [6, 12, 26]:
df[f'TEMA{n}'] = talib.TEMA(close_s, timeperiod=n)
# TRANGE 真实范围
df['TRANGE'] = talib.TRANGE(high_s, low_s, close_s)
# TYPPRICE 典型价格
df['TYPPRICE'] = talib.TYPPRICE(high_s, low_s, close_s)
# TSF 时间序列预测
df['TSF'] = talib.TSF(close_s, timeperiod=14)
# ULTOSC 极限振子
df['ULTOSC'] = talib.ULTOSC(high_s,
low_s,
close_s,
timeperiod1=7,
timeperiod2=14,
timeperiod3=28)
# 威廉指标
df['WILLR'] = talib.WILLR(high_s, low_s, close_s, timeperiod=14)
# 对 volume amount 取 log
if log_av:
df[volume_key] = np.log(volume_s.fillna(0) + 1)
df[amount_key] = np.log(amount_s.fillna(0) + 1)
if drop:
df.dropna(inplace=True)
return df
buy_sign_crossed_up = False
buy_sign_crossed_down = False
look_for_buy = True
sell_sign_crossed_up = False
sell_sign_crossed_down = False
look_for_sell = True
activate_buy = False
activate_sell = False
# df_BTC["MA_A"] = df_BTC["Close"].rolling(window=ma_a, min_periods=0).mean()
# df_BTC["MA_B"] = df_BTC["Close"].rolling(window=ma_b, min_periods=0).mean()
# df_BTC["MA_A"] = df_BTC["Close"].ewm(span=ma_a, min_periods=0, adjust=False, ignore_na=False).mean()
# df_BTC["MA_B"] = df_BTC["Close"].ewm(span=ma_b, min_periods=0, adjust=False, ignore_na=False).mean()
df_BTC["MA_A"] = talib.DEMA(df_BTC["Close"], timeperiod=ma_a)
df_BTC["MA_B"] = talib.EMA(df_BTC["Close"], timeperiod=ma_b)
df_BTC["MA_C"] = talib.EMA(df_BTC["Close"], timeperiod=ma_c)
df_BTC["STD_A"] = df_BTC["MA_B"].rolling(std_a_period).std()
if 1 == 2:
fig = plt.figure(figsize=(19, 10))
ax1 = fig.add_subplot(111)
ax1.plot(df_BTC["Close"], "-", color='b', linewidth=1)
ax1.plot(df_BTC["MA_A"],
"-",
color='r',
linewidth=2,
label=("sma" + str(sma_days_A)))
ax1.plot(df_BTC["MA_B"],
"-",
def get_factors(index,
Open,
Close,
High,
Low,
Volume,
rolling = 26,
drop=False,
normalization=True):
tmp = pd.DataFrame()
tmp['tradeTime'] = index
#累积/派发线（Accumulation / Distribution Line，该指标将每日的成交量通过价格加权累计，
#用以计算成交量的动量。属于趋势型因子
tmp['AD'] = talib.AD(High, Low, Close, Volume)
# 佳庆指标（Chaikin Oscillator），该指标基于AD曲线的指数移动均线而计算得到。属于趋势型因子
tmp['ADOSC'] = talib.ADOSC(High, Low, Close, Volume, fastperiod=3, slowperiod=10)
# 平均动向指数，DMI因子的构成部分。属于趋势型因子
tmp['ADX'] = talib.ADX(High, Low, Close,timeperiod=14)
# 相对平均动向指数，DMI因子的构成部分。属于趋势型因子
tmp['ADXR'] = talib.ADXR(High, Low, Close,timeperiod=14)
# 绝对价格振荡指数
tmp['APO'] = talib.APO(Close, fastperiod=12, slowperiod=26)
# Aroon通过计算自价格达到近期最高值和最低值以来所经过的期间数，帮助投资者预测证券价格从趋势到区域区域或反转的变化，
#Aroon指标分为Aroon、AroonUp和AroonDown3个具体指标。属于趋势型因子
tmp['AROONDown'], tmp['AROONUp'] = talib.AROON(High, Low,timeperiod=14)
tmp['AROONOSC'] = talib.AROONOSC(High, Low,timeperiod=14)
# 均幅指标（Average TRUE Ranger），取一定时间周期内的股价波动幅度的移动平均值，
#是显示市场变化率的指标，主要用于研判买卖时机。属于超买超卖型因子。
tmp['ATR14']= talib.ATR(High, Low, Close, timeperiod=14)
tmp['ATR6']= talib.ATR(High, Low, Close, timeperiod=6)
# 布林带
tmp['Boll_Up'],tmp['Boll_Mid'],tmp['Boll_Down']= talib.BBANDS(Close, timeperiod=20, nbdevup=2, nbdevdn=2, matype=0)
# 均势指标
tmp['BOP'] = talib.BOP(Open, High, Low, Close)
#5日顺势指标（Commodity Channel Index），专门测量股价是否已超出常态分布范围。属于超买超卖型因子。
tmp['CCI5'] = talib.CCI(High, Low, Close, timeperiod=5)
tmp['CCI10'] = talib.CCI(High, Low, Close, timeperiod=10)
tmp['CCI20'] = talib.CCI(High, Low, Close, timeperiod=20)
tmp['CCI88'] = talib.CCI(High, Low, Close, timeperiod=88)
# 钱德动量摆动指标（Chande Momentum Osciliator），与其他动量指标摆动指标如相对强弱指标（RSI）和随机指标（KDJ）不同，
# 钱德动量指标在计算公式的分子中采用上涨日和下跌日的数据。属于超买超卖型因子
tmp['CMO_Close'] = talib.CMO(Close,timeperiod=14)
tmp['CMO_Open'] = talib.CMO(Close,timeperiod=14)
# DEMA双指数移动平均线
tmp['DEMA6'] = talib.DEMA(Close, timeperiod=6)
tmp['DEMA12'] = talib.DEMA(Close, timeperiod=12)
tmp['DEMA26'] = talib.DEMA(Close, timeperiod=26)
# DX 动向指数
tmp['DX'] = talib.DX(High, Low, Close,timeperiod=14)
# EMA 指数移动平均线
tmp['EMA6'] = talib.EMA(Close, timeperiod=6)
tmp['EMA12'] = talib.EMA(Close, timeperiod=12)
tmp['EMA26'] = talib.EMA(Close, timeperiod=26)
# KAMA 适应性移动平均线
tmp['KAMA'] = talib.KAMA(Close, timeperiod=30)
# MACD
tmp['MACD_DIF'],tmp['MACD_DEA'],tmp['MACD_bar'] = talib.MACD(Close, fastperiod=12, slowperiod=24, signalperiod=9)
# 中位数价格 不知道是什么意思
tmp['MEDPRICE'] = talib.MEDPRICE(High, Low)
# 负向指标 负向运动
tmp['MiNUS_DI'] = talib.MINUS_DI(High, Low, Close,timeperiod=14)
tmp['MiNUS_DM'] = talib.MINUS_DM(High, Low,timeperiod=14)
# 动量指标（Momentom Index），动量指数以分析股价波动的速度为目的，研究股价在波动过程中各种加速，
#减速，惯性作用以及股价由静到动或由动转静的现象。属于趋势型因子
tmp['MOM'] = talib.MOM(Close, timeperiod=10)
# 归一化平均值范围
tmp['NATR'] = talib.NATR(High, Low, Close,timeperiod=14)
# OBV 能量潮指标（On Balance Volume，OBV），以股市的成交量变化来衡量股市的推动力，
#从而研判股价的走势。属于成交量型因子
tmp['OBV'] = talib.OBV(Close, Volume)
# PLUS_DI 更向指示器
tmp['PLUS_DI'] = talib.PLUS_DI(High, Low, Close,timeperiod=14)
tmp['PLUS_DM'] = talib.PLUS_DM(High, Low, timeperiod=14)
# PPO 价格振荡百分比
tmp['PPO'] = talib.PPO(Close, fastperiod=6, slowperiod= 26, matype=0)
# ROC 6日变动速率（Price Rate of Change），以当日的收盘价和N天前的收盘价比较，
#通过计算股价某一段时间内收盘价变动的比例，应用价格的移动比较来测量价位动量。属于超买超卖型因子。
tmp['ROC6'] = talib.ROC(Close, timeperiod=6)
tmp['ROC20'] = talib.ROC(Close, timeperiod=20)
#12日量变动速率指标（Volume Rate of Change），以今天的成交量和N天前的成交量比较，
#通过计算某一段时间内成交量变动的幅度，应用成交量的移动比较来测量成交量运动趋向，
#达到事先探测成交量供需的强弱，进而分析成交量的发展趋势及其将来是否有转势的意愿，
#属于成交量的反趋向指标。属于成交量型因子
tmp['VROC6'] = talib.ROC(Volume, timeperiod=6)
tmp['VROC20'] = talib.ROC(Volume, timeperiod=20)
# ROC 6日变动速率（Price Rate of Change），以当日的收盘价和N天前的收盘价比较，
#通过计算股价某一段时间内收盘价变动的比例，应用价格的移动比较来测量价位动量。属于超买超卖型因子。
tmp['ROCP6'] = talib.ROCP(Close, timeperiod=6)
tmp['ROCP20'] = talib.ROCP(Close, timeperiod=20)
#12日量变动速率指标（Volume Rate of Change），以今天的成交量和N天前的成交量比较，
#通过计算某一段时间内成交量变动的幅度，应用成交量的移动比较来测量成交量运动趋向，
#达到事先探测成交量供需的强弱，进而分析成交量的发展趋势及其将来是否有转势的意愿，
#属于成交量的反趋向指标。属于成交量型因子
tmp['VROCP6'] = talib.ROCP(Volume, timeperiod=6)
tmp['VROCP20'] = talib.ROCP(Volume, timeperiod=20)
# RSI
tmp['RSI'] = talib.RSI(Close, timeperiod=14)
# SAR 抛物线转向
tmp['SAR'] = talib.SAR(High, Low, acceleration=0.02, maximum=0.2)
# TEMA
tmp['TEMA6'] = talib.TEMA(Close, timeperiod=6)
tmp['TEMA12'] = talib.TEMA(Close, timeperiod=12)
tmp['TEMA26'] = talib.TEMA(Close, timeperiod=26)
# TRANGE 真实范围
tmp['TRANGE'] = talib.TRANGE(High, Low, Close)
# TYPPRICE 典型价格
tmp['TYPPRICE'] = talib.TYPPRICE(High, Low, Close)
# TSF 时间序列预测
tmp['TSF'] = talib.TSF(Close, timeperiod=14)
# ULTOSC 极限振子
tmp['ULTOSC'] = talib.ULTOSC(High, Low, Close, timeperiod1=7, timeperiod2=14, timeperiod3=28)
# 威廉指标
tmp['WILLR'] = talib.WILLR(High, Low, Close, timeperiod=14)
# 标准化
if normalization:
factors_list = tmp.columns.tolist()[1:]
if rolling >= 26:
for i in factors_list:
tmp[i] = (tmp[i] - tmp[i].rolling(window=rolling, center=False).mean()) /tmp[i].rolling(window=rolling, center=False).std()
elif rolling < 26 & rolling > 0:
print ('Recommended rolling range greater than 26')
elif rolling <=0:
for i in factors_list:
tmp[i] = (tmp[i] - tmp[i].mean())/tmp[i].std()
if drop:
tmp.dropna(inplace=True)
tmp.set_index('tradeTime', inplace=True)
return tmp
def handle_overlap_studies(args, kax, klines_df, close_times, display_count):
all_name = ""
if args.ABANDS: # ATR BANDS
name = 'ABANDS'
real = talib.ATR(klines_df["high"],
klines_df["low"],
klines_df["close"],
timeperiod=14)
emas = talib.EMA(klines_df["close"], timeperiod=26)
kax.plot(close_times, emas[-display_count:], "b--", label=name)
#cs = ['y', 'c', 'm', 'k']
for idx, n in enumerate(args.ABANDS):
"""
if idx >= len(cs):
break
c = cs[idx]
"""
c = 'y'
cl = c + '--'
n = int(n)
kax.plot(close_times, (emas + n * real)[-display_count:],
cl,
label=name + ' upperband')
kax.plot(close_times, (emas - n * real)[-display_count:],
cl,
label=name + ' lowerband')
if args.BANDS: # BANDS
name = 'BANDS'
emas = talib.EMA(klines_df["close"], timeperiod=26)
kax.plot(close_times, emas[-display_count:], "b--", label=name)
r = args.BANDS
kax.plot(close_times, (1 + r) * emas[-display_count:],
'y--',
label=name + ' upperband')
kax.plot(close_times, (1 - r) * emas[-display_count:],
'y--',
label=name + ' lowerband')
# talib
os_key = 'BBANDS'
if args.BBANDS:
upperband, middleband, lowerband = talib.BBANDS(klines_df["close"],
timeperiod=5,
nbdevup=2,
nbdevdn=2,
matype=0)
kax.plot(close_times,
upperband[-display_count:],
"y",
label=os_key + ' upperband')
kax.plot(close_times,
middleband[-display_count:],
"b",
label=os_key + ' middleband')
kax.plot(close_times,
lowerband[-display_count:],
"y",
label=os_key + ' lowerband')
os_key = 'DEMA'
if args.DEMA:
real = talib.DEMA(klines_df["close"], timeperiod=args.DEMA)
kax.plot(close_times, real[-display_count:], "y", label=os_key)
if args.EMA:
name = 'EMA'
all_name += " %s%s" % (name, args.EMA)
for idx, e_p in enumerate(args.EMA):
if idx >= len(plot_colors):
break
e_p = int(e_p)
emas = talib.EMA(klines_df["close"], timeperiod=e_p)
kax.plot(close_times,
emas[-display_count:],
plot_colors[idx] + '--',
label="%sEMA" % (e_p))
if args.MA:
name = 'MA'
all_name += " %s%s" % (name, args.MA)
for idx, e_p in enumerate(args.MA):
if idx >= len(plot_colors):
break
e_p = int(e_p)
emas = talib.MA(klines_df["close"], timeperiod=e_p)
kax.plot(close_times,
emas[-display_count:],
plot_colors[idx],
label="%sMA" % (e_p))
os_key = 'KAMA'
if args.KAMA:
all_name += " %s%s" % (os_key, args.KAMA)
for idx, e_p in enumerate(args.KAMA):
if idx >= len(plot_colors):
break
e_p = int(e_p)
real = talib.KAMA(klines_df["close"], timeperiod=e_p)
kax.plot(close_times,
real[-display_count:],
plot_colors[idx] + '.',
label="%s%s" % (e_p, os_key))
os_key = 'MAMA'
if args.MAMA:
mama, fama = talib.MAMA(klines_df["close"], fastlimit=0, slowlimit=0)
kax.plot(close_times, mama[-display_count:], "b", label=os_key)
kax.plot(close_times, fama[-display_count:], "c", label=os_key)
os_key = 'HT_TRENDLINE'
if args.HT_TRENDLINE:
real = talib.HT_TRENDLINE(klines_df["close"])
kax.plot(close_times, real[-display_count:], "y", label=os_key)
os_key = 'MIDPOINT'
if args.MIDPOINT:
real = talib.MIDPOINT(klines_df["close"], timeperiod=args.MIDPOINT)
kax.plot(close_times, real[-display_count:], "y", label=os_key)
os_key = 'MIDPRICE'
if args.MIDPRICE:
real = talib.MIDPRICE(klines_df["high"],
klines_df["low"],
timeperiod=args.MIDPRICE)
kax.plot(close_times, real[-display_count:], "y", label=os_key)
os_key = 'SAR'
if args.SAR:
real = talib.SAR(klines_df["high"],
klines_df["low"],
acceleration=0,
maximum=0)
kax.plot(close_times, real[-display_count:], "y", label=os_key)
os_key = 'SAREXT'
if args.SAREXT:
real = talib.SAREXT(klines_df["high"],
klines_df["low"],
startvalue=0,
offsetonreverse=0,
accelerationinitlong=0,
accelerationlong=0,
accelerationmaxlong=0,
accelerationinitshort=0,
accelerationshort=0,
accelerationmaxshort=0)
kax.plot(close_times, real[-display_count:], "y", label=os_key)
os_key = 'SMA'
if args.SMA:
real = talib.SMA(klines_df["close"], timeperiod=args.SMA)
kax.plot(close_times, real[-display_count:], "y", label=os_key)
os_key = 'T3'
if args.T3:
real = talib.T3(klines_df["close"], timeperiod=args.T3, vfactor=0)
kax.plot(close_times, real[-display_count:], "y", label=os_key)
os_key = 'TEMA'
if args.TEMA:
real = talib.TEMA(klines_df["close"], timeperiod=args.TEMA)
kax.plot(close_times, real[-display_count:], "y", label=os_key)
os_key = 'TRIMA'
if args.TRIMA:
real = talib.TRIMA(klines_df["close"], timeperiod=args.TRIMA)
kax.plot(close_times, real[-display_count:], "y", label=os_key)
os_key = 'WMA'
if args.WMA:
real = talib.WMA(klines_df["close"], timeperiod=args.WMA)
kax.plot(close_times, real[-display_count:], "y", label=os_key)
if args.TSF:
name = 'TSF'
real = talib.TSF(klines_df["close"], timeperiod=14)
kax.plot(close_times, real[-display_count:], "y:", label=name)
return all_name
def TA(S, s, c):
S = S.fillna(0)
ope = numpy.asfarray(S.Open)
high = numpy.asfarray(S.High)
low = numpy.asfarray(S.Low)
close = numpy.asfarray(S.Close)
volume = numpy.asfarray(S.Volume)
##ROI calculation
ROI = [(close[i + 1] - close[i]) / close[i] for i in range(len(close) - 1)]
ROI.append(0) #add zero value for last day
d = pandas.DataFrame(ROI, index=S.index, columns=['ROI'])
d.to_csv("C:\\Users\\...\\Documents\\Data_TA\\{0}\\ROI_{1}.csv".format(
s, c))
##Baselines
try:
bah.append((S.Close['2013-04-30'] - S.Close['2002-05-01']) /
S.Close['2002-05-01'])
sah.append((-S.Close['2013-04-30'] + S.Close['2002-05-01']) /
S.Close['2002-05-01'])
except:
bah.append((S.Close['2013-04-30'] - S.Close['2002-05-02']) /
S.Close['2002-05-02'])
sah.append((-S.Close['2013-04-30'] + S.Close['2002-05-02']) /
S.Close['2002-05-02'])
rp.append(
numpy.dot(numpy.random.uniform(-1, 1, len(S)), numpy.asfarray(ROI)))
##talib application
#overlap
BBANDS = ta.BBANDS(close)
DEMA = ta.DEMA(close)
EMA = ta.EMA(close)
HT_TRENDLINE = ta.HT_TRENDLINE(close)
KAMA = ta.KAMA(close)
MA = ta.MA(close)
MAMA = ta.MAMA(close)
MIDPOINT = ta.MIDPOINT(close)
MIDPRICE = ta.MIDPRICE(high, low)
SAR = ta.SAR(high, low)
SAREXT = ta.SAREXT(high, low)
SMA = ta.SMA(close)
T3 = ta.T3(close)
TEMA = ta.TEMA(close)
TRIMA = ta.TRIMA(close)
WMA = ta.WMA(close)
#momentum
ADX = ta.ADX(high, low, close)
ADXR = ta.ADXR(high, low, close)
APO = ta.APO(close)
AROON = ta.AROON(high, low)
AROONOSC = ta.AROONOSC(high, low)
BOP = ta.BOP(ope, high, low, close)
CCI = ta.CCI(high, low, close)
CMO = ta.CMO(close)
DX = ta.DX(high, low, close)
MACD = ta.MACD(close)
MACDEXT = ta.MACDEXT(close)
MFI = ta.MFI(high, low, close, volume)
MINUS_DI = ta.MINUS_DI(high, low, close)
MINUS_DM = ta.MINUS_DM(high, low)
MOM = ta.MOM(close)
PLUS_DI = ta.PLUS_DI(high, low, close)
PLUS_DM = ta.PLUS_DM(high, low)
PPO = ta.PPO(close)
ROC = ta.ROC(close)
ROCP = ta.ROCP(close)
ROCR = ta.ROCR(close)
RSI = ta.RSI(close)
STOCH = ta.STOCH(high, low, close)
STOCHF = ta.STOCHF(high, low, close)
STOCHRSI = ta.STOCHRSI(close)
TRIX = ta.TRIX(close)
ULTOSC = ta.ULTOSC(high, low, close)
WILLR = ta.WILLR(high, low, close)
#volume
AD = ta.AD(high, low, close, volume)
ADOSC = ta.ADOSC(high, low, close, volume)
OBV = ta.OBV(close, volume)
#cycle
HT_DCPERIOD = ta.HT_DCPERIOD(close)
HT_DCPHASE = ta.HT_DCPHASE(close)
HT_PHASOR = ta.HT_PHASOR(close)
HT_SINE = ta.HT_SINE(close)
HT_TRENDMODE = ta.HT_TRENDMODE(close)
#price
AVGPRICE = ta.AVGPRICE(ope, high, low, close)
MEDPRICE = ta.MEDPRICE(high, low)
TYPPRICE = ta.TYPPRICE(high, low, close)
WCLPRICE = ta.WCLPRICE(high, low, close)
#volatility
ATR = ta.ATR(high, low, close)
NATR = ta.NATR(high, low, close)
TRANGE = ta.TRANGE(high, low, close)
#pattern
CDL2CROWS = ta.CDL2CROWS(ope, high, low, close)
CDL3BLACKCROWS = ta.CDL3BLACKCROWS(ope, high, low, close)
CDL3INSIDE = ta.CDL3INSIDE(ope, high, low, close)
CDL3LINESTRIKE = ta.CDL3LINESTRIKE(ope, high, low, close)
CDL3OUTSIDE = ta.CDL3OUTSIDE(ope, high, low, close)
CDL3STARSINSOUTH = ta.CDL3STARSINSOUTH(ope, high, low, close)
CDL3WHITESOLDIERS = ta.CDL3WHITESOLDIERS(ope, high, low, close)
CDLABANDONEDBABY = ta.CDLABANDONEDBABY(ope, high, low, close)
CDLADVANCEBLOCK = ta.CDLADVANCEBLOCK(ope, high, low, close)
CDLBELTHOLD = ta.CDLBELTHOLD(ope, high, low, close)
CDLBREAKAWAY = ta.CDLBREAKAWAY(ope, high, low, close)
CDLCLOSINGMARUBOZU = ta.CDLCLOSINGMARUBOZU(ope, high, low, close)
CDLCONCEALBABYSWALL = ta.CDLCONCEALBABYSWALL(ope, high, low, close)
CDLCOUNTERATTACK = ta.CDLCOUNTERATTACK(ope, high, low, close)
CDLDARKCLOUDCOVER = ta.CDLDARKCLOUDCOVER(ope, high, low, close)
CDLDOJI = ta.CDLDOJI(ope, high, low, close)
CDLDOJISTAR = ta.CDLDOJISTAR(ope, high, low, close)
CDLDRAGONFLYDOJI = ta.CDLDRAGONFLYDOJI(ope, high, low, close)
CDLENGULFING = ta.CDLENGULFING(ope, high, low, close)
CDLEVENINGDOJISTAR = ta.CDLEVENINGDOJISTAR(ope, high, low, close)
CDLEVENINGSTAR = ta.CDLEVENINGSTAR(ope, high, low, close)
CDLGAPSIDESIDEWHITE = ta.CDLGAPSIDESIDEWHITE(ope, high, low, close)
CDLGRAVESTONEDOJI = ta.CDLGRAVESTONEDOJI(ope, high, low, close)
CDLHAMMER = ta.CDLHAMMER(ope, high, low, close)
CDLHANGINGMAN = ta.CDLHANGINGMAN(ope, high, low, close)
CDLHARAMI = ta.CDLHARAMI(ope, high, low, close)
CDLHARAMICROSS = ta.CDLHARAMICROSS(ope, high, low, close)
CDLHIGHWAVE = ta.CDLHIGHWAVE(ope, high, low, close)
CDLHIKKAKE = ta.CDLHIKKAKE(ope, high, low, close)
CDLHIKKAKEMOD = ta.CDLHIKKAKEMOD(ope, high, low, close)
CDLHOMINGPIGEON = ta.CDLHOMINGPIGEON(ope, high, low, close)
CDLIDENTICAL3CROWS = ta.CDLIDENTICAL3CROWS(ope, high, low, close)
CDLINNECK = ta.CDLINNECK(ope, high, low, close)
CDLINVERTEDHAMMER = ta.CDLINVERTEDHAMMER(ope, high, low, close)
CDLKICKING = ta.CDLKICKING(ope, high, low, close)
CDLKICKINGBYLENGTH = ta.CDLKICKINGBYLENGTH(ope, high, low, close)
CDLLADDERBOTTOM = ta.CDLLADDERBOTTOM(ope, high, low, close)
CDLLONGLEGGEDDOJI = ta.CDLLONGLEGGEDDOJI(ope, high, low, close)
CDLLONGLINE = ta.CDLLONGLINE(ope, high, low, close)
CDLMARUBOZU = ta.CDLMARUBOZU(ope, high, low, close)
CDLMATCHINGLOW = ta.CDLMATCHINGLOW(ope, high, low, close)
CDLMATHOLD = ta.CDLMATHOLD(ope, high, low, close)
CDLMORNINGDOJISTAR = ta.CDLMORNINGDOJISTAR(ope, high, low, close)
CDLMORNINGSTAR = ta.CDLMORNINGSTAR(ope, high, low, close)
CDLONNECK = ta.CDLONNECK(ope, high, low, close)
CDLPIERCING = ta.CDLPIERCING(ope, high, low, close)
CDLRICKSHAWMAN = ta.CDLRICKSHAWMAN(ope, high, low, close)
CDLRISEFALL3METHODS = ta.CDLRISEFALL3METHODS(ope, high, low, close)
CDLSEPARATINGLINES = ta.CDLSEPARATINGLINES(ope, high, low, close)
CDLSHOOTINGSTAR = ta.CDLSHOOTINGSTAR(ope, high, low, close)
CDLSHORTLINE = ta.CDLSHORTLINE(ope, high, low, close)
CDLSPINNINGTOP = ta.CDLSPINNINGTOP(ope, high, low, close)
CDLSTALLEDPATTERN = ta.CDLSTALLEDPATTERN(ope, high, low, close)
CDLSTICKSANDWICH = ta.CDLSTICKSANDWICH(ope, high, low, close)
CDLTAKURI = ta.CDLTAKURI(ope, high, low, close)
CDLTASUKIGAP = ta.CDLTASUKIGAP(ope, high, low, close)
CDLTHRUSTING = ta.CDLTHRUSTING(ope, high, low, close)
CDLTRISTAR = ta.CDLTRISTAR(ope, high, low, close)
CDLUNIQUE3RIVER = ta.CDLUNIQUE3RIVER(ope, high, low, close)
CDLUPSIDEGAP2CROWS = ta.CDLUPSIDEGAP2CROWS(ope, high, low, close)
CDLXSIDEGAP3METHODS = ta.CDLXSIDEGAP3METHODS(ope, high, low, close)
f = numpy.column_stack(
(ATR, NATR, TRANGE, HT_DCPERIOD, HT_DCPHASE, HT_PHASOR[0],
HT_PHASOR[1], HT_SINE[0], HT_SINE[1], HT_TRENDMODE, AVGPRICE,
MEDPRICE, TYPPRICE, WCLPRICE, ADX, ADXR, APO, AROON[0], AROON[1],
AROONOSC, BOP, CCI, CMO, DX, MACD[0], MACD[1], MACD[2], MACDEXT[0],
MACDEXT[1], MACDEXT[2], MFI, MINUS_DI, MINUS_DM, MOM, PLUS_DI,
PLUS_DM, PPO, ROC, ROCP, ROCR, RSI, STOCH[0], STOCH[1], STOCHF[0],
STOCHF[1], STOCHRSI[0], STOCHRSI[1], TRIX, ULTOSC, WILLR, CDL2CROWS,
CDL3BLACKCROWS, CDL3INSIDE, CDL3LINESTRIKE, CDL3OUTSIDE,
CDL3STARSINSOUTH, CDL3WHITESOLDIERS, CDLABANDONEDBABY,
CDLADVANCEBLOCK, CDLBELTHOLD, CDLBREAKAWAY, CDLCLOSINGMARUBOZU,
CDLCONCEALBABYSWALL, CDLCOUNTERATTACK, CDLDARKCLOUDCOVER, CDLDOJI,
CDLDOJISTAR, CDLDRAGONFLYDOJI, CDLENGULFING, CDLEVENINGDOJISTAR,
CDLEVENINGSTAR, CDLGAPSIDESIDEWHITE, CDLGRAVESTONEDOJI, CDLHAMMER,
CDLHANGINGMAN, CDLHARAMI, CDLHARAMICROSS, CDLHIGHWAVE, CDLHIKKAKE,
CDLHIKKAKEMOD, CDLHOMINGPIGEON, CDLIDENTICAL3CROWS, CDLINNECK,
CDLINVERTEDHAMMER, CDLKICKING, CDLKICKINGBYLENGTH, CDLLADDERBOTTOM,
CDLLONGLEGGEDDOJI, CDLLONGLINE, CDLMARUBOZU, CDLMATCHINGLOW,
CDLMATHOLD, CDLMORNINGDOJISTAR, CDLMORNINGSTAR, CDLONNECK,
CDLPIERCING, CDLRICKSHAWMAN, CDLRISEFALL3METHODS, CDLSEPARATINGLINES,
CDLSHOOTINGSTAR, CDLSHORTLINE, CDLSPINNINGTOP, CDLSTALLEDPATTERN,
CDLSTICKSANDWICH, CDLTAKURI, CDLTASUKIGAP, CDLTHRUSTING, CDLTRISTAR,
CDLUNIQUE3RIVER, CDLUPSIDEGAP2CROWS, CDLXSIDEGAP3METHODS, BBANDS[0],
BBANDS[1], BBANDS[2], DEMA, EMA, HT_TRENDLINE, KAMA, MA, MAMA[0],
MAMA[1], MIDPOINT, MIDPRICE, SAR, SAREXT, SMA, T3, TEMA, TRIMA, WMA,
AD, ADOSC, OBV))
h = numpy.apply_along_axis(nor, 0, f) # normalize columnwise
df = pandas.DataFrame(
h,
index=S.index,
columns=[
'ATR', 'NATR', 'TRANGE', 'HT_DCPERIOD', 'HT_DCPHASE',
'HT_PHASOR[0]', 'HT_PHASOR[1]', 'HT_SINE[0]', 'HT_SINE[1]',
'HT_TRENDMODE', 'AVGPRICE', 'MEDPRICE', 'TYPPRICE', 'WCLPRICE',
'ADX', 'ADXR', 'APO', 'AROON[0]', 'AROON[1]', 'AROONOSC', 'BOP',
'CCI', 'CMO', 'DX', 'MACD[0]', 'MACD[1]', 'MACD[2]', 'MACDEXT[0]',
'MACDEXT[1]', 'MACDEXT[2]', 'MFI', 'MINUS_DI', 'MINUS_DM', 'MOM',
'PLUS_DI', 'PLUS_DM', 'PPO', 'ROC', 'ROCP', 'ROCR', 'RSI',
'STOCH[0]', 'STOCH[1]', 'STOCHF[0]', 'STOCHF[1]', 'STOCHRSI[0]',
'STOCHRSI[1]', 'TRIX', 'ULTOSC', 'WILLR', 'CDL2CROWS',
'CDL3BLACKCROWS', 'CDL3INSIDE', 'CDL3LINESTRIKE', 'CDL3OUTSIDE',
'CDL3STARSINSOUTH', 'CDL3WHITESOLDIERS', 'CDLABANDONEDBABY',
'CDLADVANCEBLOCK', 'CDLBELTHOLD', 'CDLBREAKAWAY',
'CDLCLOSINGMARUBOZU', 'CDLCONCEALBABYSWALL', 'CDLCOUNTERATTACK',
'CDLDARKCLOUDCOVER', 'CDLDOJI', 'CDLDOJISTAR', 'CDLDRAGONFLYDOJI',
'CDLENGULFING', 'CDLEVENINGDOJISTAR', 'CDLEVENINGSTAR',
'CDLGAPSIDESIDEWHITE', 'CDLGRAVESTONEDOJI', 'CDLHAMMER',
'CDLHANGINGMAN', 'CDLHARAMI', 'CDLHARAMICROSS', 'CDLHIGHWAVE',
'CDLHIKKAKE', 'CDLHIKKAKEMOD', 'CDLHOMINGPIGEON',
'CDLIDENTICAL3CROWS', 'CDLINNECK', 'CDLINVERTEDHAMMER',
'CDLKICKING', 'CDLKICKINGBYLENGTH', 'CDLLADDERBOTTOM',
'CDLLONGLEGGEDDOJI', 'CDLLONGLINE', 'CDLMARUBOZU',
'CDLMATCHINGLOW', 'CDLMATHOLD', 'CDLMORNINGDOJISTAR',
'CDLMORNINGSTAR', 'CDLONNECK', 'CDLPIERCING', 'CDLRICKSHAWMAN',
'CDLRISEFALL3METHODS', 'CDLSEPARATINGLINES', 'CDLSHOOTINGSTAR',
'CDLSHORTLINE', 'CDLSPINNINGTOP', 'CDLSTALLEDPATTERN',
'CDLSTICKSANDWICH', 'CDLTAKURI', 'CDLTASUKIGAP', 'CDLTHRUSTING',
'CDLTRISTAR', 'CDLUNIQUE3RIVER', 'CDLUPSIDEGAP2CROWS',
'CDLXSIDEGAP3METHODS', 'BBANDS[0]', 'BBANDS[1]', 'BBANDS[2]',
'DEMA', 'EMA', 'HT_TRENDLINE', 'KAMA', 'MA', 'MAMA[0]', 'MAMA[1]',
'MIDPOINT', 'MIDPRICE', 'SAR', 'SAREXT', 'SMA', 'T3', 'TEMA',
'TRIMA', 'WMA', 'AD', 'ADOSC', 'OBV'
])
df.to_csv("C:\\Users\\...\\Documents\\Data_TA\\{0}\\{1}.csv".format(s, c))
def DEMA(data, **kwargs):
_check_talib_presence()
prices = _extract_series(data)
return talib.DEMA(prices, **kwargs)
cnt = 0
for i in range(end_date, (game_end_date)):
cnt += 1
#if i % 500 == 0:
#print("STEP: ", i, "DATE: ", btc_state["Date"][i])
next_state_row = df_BTC.loc[[i + 1]]
# PRICE
btc_state = pd.concat([btc_state, next_state_row])
btc_state = btc_state.drop(btc_state.index[0])
btc_price_current = btc_state["Close"].iloc[-1]
# MA A
btc_state_ma_a = pd.concat([btc_state_ma_a, next_state_row])
btc_state_ma_a = btc_state_ma_a.drop(btc_state_ma_a.index[0])
btc_state_ma_a_applied = talib.DEMA(btc_state_ma_a["Close"],
timeperiod=ma_a)
#btc_state_ma_a_applied = btc_state_ma_a_applied.loc[btc_state.index[0]:] # crop the beginning using btc state's range
btc_state_ma_a_price_current = btc_state_ma_a_applied.iloc[-1]
# MA B
btc_state_ma_b = pd.concat([btc_state_ma_b, next_state_row])
btc_state_ma_b = btc_state_ma_b.drop(btc_state_ma_b.index[0])
btc_state_ma_b_applied = talib.DEMA(btc_state_ma_b["Close"],
timeperiod=ma_b)
#btc_state_ma_b_applied = btc_state_ma_b_applied.loc[btc_state.index[0]:] # crop the beginning using btc state's range
btc_state_ma_b_price_current = btc_state_ma_b_applied.iloc[-1]
# MA C
btc_state_ma_c = pd.concat([btc_state_ma_c, next_state_row])
btc_state_ma_c = btc_state_ma_c.drop(btc_state_ma_c.index[0])
btc_state_ma_c_applied = talib.DEMA(btc_state_ma_c["Close"],
def DEMA(close, timeperiod=30):
# Double Exponential Moving Average
return talib.DEMA(close, timeperiod=timeperiod)
def on_preparing_data(self, data, **kwargs):
"""附加计算双移动平均线"""
real = 'dema_{}_{}'.format(self.col_name, self.timeperiod)
data[real] = talib.DEMA(data[self.col_name].values, self.timeperiod)
def PMAX(dataframe, period=10, multiplier=3, length=12, MAtype=1, src=1):
"""
Function to compute PMAX
Source: https://www.tradingview.com/script/sU9molfV/
Pinescript Author: KivancOzbilgic
Args :
df : Pandas DataFrame with the columns ['date', 'open', 'high', 'low', 'close', 'volume']
period : Integer indicates the period of computation in terms of number of candles
multiplier : Integer indicates value to multiply the ATR
length: moving averages length
MAtype: type of the moving average
Returns :
df : Pandas DataFrame with new columns added for
True Range (TR), ATR (ATR_$period)
PMAX (pm_$period_$multiplier_$length_$Matypeint)
PMAX Direction (pmX_$period_$multiplier_$length_$Matypeint)
"""
import talib.abstract as ta
df = dataframe.copy()
mavalue = 'MA_' + str(MAtype) + '_' + str(length)
atr = 'ATR_' + str(period)
df[atr] = ta.ATR(df, timeperiod=period)
pm = 'pm_' + str(period) + '_' + str(multiplier) + '_' + str(
length) + '_' + str(MAtype)
pmx = 'pmX_' + str(period) + '_' + str(multiplier) + '_' + str(
length) + '_' + str(MAtype)
# MAtype==1 --> EMA
# MAtype==2 --> DEMA
# MAtype==3 --> T3
# MAtype==4 --> SMA
# MAtype==5 --> VIDYA
# MAtype==6 --> TEMA
# MAtype==7 --> WMA
# MAtype==8 --> VWMA
# MAtype==9 --> zema
if src == 1:
masrc = df["close"]
elif src == 2:
masrc = (df["high"] + df["low"]) / 2
elif src == 3:
masrc = (df["high"] + df["low"] + df["close"] + df["open"]) / 4
if MAtype == 1:
df[mavalue] = ta.EMA(masrc, timeperiod=length)
elif MAtype == 2:
df[mavalue] = ta.DEMA(masrc, timeperiod=length)
elif MAtype == 3:
df[mavalue] = ta.T3(masrc, timeperiod=length)
elif MAtype == 4:
df[mavalue] = ta.SMA(masrc, timeperiod=length)
elif MAtype == 5:
df[mavalue] = VIDYA(df, length=length)
elif MAtype == 6:
df[mavalue] = ta.TEMA(masrc, timeperiod=length)
elif MAtype == 7:
df[mavalue] = ta.WMA(df, timeperiod=length)
elif MAtype == 8:
df[mavalue] = vwma(df, length)
elif MAtype == 9:
df[mavalue] = zema(df, period=length)
# Compute basic upper and lower bands
df['basic_ub'] = df[mavalue] + (multiplier * df[atr])
df['basic_lb'] = df[mavalue] - (multiplier * df[atr])
# Compute final upper and lower bands
df['final_ub'] = 0.00
df['final_lb'] = 0.00
for i in range(period, len(df)):
df['final_ub'].iat[i] = df['basic_ub'].iat[i] if (
df['basic_ub'].iat[i] < df['final_ub'].iat[i - 1]
or df[mavalue].iat[i - 1] > df['final_ub'].iat[i - 1]
) else df['final_ub'].iat[i - 1]
df['final_lb'].iat[i] = df['basic_lb'].iat[i] if (
df['basic_lb'].iat[i] > df['final_lb'].iat[i - 1]
or df[mavalue].iat[i - 1] < df['final_lb'].iat[i - 1]
) else df['final_lb'].iat[i - 1]
# Set the Pmax value
df[pm] = 0.00
for i in range(period, len(df)):
df[pm].iat[i] = (
df['final_ub'].iat[i] if
(df[pm].iat[i - 1] == df['final_ub'].iat[i - 1]
and df[mavalue].iat[i] <= df['final_ub'].iat[i]) else
df['final_lb'].iat[i] if
(df[pm].iat[i - 1] == df['final_ub'].iat[i - 1]
and df[mavalue].iat[i] > df['final_ub'].iat[i]) else
df['final_lb'].iat[i] if
(df[pm].iat[i - 1] == df['final_lb'].iat[i - 1]
and df[mavalue].iat[i] >= df['final_lb'].iat[i]
) else df['final_ub'].iat[i] if
(df[pm].iat[i - 1] == df['final_lb'].iat[i - 1]
and df[mavalue].iat[i] < df['final_lb'].iat[i]) else 0.00)
# Mark the trend direction up/down
df[pmx] = np.where((df[pm] > 0.00),
np.where((df[mavalue] < df[pm]), 'down', 'up'), np.NaN)
# Remove basic and final bands from the columns
df.drop(['basic_ub', 'basic_lb', 'final_ub', 'final_lb'],
inplace=True,
axis=1)
df.fillna(0, inplace=True)
return df
def DEMA(Series, timeperiod=30):
res = talib.DEMA(Series.values, timeperiod)
return pd.Series(res, index=Series.index)
def execute(self):
return np.array([
self.open,
self.high,
self.low,
self.close,
self.volume,
talib.HT_DCPERIOD(self.close),
talib.HT_DCPHASE(self.close),
talib.HT_PHASOR(self.close)[0],
talib.HT_PHASOR(self.close)[1],
talib.HT_SINE(self.close)[0],
talib.HT_SINE(self.close)[1],
talib.HT_TRENDMODE(self.close),
talib.ADX(self.high, self.low, self.close),
talib.ADXR(self.high, self.low, self.close),
talib.APO(self.close),
talib.AROON(self.high, self.low)[0],
talib.AROON(self.high, self.low)[1],
talib.AROONOSC(self.high, self.low),
talib.BOP(self.open, self.high, self.low, self.close),
talib.CCI(self.high, self.low, self.close),
talib.CMO(self.close),
talib.DX(self.high, self.low, self.close),
talib.MACD(self.close)[0],
talib.MACD(self.close)[1],
talib.MACD(self.close)[2],
talib.MACDEXT(self.close)[0],
talib.MACDEXT(self.close)[1],
talib.MACDEXT(self.close)[2],
talib.MACDFIX(self.close)[0],
talib.MACDFIX(self.close)[1],
talib.MACDFIX(self.close)[2],
talib.MFI(self.high, self.low, self.close, self.volume),
talib.MINUS_DI(self.high, self.low, self.close),
talib.MINUS_DM(self.high, self.low),
talib.MOM(self.close),
talib.PLUS_DI(self.high, self.low, self.close),
talib.PLUS_DM(self.high, self.low),
talib.PPO(self.close),
talib.ROC(self.close),
talib.ROCP(self.close),
talib.ROCR(self.close),
talib.ROCR100(self.close),
talib.RSI(self.close),
talib.STOCH(self.high, self.low, self.close)[0],
talib.STOCH(self.high, self.low, self.close)[1],
talib.STOCHF(self.high, self.low, self.close)[0],
talib.STOCHF(self.high, self.low, self.close)[1],
talib.STOCHRSI(self.close)[0],
talib.STOCHRSI(self.close)[1],
talib.TRIX(self.close),
talib.ULTOSC(self.high, self.low, self.close),
talib.WILLR(self.high, self.low, self.close),
talib.BBANDS(self.close)[0],
talib.BBANDS(self.close)[1],
talib.BBANDS(self.close)[2],
talib.DEMA(self.close),
talib.EMA(self.close),
talib.HT_TRENDLINE(self.close),
talib.KAMA(self.close),
talib.MA(self.close),
talib.MAMA(self.close)[0],
talib.MAMA(self.close)[1],
talib.MIDPOINT(self.close),
talib.MIDPRICE(self.high, self.low),
talib.SAR(self.high, self.low),
talib.SAREXT(self.high, self.low),
talib.T3(self.close),
talib.TEMA(self.close),
talib.TRIMA(self.close),
talib.WMA(self.close),
talib.AVGPRICE(self.open, self.high, self.low, self.close),
talib.MEDPRICE(self.high, self.low),
talib.TYPPRICE(self.high, self.low, self.close),
talib.WCLPRICE(self.high, self.low, self.close),
talib.ATR(self.high, self.low, self.close),
talib.NATR(self.high, self.low, self.close),
talib.TRANGE(self.high, self.low, self.close),
talib.AD(self.high, self.low, self.close, self.volume),
talib.ADOSC(self.high, self.low, self.close, self.volume),
talib.OBV(self.close, self.volume),
talib.CDL2CROWS(self.open, self.high, self.low, self.close),
talib.CDL3BLACKCROWS(self.open, self.high, self.low, self.close),
talib.CDL3INSIDE(self.open, self.high, self.low, self.close),
talib.CDL3LINESTRIKE(self.open, self.high, self.low, self.close),
talib.CDL3OUTSIDE(self.open, self.high, self.low, self.close),
talib.CDL3STARSINSOUTH(self.open, self.high, self.low, self.close),
talib.CDL3WHITESOLDIERS(self.open, self.high, self.low,
self.close),
talib.CDLABANDONEDBABY(self.open, self.high, self.low, self.close),
talib.CDLADVANCEBLOCK(self.open, self.high, self.low, self.close),
talib.CDLBELTHOLD(self.open, self.high, self.low, self.close),
talib.CDLBREAKAWAY(self.open, self.high, self.low, self.close),
talib.CDLCLOSINGMARUBOZU(self.open, self.high, self.low,
self.close),
talib.CDLCONCEALBABYSWALL(self.open, self.high, self.low,
self.close),
talib.CDLCOUNTERATTACK(self.open, self.high, self.low, self.close),
talib.CDLDARKCLOUDCOVER(self.open, self.high, self.low,
self.close),
talib.CDLDOJI(self.open, self.high, self.low, self.close),
talib.CDLDOJISTAR(self.open, self.high, self.low, self.close),
talib.CDLDRAGONFLYDOJI(self.open, self.high, self.low, self.close),
talib.CDLENGULFING(self.open, self.high, self.low, self.close),
talib.CDLEVENINGDOJISTAR(self.open, self.high, self.low,
self.close),
talib.CDLEVENINGSTAR(self.open, self.high, self.low, self.close),
talib.CDLGAPSIDESIDEWHITE(self.open, self.high, self.low,
self.close),
talib.CDLGRAVESTONEDOJI(self.open, self.high, self.low,
self.close),
talib.CDLHAMMER(self.open, self.high, self.low, self.close),
talib.CDLHANGINGMAN(self.open, self.high, self.low, self.close),
talib.CDLHARAMI(self.open, self.high, self.low, self.close),
talib.CDLHARAMICROSS(self.open, self.high, self.low, self.close),
talib.CDLHIGHWAVE(self.open, self.high, self.low, self.close),
talib.CDLHIKKAKE(self.open, self.high, self.low, self.close),
talib.CDLHIKKAKEMOD(self.open, self.high, self.low, self.close),
talib.CDLHOMINGPIGEON(self.open, self.high, self.low, self.close),
talib.CDLIDENTICAL3CROWS(self.open, self.high, self.low,
self.close),
talib.CDLINNECK(self.open, self.high, self.low, self.close),
talib.CDLINVERTEDHAMMER(self.open, self.high, self.low,
self.close),
talib.CDLKICKING(self.open, self.high, self.low, self.close),
talib.CDLKICKINGBYLENGTH(self.open, self.high, self.low,
self.close),
talib.CDLLADDERBOTTOM(self.open, self.high, self.low, self.close),
talib.CDLLONGLEGGEDDOJI(self.open, self.high, self.low,
self.close),
talib.CDLLONGLINE(self.open, self.high, self.low, self.close),
talib.CDLMARUBOZU(self.open, self.high, self.low, self.close),
talib.CDLMATCHINGLOW(self.open, self.high, self.low, self.close),
talib.CDLMATHOLD(self.open, self.high, self.low, self.close),
talib.CDLMORNINGDOJISTAR(self.open, self.high, self.low,
self.close),
talib.CDLMORNINGSTAR(self.open, self.high, self.low, self.close),
talib.CDLONNECK(self.open, self.high, self.low, self.close),
talib.CDLPIERCING(self.open, self.high, self.low, self.close),
talib.CDLRICKSHAWMAN(self.open, self.high, self.low, self.close),
talib.CDLRISEFALL3METHODS(self.open, self.high, self.low,
self.close),
talib.CDLSEPARATINGLINES(self.open, self.high, self.low,
self.close),
talib.CDLSHOOTINGSTAR(self.open, self.high, self.low, self.close),
talib.CDLSHORTLINE(self.open, self.high, self.low, self.close),
talib.CDLSPINNINGTOP(self.open, self.high, self.low, self.close),
talib.CDLSTALLEDPATTERN(self.open, self.high, self.low,
self.close),
talib.CDLSTICKSANDWICH(self.open, self.high, self.low, self.close),
talib.CDLTAKURI(self.open, self.high, self.low, self.close),
talib.CDLTASUKIGAP(self.open, self.high, self.low, self.close),
talib.CDLTHRUSTING(self.open, self.high, self.low, self.close),
talib.CDLTRISTAR(self.open, self.high, self.low, self.close),
talib.CDLUNIQUE3RIVER(self.open, self.high, self.low, self.close),
talib.CDLUPSIDEGAP2CROWS(self.open, self.high, self.low,
self.close),
talib.CDLXSIDEGAP3METHODS(self.open, self.high, self.low,
self.close),
]).transpose()
