def alpha_12(self): """ formula: (sign(delta(volume, 1))*(-1 * delta(close, 1))) """ return np.sign( _utils.delta(self.volume, period=1) * -1 * _utils.delta(self.close, period=1))
def alpha_24(self): """ formula: ((((delta((sum(close, 100) / 100), 100) / delay(close, 100)) < 0.05) or ((delta((sum(close, 100) / 100), 100) / delay(close, 100)) == 0.05)) ? (-1* (close - ts_min(close, 100))) : (-1* delta(close, 3))) """ condition = _utils.delta(_utils.ts_ma(self.close, 100), 100) / _utils.delay(self.close, 100) <= 0.05 alpha = -1 * _utils.delta(self.close, 3) alpha[condition] = -1 * (self.close - _utils.ts_min(self.close, 100)) return alpha
def alpha_7(self): """ formula for alpha7: ((adv20 < volume) ? ((-1*ts_rank(abs(delta(close, 7)), 60)) *sign(delta(close, 7))) : (-1*1)) careful, the self.close should be len>60, so that nan won't generated """ adv20 = _utils.ts_ma(self.volume, 20) alpha = -1 * _utils.ts_rank(abs(_utils.delta(self.close, 7)), 60) * np.sign(_utils.delta(self.close, 7)) alpha[adv20 >= self.volume] = -1 return alpha
def alpha_17(self): """ formula: (((-1 * rank(ts_rank(close, 10))) * rank(delta(delta(close, 1), 1))) *rank(ts_rank((volume / adv20), 5))) :return: """ adv20 = _utils.ts_ma(self.volume, 20) return -1 * ( _utils.rank(_utils.ts_rank(self.close, 10)) * _utils.rank( _utils.delta(_utils.delta(self.close, period=1), period=1)) * _utils.rank(_utils.ts_rank(self.volume / adv20, window=5)))
def alpha_2(self): """ formula for alpha2: (-1*correlation(rank(delta(log(volume), 2)), rank(((close - open) / open)), 6)) :return: time series df of all stocks """ x1 = _utils.rank(_utils.delta(np.log(self.volume), period=2)) x2 = _utils.rank((self.close - self.open) / self.open) return -1 * _utils.correlation(x1, x2, window=6)
def alpha_31(self): """ formula: ((rank(rank(rank(decay_linear((-1* rank(rank(delta(close, 10)))), 10)))) + rank((-1* delta(close, 3)))) + sign(scale(correlation(adv20, low, 12)))) :return: """ adv20 = _utils.ts_ma(self.volume, 20) df = _utils.correlation(adv20, self.low, 12).replace([-np.inf, np.inf], 0).fillna(value=0) p1 = _utils.rank( _utils.rank( _utils.rank( _utils.decay_linear_pn((-1 * _utils.rank( _utils.rank(_utils.delta(self.close, 10)))), 10)))) p2 = _utils.rank((-1 * _utils.delta(self.close, 3))) p3 = np.sign(_utils.scale(df)) return p1 + p2 + p3
def alpha_22(self): """ formula: (-1 * (delta(correlation(high, volume, 5), 5) * rank(stddev(close, 20)))) """ df = _utils.correlation(self.high, self.volume, 5) df = df.replace([-np.inf, np.inf], 0).fillna(value=0) return -1 * _utils.delta(df, 5) * _utils.rank( _utils.stddev(self.close, 20))
def alpha_19(self): """ formula: ((-1 * sign(((close - delay(close, 7)) + delta(close, 7)))) * (1 + rank((1 + sum(returns,250))))) be careful with the time range, less than 250 will be nan """ return ((-1 * np.sign((self.close - _utils.delay(self.close, 7)) + _utils.delta(self.close, 7))) * (1 + _utils.rank(1 + _utils.ts_sum(self.returns, 250))))
def alpha_14(self): """ formula:((-1 * rank(delta(returns, 3))) * correlation(open, volume, 10)) :return: dataframe need a lot stock to prevent inf """ df = _utils.correlation(self.open, self.volume, window=10) df = df.replace([-np.inf, np.inf], 0).fillna(method='backfill') return -1 * _utils.rank(_utils.delta(self.returns, period=3)) * df
def alpha_42(self): """ formula: (ts_rank((volume / adv20), 20) * ts_rank((-1 * delta(close, 7)), 8)) :return: """ adv20 = _utils.ts_ma(self.volume, 20) return _utils.ts_rank(self.volume / adv20, 20) * _utils.ts_rank( (-1 * _utils.delta(self.close, 7)), 8)
def alpha_34(self): """ formula: rank(((1 - rank((stddev(returns, 2) / stddev(returns, 5)))) + (1 - rank(delta(close, 1))))) :return: """ inner = _utils.stddev(self.returns, 2) / _utils.stddev(self.returns, 5) inner = inner.replace([-np.inf, np.inf], 1).fillna(value=1) return _utils.rank(2 - _utils.rank(inner) - _utils.rank(_utils.delta(self.close, 1)))
def alpha_11(self): """ formula: ((rank(ts_max((vwap - close), 3)) + rank(ts_min((vwap - close), 3)))*rank(delta(volume, 3))) :return:df backfilled """ df = (_utils.rank(_utils.ts_max(self.vwap - self.close, window=3)) + _utils.rank(_utils.ts_min(self.vwap - self.close, window=3)) ) * _utils.delta(self.volume, period=3) return df.fillna(method='backfill')
def alpha_30(self): """ formula: (((1.0 - rank(((sign((close - delay(close, 1))) + sign((delay(close, 1) - delay(close, 2)))) + sign((delay(close, 2) - delay(close, 3))))))* sum(volume, 5)) / sum(volume, 20)) """ delta_close = _utils.delta(self.close, 1) # (close - delay(close, 1) inner = np.sign(delta_close) + np.sign(_utils.delay( delta_close, 1)) + np.sign(_utils.delay(delta_close, 2)) df = (1.0 - _utils.rank(inner)) * _utils.ts_sum( self.volume, 5) / _utils.ts_sum(self.volume, 20) return df.fillna(method='backfill')
def alpha_10(self): """ formula: rank(((0 < ts_min(delta(close, 1), 4)) ? delta(close, 1) : ((ts_max(delta(close, 1), 4) < 0) ? delta(close, 1) : (-1*delta(close, 1))))) """ delta_close = _utils.delta(self.close, period=1) condition_1 = _utils.ts_min(delta_close, window=4) > 0 condition_2 = _utils.ts_max(delta_close, window=4) < 0 alpha = -1 * delta_close alpha[condition_1 | condition_2] = delta_close return _utils.rank(alpha)
def alpha_23(self): """ formula: (((sum(high, 20) / 20) < high) ? (-1 * delta(high, 2)) : 0) :return zeros dataframe, hat function """ condition = _utils.ts_ma(self.high, 20) < self.high alpha = pd.DataFrame(np.zeros_like(self.close), index=self.close.index, columns=self.close.columns) alpha[condition] = -1 * _utils.delta(self.high, 2).fillna(value=0) return alpha
def alpha_9(self): """ formula: ((0 < ts_min(delta(close, 1), 5)) ? delta(close, 1) : ((ts_max(delta(close, 1), 5) < 0) ? delta(close, 1) : (-1*delta(close, 1)))) """ delta_close = _utils.delta(self.close, period=1) condition_1 = _utils.ts_min(delta_close, window=5) > 0 condition_2 = _utils.ts_max(delta_close, window=5) < 0 alpha = -1 * delta_close alpha[condition_1 | condition_2] = delta_close return alpha
def alpha_50(self): """ formula: ((((-1 * ts_min(low, 5)) + delay(ts_min(low, 5), 5)) * rank(((sum(returns, 240) -sum(returns, 20)) / 220))) * ts_rank(volume, 5)) :return: long range data needed """ return (( (-1 * _utils.delta(_utils.ts_min(self.low, 5), 5)) * _utils.rank( ((_utils.ts_sum(self.returns, 240) - _utils.ts_sum(self.returns, 20)) / 220))) * _utils.ts_rank(self.volume, 5))
def alpha_49(self): """ formula: (((((delay(close, 20) - delay(close, 10)) / 10) - ((delay(close, 10) - close) / 10)) < (-1 *0.05)) ? 1 : ((-1 * 1) * (close - delay(close, 1)))) :return: """ inner = (( (_utils.delay(self.close, 20) - _utils.delay(self.close, 10)) / 10) - ((_utils.delay(self.close, 10) - self.close) / 10)) alpha = (-1 * _utils.delta(self.close)) alpha[inner < -0.05] = 1 return alpha
def alpha_38(self): """ formula: ((-1 * rank((delta(close, 7) * (1 - rank(decay_linear_pn((volume / adv20), 9)))))) * (1 +rank(sum(returns, 250)))) :return: """ adv20 = _utils.ts_ma(self.volume, 20) return ((-1 * _utils.rank( _utils.delta(self.close, 7) * (1 - _utils.rank(_utils.decay_linear_pn( (self.volume / adv20), 9))))) * (1 + _utils.rank(_utils.ts_ma(self.returns, 250))))
def alpha_45(self): """ formula: (0.25 < (((delay(close, 20) - delay(close, 10)) / 10) - ((delay(close, 10) - close) / 10))) ? (-1 * 1) : (((((delay(close, 20) - delay(close, 10)) / 10) - ((delay(close, 10) - close) / 10)) < 0) ? 1 :((-1 * 1) * (close - delay(close, 1))))) :return dataframe, inner has lot of nan """ inner = ((_utils.delay(self.close, 20) - _utils.delay(self.close, 10)) / 10) - \ ((_utils.delay(self.close, 10) - self.close) / 10) alpha = (-1 * _utils.delta(self.close)) alpha[inner < 0] = 1 alpha[inner > 0.25] = -1 return alpha
def alpha_29(self): """ formula: (min(product(rank(rank(scale(log(sum(ts_min(rank( rank((-1*rank(delta((close - 1), 5))))), 2), 1))))), 1), 5) + ts_rank(delay((-1* returns), 6), 5)) """ df = _utils.ts_min( _utils.rank( _utils.rank( _utils.scale( np.log( _utils.ts_sum( _utils.rank( _utils.rank(-1 * _utils.rank( _utils.delta(self.close - 1, 5)))), 2))))), 5) + _utils.ts_rank( _utils.delay(-1 * self.returns, 6), 5) return df.fillna(method='backfill')