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