def calculate(self):
"""function to calculate On Balance Volume"""
super().calculate()
daily_ret_key = Constants.get_key("daily_ret")
direction_key = Constants.get_key("direction")
volume_adjusted_key = Constants.get_key("vol_adj")
df_result = []
for ticker in self.tickers:
df_data = self.df[ticker].copy()
df_data[daily_ret_key] = df_data[self.prices_key].pct_change()
df_data[direction_key] = np.where(df_data[daily_ret_key] >= 0, 1,
-1)
df_data.iloc[0].at[direction_key] = 0
df_data[volume_adjusted_key] = df_data[
self.volume_key] * df_data[direction_key]
df_data[self.indicator_key] = df_data[volume_adjusted_key].cumsum()
df_result.append(df_data.loc[:, [self.indicator_key]])
self.df = pd.concat(df_result, axis=1, keys=self.tickers)
return self.df
def get_atr(input_df, params=None):
n = params["n"]
# Set temp dataframe keys
h_l_key = Ct.get_key("H-L")
h_pc_key = Ct.get_key("H-PC")
l_pc_key = Ct.get_key("L-PC")
tr_key = Ct.get_key("TR")
df_data = input_df.copy()
df_data.columns = df_data.columns.droplevel(1)
df_data[h_l_key] = abs(df_data[Ct.high_key()] - df_data[Ct.low_key()])
df_data[h_pc_key] = abs(df_data[Ct.high_key()] -
df_data[Ct.prices_key()].shift(1))
df_data[l_pc_key] = abs(df_data[Ct.low_key()] -
df_data[Ct.prices_key()].shift(1))
df_data[tr_key] = df_data[[h_l_key, h_pc_key,
l_pc_key]].max(axis=1, skipna=False)
df_data[Ct.atr_key()] = df_data[tr_key].rolling(n).mean()
# df[Ct.atr_key()] = df[tr_key].ewm(span=n,adjust=False,min_periods=n).mean()
# df_data.dropna(inplace=True, axis=0)
df_data.drop([h_l_key, h_pc_key, l_pc_key], axis=1, inplace=True)
result_df = pd.DataFrame()
result_df.append(df_data.loc[:, [Ct.atr_key(), tr_key]])
return result_df
def set_input_data(self, df):
super().set_input_data(df)
# Set dataFrame keys
self.low_key = Constants.get_low_key()
self.high_key = Constants.get_high_key()
self.indicator_key = Constants.get_key("ADX")
prices_temp = pd.DataFrame()
df_list = []
for ticker in self.tickers:
if ticker in df:
df_list.append(
pd.concat([
df[ticker].
loc[:, [self.low_key, self.high_key, self.prices_key]],
prices_temp
],
axis=1,
keys=[ticker]))
df_indicator = pd.concat(df_list, axis=1)
self.df = df_indicator.copy()
def calculate(self):
"""function to convert ohlc data into renko bricks"""
super().calculate()
df_result = []
for ticker in self.tickers:
df_data_atr = self.df[[ticker]].copy()
atr = ATR(df_data_atr, 120)
df_atr = atr.calculate()
df_data = self.df_renko_input[ticker].copy()
self.df_renko = Renko(df_data)
atr_key = Constants.get_key("ATR")
self.df_renko.brick_size = round(df_atr[ticker][atr_key][-1], 0)
self.brick_size = self.df_renko.brick_size
# renko_df = df2.get_bricks() #if get_bricks() does not work try using get_ohlc_data() instead
self.renko_data = self.df_renko.get_ohlc_data()
df_result.append(self.renko_data)
self.df = pd.concat(df_result, axis=1, keys=self.tickers)
return self.df
def set_input_data(self, df):
super().set_input_data(df)
# Set dataFrame keys
self.bb_up_key = Constants.get_key("BB_up")
self.bb_down_key = Constants.get_key("BB_down")
self.bb_width_key = Constants.get_key("BB_width")
prices_temp = pd.DataFrame()
df_list = []
for ticker in self.tickers:
if ticker in df:
df_list.append(
pd.concat(
[df[ticker].loc[:, [self.prices_key]], prices_temp],
axis=1,
keys=[ticker]))
df_indicator = pd.concat(df_list, axis=1)
self.df = df_indicator.copy()
def calculate(self):
"""function to calculate RSI
typical values n=14"""
super().calculate()
delta_key = Constants.get_key("delta")
gain_key = Constants.get_key("gain")
loss_key = Constants.get_key("loss")
avg_gain_key = Constants.get_key("avg_gain")
avg_loss_key = Constants.get_key("avg_loss")
rs_key = Constants.get_key("RS")
df_result = []
for ticker in self.tickers:
df_data = self.df[ticker].copy()
df_data[delta_key] = df_data[self.prices_key] - df_data[
self.prices_key].shift(1)
df_data[gain_key] = np.where(df_data[delta_key] >= 0,
df_data[delta_key], 0)
df_data[loss_key] = np.where(df_data[delta_key] < 0,
abs(df_data[delta_key]), 0)
avg_gain = []
avg_loss = []
gain = df_data[gain_key].tolist()
loss = df_data[loss_key].tolist()
for i in range(len(df_data)):
if i < self.n:
avg_gain.append(np.NaN)
avg_loss.append(np.NaN)
elif i == self.n:
avg_gain.append(df_data[gain_key].rolling(
self.n).mean().tolist()[self.n])
avg_loss.append(df_data[loss_key].rolling(
self.n).mean().tolist()[self.n])
elif i > self.n:
avg_gain.append(
((self.n - 1) * avg_gain[i - 1] + gain[i]) / self.n)
avg_loss.append(
((self.n - 1) * avg_loss[i - 1] + loss[i]) / self.n)
df_data[avg_gain_key] = np.array(avg_gain)
df_data[avg_loss_key] = np.array(avg_loss)
df_data[rs_key] = df_data[avg_gain_key] / df_data[avg_loss_key]
df_data[self.indicator_key] = 100 - (100 / (1 + df_data[rs_key]))
df_result.append(df_data.loc[:, [self.indicator_key]])
self.df = pd.concat(df_result, axis=1, keys=self.tickers)
return self.df
def calculate(self):
"""function to calculate Bollinger Bands"""
super().calculate()
# Set temp dataframe keys
ma_key = Constants.get_key("MA")
df_data = pd.DataFrame()
df_result = []
for ticker in self.tickers:
df_data = self.df[ticker].copy()
#df_data.rename(columns={self.ticker: self.prices_key}, inplace=True) #TODO: what happens with this
df_data[ma_key] = \
df_data[self.prices_key].rolling(self.n).mean()
# ddof=0 is required since we want to take the standard deviation of the population and not sample
df_data[self.bb_up_key] = \
df_data[ma_key] + 2 * df_data[self.prices_key].rolling(self.n).std(ddof=0)
# ddof=0 is required since we want to take the standard deviation of the population and not sample
df_data[self.bb_down_key] = \
df_data[ma_key] - 2 * df_data[self.prices_key].rolling(self.n).std(ddof=0)
df_data[self.bb_width_key] = df_data[self.bb_up_key] - df_data[
self.bb_down_key]
df_data.dropna(inplace=True)
df_result.append(df_data.loc[:,
[self.bb_up_key, self.bb_down_key]])
self.df = pd.concat(df_result, axis=1, keys=self.tickers)
return df_data
def calculate(self):
""""function to calculate ADX"""
super().calculate()
tr_key = Constants.get_key("TR")
trn_key = Constants.get_key("TRn")
dm_plus_key = Constants.get_key("DMplus")
dm_plus_n_key = Constants.get_key("DMplusN")
dm_minus_key = Constants.get_key("DMminus")
dm_minus_n_key = Constants.get_key("DMminusN")
di_plus_n_key = Constants.get_key("DIplusN")
di_minus_n_key = Constants.get_key("DIminusN")
di_diff_key = Constants.get_key("DIdiff")
di_sum_key = Constants.get_key("DIsum")
dx_key = Constants.get_key("DX")
df_result = []
for ticker in self.tickers:
df_data_atr = self.df[[ticker]].copy()
atr_ind = ATR(df=df_data_atr, n=14)
df_data = self.df[ticker].copy()
# the period parameter of ATR function does not matter because period does not influence TR calculation
df_data[tr_key] = atr_ind.calculate()[ticker][[tr_key]]
df_data[dm_plus_key] = \
np.where(
(df_data[self.high_key] - df_data[self.high_key].shift(1)) >
(df_data[self.low_key].shift(1) - df_data[self.low_key]),
df_data[self.high_key] - df_data[self.high_key].shift(1),
0)
df_data[dm_plus_key] = \
np.where(
df_data[dm_plus_key] < 0,
0,
df_data[dm_plus_key])
df_data[dm_minus_key] = \
np.where((df_data[self.low_key].shift(1) - df_data[self.low_key]) >
(df_data[self.high_key] - df_data[self.high_key].shift(1)),
df_data[self.low_key].shift(1) - df_data[self.low_key],
0)
df_data[dm_minus_key] = np.where(df_data[dm_minus_key] < 0, 0,
df_data[dm_minus_key])
TRn = []
DMplusN = []
DMminusN = []
TR = df_data[tr_key].tolist()
DMplus = df_data[dm_plus_key].tolist()
DMminus = df_data[dm_minus_key].tolist()
for i in range(len(df_data)):
if i < self.n:
TRn.append(np.NaN)
DMplusN.append(np.NaN)
DMminusN.append(np.NaN)
elif i == self.n:
TRn.append(df_data[tr_key].rolling(
self.n).sum().tolist()[self.n])
DMplusN.append(df_data[dm_plus_key].rolling(
self.n).sum().tolist()[self.n])
DMminusN.append(df_data[dm_minus_key].rolling(
self.n).sum().tolist()[self.n])
elif i > self.n:
TRn.append(TRn[i - 1] - (TRn[i - 1] / 14) + TR[i])
DMplusN.append(DMplusN[i - 1] - (DMplusN[i - 1] / 14) +
DMplus[i])
DMminusN.append(DMminusN[i - 1] - (DMminusN[i - 1] / 14) +
DMminus[i])
df_data[trn_key] = np.array(TRn)
df_data[dm_plus_n_key] = np.array(DMplusN)
df_data[dm_minus_n_key] = np.array(DMminusN)
df_data[di_plus_n_key] = 100 * (df_data[dm_plus_n_key] /
df_data[trn_key])
df_data[di_minus_n_key] = 100 * (df_data[dm_minus_n_key] /
df_data[trn_key])
df_data[di_diff_key] = abs(df_data[di_plus_n_key] -
df_data[di_minus_n_key])
df_data[
di_sum_key] = df_data[di_plus_n_key] + df_data[di_minus_n_key]
df_data[dx_key] = 100 * (df_data[di_diff_key] /
df_data[di_sum_key])
ADX = []
DX = df_data[dx_key].tolist()
for j in range(len(df_data)):
if j < 2 * self.n - 1:
ADX.append(np.NaN)
elif j == 2 * self.n - 1:
ADX.append(df_data[dx_key][j - self.n + 1:j + 1].mean())
elif j > 2 * self.n - 1:
ADX.append(((self.n - 1) * ADX[j - 1] + DX[j]) / self.n)
df_data[self.indicator_key] = np.array(ADX)
df_result.append(df_data.loc[:, [self.indicator_key]])
self.df = pd.concat(df_result, axis=1, keys=self.tickers)
return self.df
