Created
April 3, 2019 23:58
-
-
Save kangchihlun/7850f07c11bdea022b2d49f1d4ed9802 to your computer and use it in GitHub Desktop.
GTJA_Alpha191.py
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| from scipy.stats import rankdata | |
| import scipy as sp | |
| import numpy as np | |
| import pandas as pd | |
| class GTJA_191: | |
| def __init__(self, end_date, index): | |
| security = get_index_stocks(index) | |
| price = get_price(security, None, end_date, '1d', ['open','close','low','high','avg_price','prev_close','volume','turnover'], False, None, 250,is_panel=1) | |
| benchmark_price = get_price(index, None, end_date, '1d',['open','close','low','high','avg_price','prev_close','volume'], False, None, 250,is_panel=1) | |
| self.open_price = price.loc['open',:,:].dropna(axis=1,how='any') | |
| self.close = price.loc['close',:,:].dropna(axis=1,how='any') | |
| self.low = price.loc['low',:,:].dropna(axis=1,how='any') | |
| self.high = price.loc['high',:,:].dropna(axis=1,how='any') | |
| self.avg_price = price.loc['avg_price',:,:].dropna(axis=1,how='any') | |
| self.prev_close = price.loc['prev_close',:,:].dropna(axis=1,how='any') | |
| self.volume = price.loc['volume',:,:].dropna(axis=1,how='any') | |
| self.amount = price.loc['turnover',:,:].dropna(axis=1,how='any') | |
| self.benchmark_open_price = benchmark_price.loc[:, 'open'] | |
| self.benchmark_close_price = benchmark_price.loc[:, 'close'] | |
| ######################################################################### | |
| def func_rank(self, na): | |
| return rankdata(na)[-1]/rankdata(na).max() | |
| def func_decaylinear(self, na): | |
| n = len(na) | |
| decay_weights = np.arange(1,n+1,1) | |
| decay_weights = decay_weights / decay_weights.sum() | |
| return (na * decay_weights).sum() | |
| def func_highday(self, na): | |
| return len(na) - na.values.argmax() | |
| def func_lowday(self, na): | |
| return len(na) - na.values.argmin() | |
| ############################################################################# | |
| def alpha_001(self): | |
| data1 = self.volume.diff(periods=1).rank(axis=1,pct=True) | |
| data2 = ((self.close - self.open_price)/self.open_price).rank(axis=1,pct=True) | |
| alpha = -data1.iloc[-6:,:].corrwith(data2.iloc[-6:,:]).dropna() | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_002(self): | |
| ##### -1 * delta((((close-low)-(high-close))/((high-low)),1))#### | |
| result=((self.close-self.low)-(self.high-self.close))/((self.high-self.low)).diff() | |
| m=result.iloc[-1,:].dropna() | |
| alpha=m[(m<np.inf)&(m>-np.inf)] | |
| return alpha.dropna() | |
| ################################################################ | |
| def alpha_003(self): | |
| delay1 = self.close.shift() | |
| condtion1 = (self.close == delay1) | |
| condition2 = (self.close > delay1) | |
| condition3 = (self.close < delay1) | |
| part2 = (self.close-np.minimum(delay1[condition2],self.low[condition2])).iloc[-6:,:] #取最近的6位数据 | |
| part3 = (self.close-np.maximum(delay1[condition3],self.low[condition3])).iloc[-6:,:] | |
| result=part2.fillna(0)+part3.fillna(0) | |
| alpha=result.sum() | |
| return alpha.dropna() | |
| ######################################################################## | |
| def alpha_004(self): | |
| condition1=(pd.rolling_std(self.close,8)<pd.rolling_sum(self.close,2)/2) | |
| condition2=(pd.rolling_sum(self.close,2)/2<(pd.rolling_sum(self.close,8)/8-pd.rolling_std(self.close,8))) | |
| condition3=(1<=self.volume/pd.rolling_mean(self.volume,20)) | |
| condition3 | |
| indicator1=pd.DataFrame(np.ones(self.close.shape),index=self.close.index,columns=self.close.columns)#[condition2] | |
| indicator2=-pd.DataFrame(np.ones(self.close.shape),index=self.close.index,columns=self.close.columns)#[condition3] | |
| part0=pd.rolling_sum(self.close,8)/8 | |
| part1=indicator2[condition1].fillna(0) | |
| part2=(indicator1[~condition1][condition2]).fillna(0) | |
| part3=(indicator1[~condition1][~condition2][condition3]).fillna(0) | |
| part4=(indicator2[~condition1][~condition2][~condition3]).fillna(0) | |
| result=part0+part1+part2+part3+part4 | |
| alpha=result.iloc[-1,:] | |
| return alpha.dropna() | |
| ################################################################ | |
| def alpha_005(self): | |
| ts_volume=(self.volume.iloc[-7:,:]).rank(axis=0,pct=True) | |
| ts_high=(self.high.iloc[-7:,:]).rank(axis=0,pct=True) | |
| corr_ts=pd.rolling_corr(ts_high,ts_volume,5) | |
| alpha=corr_ts.max().dropna() | |
| alpha=alpha[(alpha<np.inf)&(alpha>-np.inf)] | |
| return alpha | |
| ############################################################### | |
| def alpha_006(self): | |
| condition1=((self.open_price*0.85+self.high*0.15).diff(4)>1) | |
| condition2=((self.open_price*0.85+self.high*0.15).diff(4)==1) | |
| condition3=((self.open_price*0.85+self.high*0.15).diff(4)<1) | |
| indicator1=pd.DataFrame(np.ones(self.close.shape),index=self.close.index,columns=self.close.columns) | |
| indicator2=pd.DataFrame(np.zeros(self.close.shape),index=self.close.index,columns=self.close.columns) | |
| indicator3=-pd.DataFrame(np.ones(self.close.shape),index=self.close.index,columns=self.close.columns) | |
| part1=indicator1[condition1].fillna(0) | |
| part2=indicator2[condition2].fillna(0) | |
| part3=indicator3[condition3].fillna(0) | |
| result=part1+part2+part3 | |
| alpha=(result.rank(axis=1,pct=True)).iloc[-1,:] #cross section rank | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_007(self): | |
| part1=(np.maximum(self.avg_price-self.close,3)).rank(axis=1,pct=True) | |
| part2=(np.minimum(self.avg_price-self.close,3)).rank(axis=1,pct=True) | |
| part3=(self.volume.diff(3)).rank(axis=1,pct=True) | |
| result=part1+part2*part3 | |
| alpha=result.iloc[-1,:] | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_008(self): | |
| temp=(self.high+self.low)*0.2/2+self.avg_price*0.8 | |
| result=-temp.diff(4) | |
| alpha=result.rank(axis=1,pct=True) | |
| alpha=alpha.iloc[-1,:] | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_009(self): | |
| temp=(self.high+self.low)*0.5-(self.high.shift()+self.low.shift())*0.5*(self.high-self.low)/self.volume #计算close_{i-1} | |
| result=pd.ewma(temp,alpha=2/7) | |
| alpha=result.iloc[-1,:] | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_010(self): | |
| ret=self.close.pct_change() | |
| condtion=(ret<0) | |
| part1=(pd.rolling_std(ret,20)[condtion]).fillna(0) | |
| part2=(self.close[~condtion]).fillna(0) | |
| result=np.maximum((part1+part2)**2,5) | |
| alpha=result.rank(axis=1,pct=True) | |
| alpha=alpha.iloc[-1,:] | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_011(self): | |
| temp=((self.close-self.low)-(self.high-self.close))/(self.high-self.low) | |
| result=temp*self.volume | |
| alpha=result.iloc[-6:,:].sum() | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_012(self): | |
| vwap10=pd.rolling_sum(self.avg_price,10)/10 | |
| temp1=self.open_price-vwap10 | |
| part1=temp1.rank(axis=1,pct=True) | |
| temp2=(self.close-self.avg_price).abs() | |
| part2=-temp2.rank(axis=1,pct=True) | |
| result=part1*part2 | |
| alpha=result.iloc[-1,:] | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_013(self): | |
| result=((self.high-self.low)**0.5)-self.avg_price | |
| alpha=result.iloc[-1,:] | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_014(self): | |
| result=self.close-self.close.shift(5) | |
| alpha=result.iloc[-1,:] | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_015(self): | |
| result=self.open_price/self.close.shift()-1 | |
| alpha=result.iloc[-1,:] | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_016(self): | |
| temp1=self.volume.rank(axis=1,pct=True) | |
| temp2=self.avg_price.rank(axis=1,pct=True) | |
| part=pd.rolling_corr(temp1,temp2,5)# | |
| part=part[(part<np.inf)&(part>-np.inf)] | |
| result=part.iloc[-5:,:] | |
| result=result.dropna(axis=1) | |
| alpha=-result.max() | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_017(self): | |
| temp1=pd.rolling_max(self.avg_price,15) | |
| temp2=(self.close-temp1).dropna() | |
| part1=temp2.rank(axis=1,pct=True) | |
| part2=self.close.diff(5) | |
| result=part1**part2 | |
| alpha=result.iloc[-1,:] | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_018(self): | |
| delay5=self.close.shift(5) | |
| alpha=self.close/delay5 | |
| alpha=alpha.iloc[-1,:] | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_019(self): | |
| delay5=self.close.shift(5) | |
| condition1=(self.close<delay5) | |
| condition3=(self.close>delay5) | |
| part1=(self.close[condition1]-delay5[condition1])/delay5[condition1] | |
| part1=part1.fillna(0) | |
| part2=(self.close[condition3]-delay5[condition3])/self.close[condition3] | |
| part2=part2.fillna(0) | |
| result=part1+part2 | |
| alpha=result.iloc[-1,:] | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_020(self): | |
| delay6=self.close.shift(6) | |
| result=(self.close-delay6)*100/delay6 | |
| alpha=result.iloc[-1,:] | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_021(self): | |
| A=pd.rolling_mean(self.close,6).iloc[-6:,:] | |
| B=np.arange(1,7) | |
| temp=A.apply(lambda x:sp.stats.linregress(x,B) ,axis=0) | |
| drop_list=[i for i in range(len(temp)) if temp[i][3]>0.05] | |
| temp.drop(temp.index[drop_list],inplace=True) | |
| beta_list=[temp[i].slope for i in range(len(temp))] | |
| alpha=pd.Series(beta_list,index=temp.index) | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_022(self): | |
| part1=(self.close-pd.rolling_mean(self.close,6))/pd.rolling_mean(self.close,6) | |
| temp=(self.close-pd.rolling_mean(self.close,6))/pd.rolling_mean(self.close,6) | |
| part2=temp.shift(3) | |
| result=part1-part2 | |
| result=pd.ewma(result,alpha=1.0/12) | |
| alpha=result.iloc[-1,:] | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_023(self): | |
| condition1=(self.close>self.close.shift()) | |
| temp1=pd.rolling_std(self.close,20)[condition1] | |
| temp1=temp1.fillna(0) | |
| temp2=pd.rolling_std(self.close,20)[~condition1] | |
| temp2=temp2.fillna(0) | |
| part1=pd.ewma(temp1,alpha=1.0/20) | |
| part2=pd.ewma(temp2,alpha=1.0/20) | |
| result=part1*100/(part1+part2) | |
| alpha=result.iloc[-1,:] | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_024(self): | |
| delay5=self.close.shift(5) | |
| result=self.close-delay5 | |
| result=pd.ewma(result,alpha=1.0/5) | |
| alpha=result.iloc[-1,:] | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_025(self): | |
| n=9 | |
| part1=(self.close.diff(7)).rank(axis=1,pct=True) | |
| part1=part1.iloc[-1,:] | |
| temp=self.volume/pd.rolling_mean(self.volume,20) | |
| temp1=temp.iloc[-9:,:] | |
| seq=[2*i/(n*(n+1)) for i in range(1,n+1)] | |
| weight=np.array(seq) | |
| temp1=temp1.apply(lambda x: x*weight) | |
| ret=self.close.pct_change() | |
| rank_sum_ret=(ret.sum()).rank(pct=True) | |
| part2=1-temp1.sum() | |
| part3=1+rank_sum_ret | |
| alpha=-part1*part2*part3 | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_026(self): | |
| part1=pd.rolling_sum(self.close,7)/7-self.close | |
| part1=part1.iloc[-1,:] | |
| delay5=self.close.shift(5) | |
| part2=pd.rolling_corr(self.avg_price,delay5,230) | |
| part2=part2.iloc[-1,:] | |
| alpha=part1+part2 | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_027(self): | |
| return 0 | |
| ################################################################## | |
| def alpha_028(self): | |
| temp1=self.close-pd.rolling_min(self.low,9) | |
| temp2=pd.rolling_max(self.high,9)-pd.rolling_min(self.low,9) | |
| part1=3*pd.ewma(temp1*100/temp2,alpha=1.0/3) | |
| temp3=pd.ewma(temp1*100/temp2,alpha=1.0/3) | |
| part2=2*pd.ewma(temp3,alpha=1.0/3) | |
| result=part1-part2 | |
| alpha=result.iloc[-1,:] | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_029(self): | |
| delay6=self.close.shift(6) | |
| result=(self.close-delay6)*self.volume/delay6 | |
| alpha=result.iloc[-1,:] | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_030(self): | |
| return 0 | |
| ################################################################## | |
| def alpha_031(self): | |
| result=(self.close-pd.rolling_mean(self.close,12))*100/pd.rolling_mean(self.close,12) | |
| alpha=result.iloc[-1,:] | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_032(self): | |
| temp1=self.high.rank(axis=1,pct=True) | |
| temp2=self.volume.rank(axis=1,pct=True) | |
| temp3=pd.rolling_corr(temp1,temp2,3) | |
| temp3=temp3[(temp3<np.inf)&(temp3>-np.inf)].fillna(0) | |
| result=(temp3.rank(axis=1,pct=True)).iloc[-3:,:] | |
| alpha=-result.sum() | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_033(self): | |
| ret=self.close.pct_change() | |
| temp1=pd.rolling_min(self.low,5) #TS_MIN | |
| part1=temp1.shift(5)-temp1 | |
| part1=part1.iloc[-1,:] | |
| temp2=(pd.rolling_sum(ret,240)-pd.rolling_sum(ret,20))/220 | |
| part2=temp2.rank(axis=1,pct=True) | |
| part2=part2.iloc[-1,:] | |
| temp3=self.volume.iloc[-5:,:] | |
| part3=temp3.rank(axis=0,pct=True) #TS_RANK | |
| part3=part3.iloc[-1,:] | |
| alpha=part1+part2+part3 | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_034(self): | |
| result=pd.rolling_mean(self.close,12)/self.close | |
| alpha=result.iloc[-1,:] | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_035(self): | |
| n=15 | |
| m=7 | |
| temp1=self.open_price.diff() | |
| temp1=temp1.iloc[-n:,:] | |
| seq1=[2*i/(n*(n+1)) for i in range(1,n+1)] | |
| seq2=[2*i/(m*(m+1)) for i in range(1,m+1)] | |
| weight1=np.array(seq1) | |
| weight2=np.array(seq2) | |
| part1=temp1.apply(lambda x: x*weight1) | |
| part1=part1.rank(axis=1,pct=True) | |
| temp2=0.65*self.open_price+0.35*self.open_price | |
| temp2=pd.rolling_corr(temp2,self.volume,17) | |
| temp2=temp2.iloc[-m:,:] | |
| part2=temp2.apply(lambda x: x*weight2) | |
| alpha=np.minimum(part1.iloc[-1,:],-part2.iloc[-1,:]) | |
| alpha=alpha[(alpha<np.inf)&(alpha>-np.inf)] | |
| alpha=alpha.dropna() | |
| return alpha | |
| ################################################################## | |
| def alpha_036(self): | |
| temp1=self.volume.rank(axis=1,pct=True) | |
| temp2=self.avg_price.rank(axis=1,pct=True) | |
| part1=pd.rolling_corr(temp1,temp2,6) | |
| result=pd.rolling_sum(part1,2) | |
| result=result.rank(axis=1,pct=True) | |
| alpha=result.iloc[-1,:] | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_037(self): | |
| ret=self.close.pct_change() | |
| temp=pd.rolling_sum(self.open_price,5)*pd.rolling_sum(ret,5) | |
| part1=temp.rank(axis=1,pct=True) | |
| part2=temp.shift(10) | |
| result=-part1-part2 | |
| alpha=result.iloc[-1,:].dropna() | |
| return alpha | |
| ################################################################## | |
| def alpha_038(self): | |
| sum_20=pd.rolling_sum(self.high,20)/20 | |
| delta2=self.high.diff(2) | |
| condition=(sum_20<self.high) | |
| result=-delta2[condition].fillna(0) | |
| alpha=result.iloc[-1,:] | |
| return alpha | |
| ################################################################## | |
| def alpha_039(self): | |
| n=8 | |
| m=12 | |
| temp1=self.close.diff(2) | |
| temp1=temp1.iloc[-n:,:] | |
| seq1=[2*i/(n*(n+1)) for i in range(1,n+1)] | |
| seq2=[2*i/(m*(m+1)) for i in range(1,m+1)] | |
| weight1=np.array(seq1) | |
| weight2=np.array(seq2) | |
| part1=temp1.apply(lambda x: x*weight1) | |
| part1=part1.rank(axis=1,pct=True) | |
| temp2=0.3*self.avg_price+0.7*self.open_price | |
| volume_180=pd.rolling_mean(self.volume,180) | |
| sum_vol=pd.rolling_sum(volume_180,37) | |
| temp3=pd.rolling_corr(temp2,sum_vol,14) | |
| temp3=temp3.iloc[-m:,:] | |
| part2=-temp3.apply(lambda x: x*weight2) | |
| part2.rank(axis=1,pct=True) | |
| result=part1.iloc[-1,:]-part2.iloc[-1,:] | |
| alpha=result | |
| alpha=alpha[(alpha<np.inf)&(alpha>-np.inf)] | |
| alpha=alpha.dropna() | |
| return alpha | |
| ################################################################## | |
| def alpha_040(self): | |
| delay1=self.close.shift() | |
| condition=(self.close>delay1) | |
| vol=self.volume[condition].fillna(0) | |
| vol_sum=pd.rolling_sum(vol,26) | |
| vol1=self.volume[~condition].fillna(0) | |
| vol1_sum=pd.rolling_sum(vol1,26) | |
| result=100*vol_sum/vol1_sum | |
| result=result.iloc[-1,:] | |
| alpha=result | |
| alpha=alpha[(alpha<np.inf)&(alpha>-np.inf)] | |
| alpha=alpha.dropna() | |
| return alpha | |
| ################################################################## | |
| def alpha_041(self): | |
| delta_avg=self.avg_price.diff(3) | |
| part=np.maximum(delta_avg,5) | |
| result=-part.rank(axis=1,pct=True) | |
| alpha=result.iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| ################################################################## | |
| def alpha_042(self): | |
| part1=pd.rolling_corr(self.high,self.volume,10) | |
| part2=pd.rolling_std(self.high,10) | |
| part2=part2.rank(axis=1,pct=True) | |
| result=-part1*part2 | |
| alpha=result.iloc[-1,:] | |
| alpha=alpha[(alpha<np.inf)&(alpha>-np.inf)] | |
| alpha=alpha.dropna() | |
| return alpha | |
| ################################################################## | |
| def alpha_043(self): | |
| delay1=self.close.shift() | |
| condition1=(self.close>delay1) | |
| condition2=(self.close<delay1) | |
| temp1=self.volume[condition1].fillna(0) | |
| temp2=-self.volume[condition2].fillna(0) | |
| result=temp1+temp2 | |
| result=pd.rolling_sum(result,6) | |
| alpha=result.iloc[-1,:].dropna() | |
| return alpha | |
| ################################################################## | |
| def alpha_044(self): | |
| part1=self.open_price*0.4+self.close*0.6 | |
| n=6 | |
| m=10 | |
| temp1=pd.rolling_corr(self.low,pd.rolling_mean(self.volume,10),7) | |
| temp1=temp1.iloc[-n:,:] | |
| seq1=[2*i/(n*(n+1)) for i in range(1,n+1)] | |
| seq2=[2*i/(m*(m+1)) for i in range(1,m+1)] | |
| weight1=np.array(seq1) | |
| weight2=np.array(seq2) | |
| part1=temp1.apply(lambda x: x*weight1) | |
| part1=part1.iloc[-4:,].rank(axis=0,pct=True) | |
| temp2=self.avg_price.diff(3) | |
| temp2=temp2.iloc[-m:,:] | |
| part2=temp2.apply(lambda x: x*weight2) | |
| part2=part1.iloc[-5:,].rank(axis=0,pct=True) | |
| alpha=part1.iloc[-1,:]+part2.iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| ################################################################## | |
| def alpha_045(self): | |
| temp1=self.close*0.6+self.open_price*0.4 | |
| part1=temp1.diff() | |
| part1=part1.rank(axis=1,pct=True) | |
| temp2=pd.rolling_mean(self.volume,150) | |
| part2=pd.rolling_corr(self.avg_price,temp2,15) | |
| part2=part2.rank(axis=1,pct=True) | |
| result=part1*part2 | |
| alpha=result.iloc[-1,:].dropna() | |
| return alpha | |
| ################################################################## | |
| def alpha_046(self): | |
| part1=pd.rolling_mean(self.close,3) | |
| part2=pd.rolling_mean(self.close,6) | |
| part3=pd.rolling_mean(self.close,12) | |
| part4=pd.rolling_mean(self.close,24) | |
| result=(part1+part2+part3+part4)*0.25/self.close | |
| alpha=result.iloc[-1,:].dropna() | |
| return alpha | |
| ################################################################## | |
| def alpha_047(self): | |
| part1=pd.rolling_max(self.high,6)-self.close | |
| part2=pd.rolling_max(self.high,6)- pd.rolling_min(self.low,6) | |
| result=pd.ewma(100*part1/part2,alpha=1.0/9) | |
| alpha=result.iloc[-1,:].dropna() | |
| return alpha | |
| ################################################################## | |
| def alpha_048(self): | |
| condition1=(self.close>self.close.shift()) | |
| condition2=(self.close.shift()>self.close.shift(2)) | |
| condition3=(self.close.shift(2)>self.close.shift(3)) | |
| indicator1=pd.DataFrame(np.ones(self.close.shape),index=self.close.index,columns=self.close.columns)[condition1].fillna(0) | |
| indicator2=pd.DataFrame(np.ones(self.close.shape),index=self.close.index,columns=self.close.columns)[condition2].fillna(0) | |
| indicator3=pd.DataFrame(np.ones(self.close.shape),index=self.close.index,columns=self.close.columns)[condition3].fillna(0) | |
| indicator11=-pd.DataFrame(np.ones(self.close.shape),index=self.close.index,columns=self.close.columns)[(~condition1)&(self.close!=self.close.shift())].fillna(0) | |
| indicator22=-pd.DataFrame(np.ones(self.close.shape),index=self.close.index,columns=self.close.columns)[(~condition2)&(self.close.shift()!=self.close.shift(2))].fillna(0) | |
| indicator33=-pd.DataFrame(np.ones(self.close.shape),index=self.close.index,columns=self.close.columns)[(~condition3)&(self.close.shift(2)!=self.close.shift(3))].fillna(0) | |
| summ=indicator1+indicator2+indicator3+indicator11+indicator22+indicator33 | |
| result=-summ*pd.rolling_sum(self.volume,5)/pd.rolling_sum(self.volume,20) | |
| alpha=result.iloc[-1,:].dropna() | |
| return alpha | |
| ################################################################## | |
| def alpha_049(self): | |
| delay_high=self.high.shift() | |
| delay_low=self.low.shift() | |
| condition1=(self.high+self.low>=delay_high+delay_low) | |
| condition2=(self.high+self.low<=delay_high+delay_low) | |
| part1=np.maximum(np.abs(self.high-delay_high),np.abs(self.low-delay_low)) | |
| part1=part1[~condition1] | |
| part1=part1.iloc[-12:,:].sum() | |
| part2=np.maximum(np.abs(self.high-delay_high),np.abs(self.low-delay_low)) | |
| part2=part2[~condition2] | |
| part2=part2.iloc[-12:,:].sum() | |
| result=part1/(part1+part2) | |
| alpha=result.dropna() | |
| return alpha | |
| ################################################################## | |
| def alpha_050(self): | |
| return 0 | |
| ################################################################## | |
| def alpha_051(self): | |
| return 0 | |
| ################################################################## | |
| def alpha_052(self): | |
| delay=((self.high+self.low+self.close)/3).shift() | |
| part1=(np.maximum(self.high-delay,0)).iloc[-26:,:] | |
| part2=(np.maximum(delay-self.low,0)).iloc[-26:,:] | |
| alpha=part1.sum()+part2.sum() | |
| return alpha | |
| ################################################################## | |
| def alpha_053(self): | |
| delay=self.close.shift() | |
| condition=self.close>delay | |
| result=self.close[condition].iloc[-12:,:] | |
| alpha=result.count()*100/12 | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_054(self): | |
| part1=(self.close-self.open_price).abs() | |
| part1=part1.std() | |
| part2=(self.close-self.open_price).iloc[-1,:] | |
| part3=self.close.iloc[-10:,:].corrwith(self.open_price.iloc[-10:,:]) | |
| result=(part1+part2+part3).dropna() | |
| alpha=result.rank(pct=True) | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_055(self): | |
| return 0 | |
| ################################################################## | |
| def alpha_056(self): | |
| part1=self.open_price.iloc[-1,:]-self.open_price.iloc[-12:,:].min() | |
| part1=part1.rank(pct=1) | |
| temp1=(self.high+self.low)/2 | |
| temp1=pd.rolling_sum(temp1,19) | |
| temp2=pd.rolling_sum(pd.rolling_mean(self.volume,40),19) | |
| part2=temp1.iloc[-13:,:].corrwith(temp2.iloc[-13:,:]) | |
| part2=(part2.rank(pct=1))**5 | |
| part2=part2.rank(pct=1) | |
| part1[part1<part2]=1 | |
| part1=part1.apply(lambda x: 0 if x <1 else None) | |
| alpha=part1.fillna(1) | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_057(self): | |
| part1=self.close-pd.rolling_min(self.low,9) | |
| part2=pd.rolling_max(self.high,9)-pd.rolling_min(self.low,9) | |
| result=pd.ewma(100*part1/part2,alpha=1.0/3) | |
| alpha=result.iloc[-1,:] | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_058(self): | |
| delay=self.close.shift() | |
| condition=self.close>delay | |
| result=self.close[condition].iloc[-20:,:] | |
| alpha=result.count()*100/20 | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_059(self): | |
| delay=self.close.shift() | |
| condition1=(self.close>delay) | |
| condition2=(self.close<delay) | |
| part1=np.minimum(self.low[condition1],delay[condition1]).fillna(0) | |
| part2=np.maximum(self.high[condition2],delay[condition2]).fillna(0) | |
| part1=part1.iloc[-20:,:] | |
| part2=part2.iloc[-20:,:] | |
| result=self.close-part1-part2 | |
| alpha=result.sum() | |
| return alpha | |
| ################################################################## | |
| def alpha_060(self): | |
| part1=(self.close.iloc[-20:,:]-self.low.iloc[-20:,:])-(self.high.iloc[-20:,:]-self.close.iloc[-20:,:]) | |
| part2=self.high.iloc[-20:,:]-self.low.iloc[-20:,:] | |
| result=self.volume.iloc[-20:,:]*part1/part2 | |
| alpha=result.sum() | |
| return alpha | |
| ################################################################## | |
| def alpha_061(self): | |
| n=12 | |
| m=17 | |
| temp1=self.avg_price.diff() | |
| temp1=temp1.iloc[-n:,:] | |
| seq1=[2*i/(n*(n+1)) for i in range(1,n+1)] | |
| seq2=[2*i/(m*(m+1)) for i in range(1,m+1)] | |
| weight1=np.array(seq1) | |
| weight2=np.array(seq2) | |
| part1=temp1.apply(lambda x: x*weight1) | |
| part1=part1.rank(axis=1,pct=True) | |
| temp2=self.low | |
| temp2=pd.rolling_corr(temp2,pd.rolling_mean(self.volume,80),8) | |
| temp2=temp2.rank(axis=1,pct=1) | |
| temp2=temp2.iloc[-m:,:] | |
| part2=temp2.apply(lambda x: x*weight2) | |
| part2=-part2.rank(axis=1,pct=1) | |
| alpha=np.maximum(part1.iloc[-1,:],part2.iloc[-1,:]) | |
| alpha=alpha[(alpha<np.inf)&(alpha>-np.inf)] | |
| alpha=alpha.dropna() | |
| return alpha | |
| ################################################################## | |
| def alpha_062(self): | |
| volume_rank=self.volume.rank(axis=1,pct=1) | |
| result=self.high.iloc[-5:,:].corrwith(volume_rank.iloc[-5:,:]) | |
| alpha=-result | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_063(self): | |
| part1=np.maximum(self.close-self.close.shift(),0) | |
| part1=pd.ewma(part1,alpha=1.0/6) | |
| part2=(self.close-self.close.shift()).abs() | |
| part2=pd.ewma(part2,alpha=1.0/6) | |
| result=part1*100/part2 | |
| alpha=result.iloc[-1,:] | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_064(self): | |
| n=4 | |
| m=14 | |
| temp1=pd.rolling_corr(self.avg_price.rank(axis=1,pct=1),self.volume.rank(axis=1,pct=1),4) | |
| temp1=temp1.iloc[-n:,:] | |
| seq1=[2*i/(n*(n+1)) for i in range(1,n+1)] | |
| seq2=[2*i/(m*(m+1)) for i in range(1,m+1)] | |
| weight1=np.array(seq1) | |
| weight2=np.array(seq2) | |
| part1=temp1.apply(lambda x: x*weight1) | |
| part1=part1.rank(axis=1,pct=True) | |
| temp2=self.close.rank(axis=1,pct=1) | |
| temp2=pd.rolling_corr(temp2,pd.rolling_mean(self.volume,60),4) | |
| temp2=np.maximum(temp2,13) | |
| temp2=temp2.iloc[-m:,:] | |
| part2=temp2.apply(lambda x: x*weight2) | |
| part2=-part2.rank(axis=1,pct=1) | |
| alpha=np.maximum(part1.iloc[-1,:],part2.iloc[-1,:]) | |
| alpha=alpha[(alpha<np.inf)&(alpha>-np.inf)] | |
| alpha=alpha.dropna() | |
| return alpha | |
| ################################################################## | |
| def alpha_065(self): | |
| part1=self.close.iloc[-6:,:] | |
| alpha=part1.mean()/self.close.iloc[-1,:] | |
| return alpha.dropna() | |
| ################################################################## | |
| def alpha_066(self): | |
| part1=self.close.iloc[-6:,:] | |
| alpha=(self.close.iloc[-1,:]-part1.mean())/part1.mean() | |
| return alpha | |
| ################################################################## | |
| def alpha_067(self): | |
| temp1=self.close-self.close.shift() | |
| part1=np.maximum(temp1,0) | |
| part1=pd.ewma(part1,alpha=1.0/24) | |
| temp2=temp1.abs() | |
| part2=pd.ewma(temp2,alpha=1.0/24) | |
| result=part1*100/part2 | |
| alpha=result.iloc[-1,:].dropna() | |
| return alpha | |
| ################################################################## | |
| def alpha_068(self): | |
| part1=(self.high+self.low)/2-self.high.shift() | |
| part2=0.5*self.low.shift()*(self.high-self.low)/self.volume | |
| result=(part1+part2)*100 | |
| result=pd.ewma(result,alpha=2.0/15) | |
| alpha=result.iloc[-1,:].dropna() | |
| return alpha | |
| ################################################################## | |
| def alpha_069(self): | |
| return 0 | |
| ################################################################## | |
| def alpha_070(self): | |
| #### STD(AMOUNT, 6) | |
| ## | |
| alpha = self.amount.iloc[-6:,:].std().dropna() | |
| return alpha | |
| ############################################################################# | |
| def alpha_071(self): | |
| # (CLOSE-MEAN(CLOSE,24))/MEAN(CLOSE,24)*100 | |
| # | |
| data = self.close - pd.rolling_mean(self.close, 24) / pd.rolling_mean(self.close, 24) | |
| alpha = data.iloc[-1].dropna() | |
| return alpha | |
| ############################################################################# | |
| def alpha_072(self): | |
| #SMA((TSMAX(HIGH,6)-CLOSE)/(TSMAX(HIGH,6)-TSMIN(LOW,6))*100,15,1) | |
| # | |
| data1 = pd.rolling_max(self.high, 6) - self.close | |
| data2 = pd.rolling_max(self.high, 6) - pd.rolling_min(self.low, 6) | |
| alpha = pd.ewma(data1 / data2 * 100, alpha=1/15).iloc[-1].dropna() | |
| return alpha | |
| ############################################################################# | |
| def alpha_073(self): | |
| return 0 | |
| ############################################################################# | |
| def alpha_074(self): | |
| #(RANK(CORR(SUM(((LOW * 0.35) + (VWAP * 0.65)), 20), SUM(MEAN(VOLUME,40), 20), 7)) + RANK(CORR(RANK(VWAP), RANK(VOLUME), 6))) | |
| # | |
| data1 = pd.rolling_sum((self.low * 0.35 + self.avg_price * 0.65), window=20) | |
| data2 = pd.rolling_mean(self.volume, window=40) | |
| rank1 = pd.rolling_corr(data1, data2, window=7).rank(axis=1, pct=True) | |
| data3 = self.avg_price.rank(axis=1, pct=True) | |
| data4 = self.volume.rank(axis=1, pct=True) | |
| rank2 = pd.rolling_corr(data3, data4, window=6).rank(axis=1, pct=True) | |
| alpha = (rank1 + rank2).iloc[-1].dropna() | |
| return alpha | |
| ############################################################################# | |
| def alpha_075(self): | |
| #COUNT(CLOSE>OPEN & BANCHMARKINDEXCLOSE<BANCHMARKINDEXOPEN,50)/COUNT(BANCHMARKINDEXCLOSE<BANCHMARKINDEXOPEN,50) | |
| # | |
| benchmark = get_price('000001.SH', None, end_date, '1d', ['open','close'], False, None, 50) | |
| condition = benchmark['close'] < benchmark['open'] | |
| data1 = benchmark[condition] | |
| numbench = len(data1) | |
| timelist = data1.index.tolist() | |
| data2 = pd.merge(self.close, data1, left_index=True, right_index=True).drop(['close', 'open'], axis=1) | |
| data3 = pd.merge(self.open_price, data1, left_index=True, right_index=True).drop(['close', 'open'], axis=1) | |
| data4 = data2[data2 > data3] | |
| alpha = 1 - data4.isnull().sum(axis=0) / numbench | |
| return alpha | |
| ############################################################################# | |
| def alpha_076(self): | |
| #STD(ABS((CLOSE/DELAY(CLOSE,1)-1))/VOLUME,20)/MEAN(ABS((CLOSE/DELAY(CLOSE,1)-1))/VOLUME,20) | |
| # | |
| data1 = abs((self.close / ((self.prev_close - 1) / self.volume).shift(20))).std() | |
| data2 = abs((self.close / ((self.prev_close - 1) / self.volume).shift(20))).mean() | |
| alpha = (data1 / data2).dropna() | |
| return alpha | |
| ############################################################################# | |
| def alpha_077(self): | |
| #MIN(RANK(DECAYLINEAR(((((HIGH + LOW) / 2) + HIGH) - (VWAP + HIGH)), 20)), RANK(DECAYLINEAR(CORR(((HIGH + LOW) / 2), MEAN(VOLUME,40), 3), 6))) | |
| # | |
| data1 = ((self.high + self.low) / 2 + self.high - (self.avg_price + self.high)).iloc[-20:,:] | |
| decay_weights = np.arange(1,20+1,1)[::-1] | |
| decay_weights = decay_weights / decay_weights.sum() | |
| rank1 = data1.apply(lambda x : x * decay_weights).rank(axis=1, pct=True) | |
| data2 = pd.rolling_corr((self.high + self.low)/2, pd.rolling_mean(self.volume, window=40), window=3).iloc[-6:,:] | |
| decay_weights2 = np.arange(1,6+1,1)[::-1] | |
| decay_weights2 = decay_weights2 / decay_weights2.sum() | |
| rank2 = data2.apply(lambda x : x * decay_weights2).rank(axis=1, pct=True) | |
| alpha = np.minimum(rank1.iloc[-1], rank2.iloc[-1]) | |
| return alpha | |
| ############################################################################# | |
| def alpha_078(self): | |
| #((HIGH+LOW+CLOSE)/3-MA((HIGH+LOW+CLOSE)/3,12))/(0.015*MEAN(ABS(CLOSE-MEAN((HIGH+LOW+CLOSE)/3,12)),12)) | |
| # | |
| data1 = (self.high + self.low + self.close) / 3 - pd.rolling_mean((self.high + self.low + self.close) / 3, window=12) | |
| data2 = abs(self.close - pd.rolling_mean((self.high + self.low + self.close) / 3, window=12)) | |
| data3 = pd.rolling_mean(data2, window=12) * 0.015 | |
| alpha = (data1 / data3).iloc[-1].dropna() | |
| return alpha | |
| ############################################################################# | |
| def alpha_079(self): | |
| #SMA(MAX(CLOSE-DELAY(CLOSE,1),0),12,1)/SMA(ABS(CLOSE-DELAY(CLOSE,1)),12,1)*100 | |
| # | |
| data1 = pd.ewma(np.maximum((self.close - self.prev_close), 0), alpha=1/12) | |
| data2 = pd.ewma(abs(self.close - self.prev_close), alpha=1/12) | |
| alpha = (data1 / data2 * 100).iloc[-1].dropna() | |
| return alpha | |
| ############################################################################# | |
| def alpha_080(self): | |
| #(VOLUME-DELAY(VOLUME,5))/DELAY(VOLUME,5)*100 | |
| # | |
| alpha = ((self.volume - self.volume.shift(5))/self.volume.shift(5) * 100).iloc[-1].dropna() | |
| return alpha | |
| ############################################################################# | |
| def alpha_081(self): | |
| result=pd.ewma(self.volume,alpha=2.0/21) | |
| alpha=result.iloc[-1,:].dropna() | |
| return alpha | |
| ############################################################################# | |
| def alpha_082(self): | |
| part1=pd.rolling_max(self.high,6)-self.close | |
| part2=pd.rolling_max(self.high,6)-pd.rolling_min(self.low,6) | |
| result=pd.ewma(100*part1/part2,alpha=1.0/20) | |
| alpha=result.iloc[-1,:].dropna() | |
| return alpha | |
| ############################################################################# | |
| def alpha_083(self): | |
| part1=self.high.rank(axis=0,pct=True) | |
| part1=part1.iloc[-5:,:] | |
| part2=self.volume.rank(axis=0,pct=True) | |
| part2=part2.iloc[-5:,:] | |
| result=part1.corrwith(part2) | |
| alpha=-result | |
| return alpha.dropna() | |
| ############################################################################# | |
| def alpha_084(self): | |
| condition1=(self.close>self.close.shift()) | |
| condition2=(self.close<self.close.shift()) | |
| part1=self.volume[condition1].fillna(0) | |
| part2=-self.volume[condition2].fillna(0) | |
| result=part1.iloc[-20:,:]+part2.iloc[-20:,:] | |
| alpha=result.sum().dropna() | |
| return alpha | |
| ############################################################################# | |
| def alpha_085(self): | |
| temp1=self.volume.iloc[-20:,:]/self.volume.iloc[-20:,:].mean() | |
| temp1=temp1 | |
| part1=temp1.rank(axis=0,pct=True) | |
| part1=part1.iloc[-1,:] | |
| delta=self.close.diff(7) | |
| temp2=-delta.iloc[-8:,:] | |
| part2=temp2.rank(axis=0,pct=True).iloc[-1,:] | |
| part2=part2 | |
| alpha=part1*part2 | |
| return alpha.dropna() | |
| ############################################################################# | |
| def alpha_086(self): | |
| delay10=self.close.shift(10) | |
| delay20=self.close.shift(20) | |
| indicator1=pd.DataFrame(-np.ones(self.close.shape),index=self.close.index,columns=self.close.columns) | |
| indicator2=pd.DataFrame(np.ones(self.close.shape),index=self.close.index,columns=self.close.columns) | |
| temp=(delay20-delay10)/10-(delay10-self.close)/10 | |
| condition1=(temp>0.25) | |
| condition2=(temp<0) | |
| temp2=(self.close-self.close.shift())*indicator1 | |
| part1=indicator1[condition1].fillna(0) | |
| part2=indicator2[~condition1][condition2].fillna(0) | |
| part3=temp2[~condition1][~condition2].fillna(0) | |
| result=part1+part2+part3 | |
| alpha=result.iloc[-1,:].dropna() | |
| return alpha | |
| ############################################################################# | |
| def alpha_087(self): | |
| n=7 | |
| m=11 | |
| temp1=self.avg_price.diff(4) | |
| temp1=temp1.iloc[-n:,:] | |
| seq1=[2*i/(n*(n+1)) for i in range(1,n+1)] | |
| seq2=[2*i/(m*(m+1)) for i in range(1,m+1)] | |
| weight1=np.array(seq1) | |
| weight2=np.array(seq2) | |
| part1=temp1.apply(lambda x: x*weight1) | |
| part1=part1.rank(axis=1,pct=True) | |
| temp2=self.low-self.avg_price | |
| temp3=self.open_price-0.5*(self.high+self.low) | |
| temp2=temp2/temp3 | |
| temp2=temp2.iloc[-m:,:] | |
| part2=-temp2.apply(lambda x: x*weight2) | |
| part2=part2.rank(axis=0,pct=1) | |
| alpha=part1.iloc[-1,:]+part2.iloc[-1,:] | |
| alpha=alpha[(alpha<np.inf)&(alpha>-np.inf)] | |
| alpha=alpha.dropna() | |
| return alpha | |
| ''' | |
| ######################################################################## | |
| ''' | |
| def alpha_88(self): | |
| #(close-delay(close,20))/delay(close,20)*100 | |
| #################### | |
| data1=self.close.iloc[-21,:] | |
| alpha=((self.close.iloc[-1,:]-data1)/data1)*100 | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_89(self): | |
| #2*(sma(close,13,2)-sma(close,27,2)-sma(sma(close,13,2)-sma(close,27,2),10,2)) | |
| ###################### | |
| data1=pd.ewma(self.close,span=12,adjust=False) | |
| data2=pd.ewma(self.close,span=26,adjust=False) | |
| data3=pd.ewma(data1-data2,span=9,adjust=False) | |
| alpha=((data1-data2-data3)*2).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_90(self): | |
| #(rank(corr(rank(vwap),rank(volume),5))*-1) | |
| ####################### | |
| data1=self.avg_price.rank(axis=1,pct=True) | |
| data2=self.volume.rank(axis=1,pct=True) | |
| corr=data1.iloc[-5:,:].corrwith(data2.iloc[-5:,:]) | |
| rank1=corr.rank(pct=True) | |
| alpha=rank1*-1 | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_91(self): | |
| #((rank((close-max(close,5)))*rank(corr((mean(volume,40)),low,5)))*-1) | |
| ################# | |
| data1=self.close | |
| cond=data1>5 | |
| data1[~cond]=5 | |
| rank1=((self.close-data1).rank(axis=1,pct=True)).iloc[-1,:] | |
| mean=pd.rolling_mean(self.volume,window=40) | |
| corr=mean.iloc[-5:,:].corrwith(self.low.iloc[-5:,:]) | |
| rank2=corr.rank(pct=True) | |
| alpha=rank1*rank2*(-1) | |
| alpha=alpha.dropna() | |
| return alpha | |
| # | |
| def alpha_92(self): | |
| # (MAX(RANK(DECAYLINEAR(DELTA(((CLOSE*0.35)+(VWAP*0.65)),2),3)),TSRANK(DECAYLINEAR(ABS(CORR((MEAN(VOLUME,180)),CLOSE,13)),5),15))*-1) # | |
| delta = (self.close*0.35+self.avg_price*0.65)-(self.close*0.35+self.avg_price*0.65).shift(2) | |
| rank1 = (pd.rolling_apply(delta, 3, self.func_decaylinear)).rank(axis=1, pct=True) | |
| rank2 = pd.rolling_apply(pd.rolling_apply(self.volume.rolling(180).mean().rolling(13).corr(self.close).abs(), 5, self.func_decaylinear), 15, self.func_rank) | |
| cond_max = rank1>rank2 | |
| rank2[cond_max] = rank1[cond_max] | |
| alpha = (-rank2).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| # | |
| def alpha_93(self): | |
| # SUM((OPEN>=DELAY(OPEN,1)?0:MAX((OPEN-LOW),(OPEN-DELAY(OPEN,1)))),20) # | |
| cond = self.open_price>=self.open_price.shift() | |
| data1 = self.open_price-self.low | |
| data2 = self.open_price-self.open_price.shift() | |
| cond_max = data1>data2 | |
| data2[cond_max] = data1[cond_max] | |
| data2[cond] = 0 | |
| alpha = data2.iloc[-20:,:].sum() | |
| alpha=alpha.dropna() | |
| return alpha | |
| # | |
| def alpha_94(self): | |
| # SUM((CLOSE>DELAY(CLOSE,1)?VOLUME:(CLOSE<DELAY(CLOSE,1)?-VOLUME:0)),30) # | |
| cond1 = self.close>self.prev_close | |
| cond2 = self.close<self.prev_close | |
| value = -self.volume | |
| value[~cond2] = 0 | |
| value[cond1] = self.volume[cond1] | |
| alpha = value.iloc[-30:,:].sum() | |
| alpha=alpha.dropna() | |
| return alpha | |
| # | |
| def alpha_95(self): | |
| # STD(AMOUNT,20) # | |
| alpha = self.amount.iloc[-20:,:].std() | |
| alpha=alpha.dropna() | |
| return alpha | |
| # | |
| def alpha_96(self): | |
| # SMA(SMA((CLOSE-TSMIN(LOW,9))/(TSMAX(HIGH,9)-TSMIN(LOW,9))*100,3,1),3,1) # | |
| sma1 = pd.ewma(100*(self.close-self.low.rolling(9).min())/(self.high.rolling(9).max()-self.low.rolling(9).min()), span=5, adjust=False) | |
| alpha = pd.ewma(sma1, span=5, adjust=False).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| # | |
| def alpha_97(self): | |
| # STD(VOLUME,10) # | |
| alpha = self.volume.iloc[-10:,:].std() | |
| alpha=alpha.dropna() | |
| return alpha | |
| # | |
| def alpha_98(self): | |
| # ((((DELTA((SUM(CLOSE,100)/100),100)/DELAY(CLOSE,100))<0.05)||((DELTA((SUM(CLOSE,100)/100),100)/DELAY(CLOSE,100))==0.05))?(-1*(CLOSE-TSMIN(CLOSE,100))):(-1*DELTA(CLOSE,3))) # | |
| sum_close = self.close.rolling(100).sum() | |
| cond = (sum_close/100-(sum_close/100).shift(100))/self.close.shift(100) <= 0.05 | |
| left_value = -(self.close-self.close.rolling(100).min()) | |
| right_value = -(self.close-self.close.shift(3)) | |
| right_value[cond] = left_value[cond] | |
| alpha = right_value.iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| # | |
| def alpha_99(self): | |
| # (-1 * RANK(COVIANCE(RANK(CLOSE), RANK(VOLUME), 5))) # | |
| alpha = (-pd.rolling_cov(self.close.rank(axis=1, pct=True), self.volume.rank(axis=1, pct=True), window=5).rank(axis=1, pct=True)).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| # | |
| def alpha_100(self): | |
| # STD(VOLUME,20) # | |
| alpha = self.volume.iloc[-20:,:].std() | |
| alpha=alpha.dropna() | |
| return alpha | |
| # | |
| def alpha_101(self): | |
| # ((RANK(CORR(CLOSE,SUM(MEAN(VOLUME,30),37),15))<RANK(CORR(RANK(((HIGH*0.1)+(VWAP*0.9))),RANK(VOLUME),11)))*-1) # | |
| rank1 = (self.close.rolling(window=15).corr((self.volume.rolling(window=30).mean()).rolling(window=37).sum())).rank(axis=1, pct=True) | |
| rank2 = (self.high*0.1+self.avg_price*0.9).rank(axis=1, pct=True) | |
| rank3 = self.volume.rank(axis=1, pct=True) | |
| rank4 = (rank2.rolling(window=11).corr(rank3)).rank(axis=1, pct=True) | |
| alpha = -(rank1<rank4) | |
| alpha=alpha.iloc[-1,:].dropna() | |
| return alpha | |
| # | |
| def alpha_102(self): | |
| # SMA(MAX(VOLUME-DELAY(VOLUME,1),0),6,1)/SMA(ABS(VOLUME-DELAY(VOLUME,1)),6,1)*100 # | |
| max_cond = (self.volume-self.volume.shift())>0 | |
| max_data = self.volume-self.volume.shift() | |
| max_data[~max_cond] = 0 | |
| sma1 = pd.ewma(max_data, span=11, adjust=False) | |
| sma2 = pd.ewma((self.volume-self.volume.shift()).abs(), span=11, adjust=False) | |
| alpha = (sma1/sma2*100).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_103(self): | |
| ##### ((20-LOWDAY(LOW,20))/20)*100 | |
| ## | |
| alpha = (20 - self.low.iloc[-20:,:].apply(self.func_lowday))/20*100 | |
| alpha=alpha.dropna() | |
| return alpha | |
| # | |
| def alpha_104(self): | |
| # (-1*(DELTA(CORR(HIGH,VOLUME,5),5)*RANK(STD(CLOSE,20)))) # | |
| corr = self.high.rolling(window=5).corr(self.volume) | |
| alpha = (-(corr-corr.shift(5))*((self.close.rolling(window=20).std()).rank(axis=1, pct=True))).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| # | |
| def alpha_105(self): | |
| # (-1*CORR(RANK(OPEN),RANK(VOLUME),10)) # | |
| alpha = -((self.open_price.rank(axis=1, pct=True)).iloc[-10:,:]).corrwith(self.volume.iloc[-10:,:].rank(axis=1, pct=True)) | |
| alpha=alpha.dropna() | |
| return alpha | |
| # | |
| def alpha_106(self): | |
| # CLOSE-DELAY(CLOSE,20) # | |
| alpha = (self.close-self.close.shift(20)).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| # | |
| def alpha_107(self): | |
| # (((-1*RANK((OPEN-DELAY(HIGH,1))))*RANK((OPEN-DELAY(CLOSE,1))))*RANK((OPEN-DELAY(LOW,1)))) # | |
| rank1 = -(self.open_price-self.high.shift()).rank(axis=1, pct=True) | |
| rank2 = (self.open_price-self.close.shift()).rank(axis=1, pct=True) | |
| rank3 = (self.open_price-self.low.shift()).rank(axis=1, pct=True) | |
| alpha = (rank1*rank2*rank3).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| # | |
| def alpha_108(self): | |
| # ((RANK((HIGH-MIN(HIGH,2)))^RANK(CORR((VWAP),(MEAN(VOLUME,120)),6)))*-1) # | |
| min_cond = self.high>2 | |
| data = self.high | |
| data[min_cond] = 2 | |
| rank1 = (self.high-data).rank(axis=1, pct=True) | |
| rank2 = (self.avg_price.rolling(window=6).corr(self.volume.rolling(window=120).mean())).rank(axis=1, pct=True) | |
| alpha = (-rank1**rank2).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| # | |
| def alpha_109(self): | |
| # SMA(HIGH-LOW,10,2)/SMA(SMA(HIGH-LOW,10,2),10,2)# | |
| data = self.high-self.low | |
| sma1 = pd.ewma(data, span=9, adjust=False) | |
| sma2 = pd.ewma(sma1, span=9, adjust=False) | |
| alpha = (sma1/sma2).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| # | |
| def alpha_110(self): | |
| # SUM(MAX(0,HIGH-DELAY(CLOSE,1)),20)/SUM(MAX(0,DELAY(CLOSE,1)-LOW),20)*100 # | |
| data1 = self.high-self.prev_close | |
| data2 = self.prev_close-self.low | |
| max_cond1 = data1<0 | |
| max_cond2 = data2<0 | |
| data1[max_cond1] = 0 | |
| data2[max_cond2] = 0 | |
| sum1 = data1.rolling(window=20).sum() | |
| sum2 = data2.rolling(window=20).sum() | |
| alpha = sum1/sum2*100 | |
| alpha=alpha.dropna() | |
| return alpha.iloc[-1,:] | |
| def alpha_111(self): | |
| #sma(vol*((close-low)-(high-close))/(high-low),11,2)-sma(vol*((close-low)-(high-close))/(high-low),4,2) | |
| ###################### | |
| data1=self.volume*((self.close-self.low)-(self.high-self.close))/(self.high-self.low) | |
| x=pd.ewma(data1,span=10) | |
| y=pd.ewma(data1,span=3) | |
| alpha=(x-y).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| # | |
| def alpha_112(self): | |
| # (SUM((CLOSE-DELAY(CLOSE,1)>0?CLOSE-DELAY(CLOSE,1):0),12)-SUM((CLOSE-DELAY(CLOSE,1)<0?ABS(CLOSE-DELAY(CLOSE,1)):0),12))/(SUM((CLOSE-DELAY(CLOSE,1)>0?CLOSE-DELAY(CLOSE,1):0),12)+SUM((CLOSE-DELAY(CLOSE,1)<0?ABS(CLOSE-DELAY(CLOSE,1)):0),12))*100 # | |
| cond1 = self.close>self.prev_close | |
| cond2 = self.close<self.prev_close | |
| data1 = self.close-self.prev_close | |
| data2 = self.close-self.prev_close | |
| data1[~cond1] = 0 | |
| data2[~cond2] = 0 | |
| data2 = data2.abs() | |
| sum1 = data1.rolling(window=12).sum() | |
| sum2 = data2.rolling(window=12).sum() | |
| alpha = ((sum1-sum2)/(sum1+sum2)*100).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_113(self): | |
| #(-1*((rank((sum(delay(close,5),20)/20))*corr(close,volume,2))*rank(corr(sum(close,5),sum(close,20),2)))) | |
| ##################### | |
| data1=self.close.iloc[:-5,:] | |
| rank1=(pd.rolling_sum(data1,window=20)/20).rank(axis=1,pct=True) | |
| corr1=self.close.iloc[-2:,:].corrwith(self.volume.iloc[-2:,:]) | |
| data2=pd.rolling_sum(self.close,window=5) | |
| data3=pd.rolling_sum(self.close,window=20) | |
| corr2=data2.iloc[-2:,:].corrwith(data3.iloc[-2:,:]) | |
| rank2=corr2.rank(axis=0,pct=True) | |
| alpha=(-1*rank1*corr1*rank2).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_114(self): | |
| #((rank(delay(((high-low)/(sum(close,5)/5)),2))*rank(rank(volume)))/(((high-low)/(sum(close,5)/5))/(vwap-close))) | |
| ##################### | |
| data1=(self.high-self.low)/(pd.rolling_sum(self.close,window=5)/5) | |
| rank1=(data1.iloc[-2,:]).rank(axis=0,pct=True) | |
| rank2=((self.volume.rank(axis=1,pct=True)).rank(axis=1,pct=True)).iloc[-1,:] | |
| data2=(((self.high-self.low)/(pd.rolling_sum(self.close,window=5)/5))/(self.avg_price-self.close)).iloc[-1,:] | |
| alpha=(rank1*rank2)/data2 | |
| alpha=alpha.dropna() | |
| return alpha | |
| # | |
| def alpha_115(self): | |
| # RANK(CORR(((HIGH*0.9)+(CLOSE*0.1)),MEAN(VOLUME,30),10))^RANK(CORR(TSRANK(((HIGH+LOW)/2),4),TSRANK(VOLUME,10),7)) # | |
| data1 = (self.high*0.9+self.close*0.1) | |
| data2 = self.volume.rolling(window=30).mean() | |
| rank1 = (data1.iloc[-10:,:].corrwith(data2.iloc[-10:,:])).rank(pct=True) | |
| tsrank1 = pd.rolling_apply((self.high+self.low)/2, 4, self.func_rank) | |
| tsrank2 = pd.rolling_apply(self.volume, 10, self.func_rank) | |
| rank2 = tsrank1.iloc[-7:,:].corrwith(tsrank2.iloc[-7:,:]).rank(pct=True) | |
| alpha = rank1**rank2 | |
| alpha=alpha.dropna() | |
| return alpha | |
| # | |
| def alpha_116(self): | |
| # REGBETA(CLOSE,SEQUENCE,20) # | |
| sequence = pd.Series(range(1,21), index=self.close.iloc[-20:,].index) # 1~20 | |
| corr = self.close.iloc[-20:,:].corrwith(sequence) | |
| alpha = corr | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_117(self): | |
| #######((tsrank(volume,32)*(1-tsrank(((close+high)-low),16)))*(1-tsrank(ret,32))) | |
| #################### | |
| data1=(self.close+self.high-self.low).iloc[-16:,:] | |
| data2=1-data1.rank(axis=0,pct=True) | |
| data3=(self.volume.iloc[-32:,:]).rank(axis=0,pct=True) | |
| ret=(self.close/self.close.shift()-1).iloc[-32:,:] | |
| data4=1-ret.rank(axis=0,pct=True) | |
| alpha=(data2.iloc[-1,:])*(data3.iloc[-1,:])*(data4.iloc[-1,:]) | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_118(self): | |
| ######sum(high-open,20)/sum((open-low),20)*100 | |
| ################### | |
| data1=self.high-self.open_price | |
| data2=self.open_price-self.low | |
| data3=pd.rolling_sum(data1,window=20) | |
| data4=pd.rolling_sum(data2,window=20) | |
| alpha=((data3/data4)*100).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| # | |
| def alpha_119(self): | |
| # (RANK(DECAYLINEAR(CORR(VWAP,SUM(MEAN(VOLUME,5),26),5),7))-RANK(DECAYLINEAR(TSRANK(MIN(CORR(RANK(OPEN),RANK(MEAN(VOLUME,15)),21),9),7),8))) | |
| sum1 = (self.volume.rolling(window=5).mean()).rolling(window=26).sum() | |
| corr1 = self.avg_price.rolling(window=5).corr(sum1) | |
| rank1 = pd.rolling_apply(corr1, 7, self.func_decaylinear).rank(axis=1, pct=True) | |
| rank2 = self.open_price.rank(axis=1, pct=True) | |
| rank3 = (self.volume.rolling(window=15).mean()).rank(axis=1, pct=True) | |
| rank4 = pd.rolling_apply(rank2.rolling(window=21).corr(rank3).rolling(window=9).min(), 7, self.func_rank) | |
| rank5 = pd.rolling_apply(rank4, 8, self.func_decaylinear).rank(axis=1, pct=True) | |
| alpha = (rank1 - rank5).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_120(self): | |
| ###############(rank(vwap-close))/(rank(vwap+close)) | |
| ################### | |
| data1=(self.avg_price-self.close).rank(axis=1,pct=True) | |
| data2=(self.avg_price+self.close).rank(axis=1,pct=True) | |
| alpha=(data1/data2).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_121(self): | |
| return 0 | |
| def alpha_122(self): | |
| ##### (SMA(SMA(SMA(LOG(CLOSE),13,2),13,2),13,2) - DELAY(SMA(SMA(SMA(LOG(CLOSE),13,2),13,2),13,2),1)) | |
| ##### / DELAY(SMA(SMA(SMA(LOG(CLOSE),13,2),13,2),13,2),1) | |
| ## | |
| log_close = np.log(self.close) | |
| data = pd.ewma(pd.ewma(pd.ewma(log_close, span=12, adjust=False), span=12, adjust=False), span=12, adjust=False) | |
| alpha = (data.iloc[-1,:] / data.iloc[-2,:]) -1 | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_123(self): | |
| #####((RANK(CORR(SUM(((HIGH+LOW)/2), 20), SUM(MEAN(VOLUME, 60), 20), 9)) < RANK(CORR(LOW, VOLUME, 6))) * -1) | |
| ## | |
| data1 = ((self.high + self.low)/2).rolling(20).sum() | |
| data2 = self.volume.rolling(60).mean().rolling(20).sum() | |
| rank1 = data1.iloc[-9:,:].corrwith(data2.iloc[-9:,:]).dropna().rank(axis=0, pct=True) | |
| rank2 = self.low.iloc[-6:,:].corrwith(self.volume.iloc[-6:,:]).dropna().rank(axis=0, pct=True) | |
| rank1 = rank1[rank1.index.isin(rank2.index)] | |
| rank2 = rank2[rank2.index.isin(rank1.index)] | |
| alpha = (rank1 < rank2) * (-1) | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_124(self): | |
| ##### (CLOSE - VWAP) / DECAYLINEAR(RANK(TSMAX(CLOSE, 30)),2) | |
| ## | |
| data1 = self.close.rolling(30).max().rank(axis=1, pct=True) | |
| alpha = (self.close.iloc[-1,:] - self.avg_price.iloc[-1,:]) / (2./3*data1.iloc[-2,:] + 1./3*data1.iloc[-1,:]) | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_125(self): | |
| ##### (RANK(DECAYLINEAR(CORR((VWAP), MEAN(VOLUME, 80), 17), 20)) / RANK(DECAYLINEAR(DELTA((CLOSE * 0.5 + VWAP * 0.5), 3), 16))) | |
| ## | |
| data1 = pd.rolling_corr(self.avg_price, self.volume.rolling(80).mean(), window = 17) | |
| decay_weights = np.arange(1,21,1)[::-1] # 倒序数组 | |
| decay_weights = decay_weights / decay_weights.sum() | |
| rank1 = data1.iloc[-20:,:].mul(decay_weights, axis=0).sum().rank(axis=0, pct=True) | |
| data2 = (self.close * 0.5 + self.avg_price * 0.5).diff(3) | |
| decay_weights = np.arange(1,17,1)[::-1] # 倒序数组 | |
| decay_weights = decay_weights / decay_weights.sum() | |
| rank2 = data2.iloc[-16:,:].mul(decay_weights, axis=0).sum().rank(axis=0, pct=True) | |
| alpha = rank1 / rank2 | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_126(self): | |
| #### (CLOSE + HIGH + LOW) / 3 | |
| ## | |
| alpha = (self.close.iloc[-1,:] + self.high.iloc[-1,:] + self.low.iloc[-1,:]) / 3 | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_127(self): | |
| return | |
| def alpha_128(self): | |
| return | |
| def alpha_129(self): | |
| #### SUM((CLOSE - DELAY(CLOSE, 1) < 0 ? ABS(CLOSE - DELAY(CLOSE, 1)):0), 12) | |
| ## | |
| data = self.close.diff(1) | |
| data[data >= 0] = 0 | |
| data = abs(data) | |
| alpha = data.iloc[-12:,:].sum() | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_130(self): | |
| #### alpha_130 | |
| #### (RANK(DELCAYLINEAR(CORR(((HIGH + LOW) / 2), MEAN(VOLUME, 40), 9), 10)) / RANK(DELCAYLINEAR(CORR(RANK(VWAP), RANK(VOLUME), 7), 3))) | |
| ## | |
| data1 = (self.high + self.low) / 2 | |
| data2 = self.volume.rolling(40).mean() | |
| data3 = pd.rolling_corr(data1, data2, window=9) | |
| decay_weights = np.arange(1,11,1)[::-1] # 倒序数组 | |
| decay_weights = decay_weights / decay_weights.sum() | |
| rank1 = data3.iloc[-10:,:].mul(decay_weights, axis=0).sum().rank(axis=0, pct=True) | |
| data1 = self.avg_price.rank(axis=1, pct=True) | |
| data2 = self.volume.rank(axis=1, pct=True) | |
| data3 = pd.rolling_corr(data1, data2, window=7) | |
| decay_weights = np.arange(1,4,1)[::-1] # 倒序数组 | |
| decay_weights = decay_weights / decay_weights.sum() | |
| rank2 = data3.iloc[-3:,:].mul(decay_weights, axis=0).sum().rank(axis=0, pct=True) | |
| alpha = (rank1 / rank2).dropna() | |
| return alpha | |
| def alpha_131(self): | |
| return 0 | |
| def alpha_132(self): | |
| #### MEAN(AMOUNT, 20) | |
| ## | |
| alpha = self.amount.iloc[-20:,:].mean() | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_133(self): | |
| #### alpha_133 | |
| #### ((20 - HIGHDAY(HIGH, 20)) / 20)*100 - ((20 - LOWDAY(LOW, 20)) / 20)*100 | |
| ## | |
| alpha = (20 - self.high.iloc[-20:,:].apply(self.func_highday))/20*100 \ | |
| - (20 - self.low.iloc[-20:,:].apply(self.func_lowday))/20*100 | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_134(self): | |
| #### (CLOSE - DELAY(CLOSE, 12)) / DELAY(CLOSE, 12) * VOLUME | |
| ## | |
| alpha = ((self.close.iloc[-1,:] / self.close.iloc[-13,:] - 1) * self.volume.iloc[-1,:]) | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_135(self): | |
| #### SMA(DELAY(CLOSE / DELAY(CLOSE, 20), 1), 20, 1) | |
| ## | |
| def rolling_div(na): | |
| return na[-1]/na[-21] | |
| data1 = self.close.rolling(21).apply(rolling_div).shift(periods=1) | |
| alpha = pd.ewma(data1, com=19, adjust=False).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_136(self): | |
| #### ((-1 * RANK(DELTA(RET, 3))) * CORR(OPEN, VOLUME, 10)) | |
| ## | |
| data1 = -(self.close / self.prev_close - 1).diff(3).rank(axis=1, pct=True) | |
| data2 = self.open_price.iloc[-10:,:].corrwith(self.volume.iloc[-10:,:]) | |
| alpha = (data1.iloc[-1,:] * data2).dropna() | |
| return alpha | |
| def alpha_137(self): | |
| return | |
| def alpha_138(self): | |
| #### ((RANK(DECAYLINEAR(DELTA((((LOW * 0.7) + (VWAP * 0.3))), 3), 20)) - TSRANK(DECAYLINEAR(TSRANK(CORR(TSRANK(LOW, 8), TSRANK(MEAN(VOLUME, 60), 17), 5), 19), 16), 7)) * -1) | |
| ## | |
| data1 = (self.low * 0.7 + self.avg_price * 0.3).diff(3) | |
| decay_weights = np.arange(1,21,1)[::-1] # 倒序数组 | |
| decay_weights = decay_weights / decay_weights.sum() | |
| rank1 = data1.iloc[-20:,:].mul(decay_weights, axis=0).sum().rank(axis=0, pct=True) | |
| data1 = self.low.rolling(8).apply(self.func_rank) | |
| data2 = self.volume.rolling(60).mean().rolling(17).apply(self.func_rank) | |
| data3 = pd.rolling_corr(data1, data2, window=5).rolling(19).apply(self.func_rank) | |
| rank2 = data3.rolling(16).apply(self.func_decaylinear).iloc[-7:,:].rank(axis=0, pct=True).iloc[-1,:] | |
| alpha = (rank2 - rank1).dropna() | |
| return alpha | |
| def alpha_139(self): | |
| #### (-1 * CORR(OPEN, VOLUME, 10)) | |
| ## | |
| alpha = - self.open_price.iloc[-10:,:].corrwith(self.volume.iloc[-10:,:]).dropna() | |
| return alpha | |
| def alpha_140(self): | |
| #### MIN(RANK(DECAYLINEAR(((RANK(OPEN) + RANK(LOW)) - (RANK(HIGH) + RANK(CLOSE))), 8)), TSRANK(DECAYLINEAR(CORR(TSRANK(CLOSE, 8), TSRANK(MEAN(VOLUME, 60), 20), 8), 7), 3)) | |
| ## | |
| data1 = self.open_price.rank(axis=1, pct=True) + self.low.rank(axis=1, pct=True) \ | |
| - self.high.rank(axis=1, pct=True) - self.close.rank(axis=1, pct=True) | |
| rank1 = data1.iloc[-8:,:].apply(self.func_decaylinear).rank(pct=True) | |
| data1 = self.close.rolling(8).apply(self.func_rank) | |
| data2 = self.volume.rolling(60).mean().rolling(20).apply(self.func_rank) | |
| data3 = pd.rolling_corr(data1, data2, window=8) | |
| data3 = data3.rolling(7).apply(self.func_decaylinear) | |
| rank2 = data3.iloc[-3:,:].rank(axis=0, pct=True).iloc[-1,:] | |
| ''' | |
| alpha = min(rank1, rank2) NaN如何比较？ | |
| ''' | |
| return alpha | |
| def alpha_141(self): | |
| #### (RANK(CORR(RANK(HIGH), RANK(MEAN(VOLUME, 15)), 9))* -1) | |
| ## | |
| df1 = self.high.rank(axis=1, pct=True) | |
| df2 = self.volume.rolling(15).mean().rank(axis=1, pct=True) | |
| alpha = -df1.iloc[-9:,:].corrwith(df2.iloc[-9:,:]).rank(pct=True) | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_142(self): | |
| #### (((-1 * RANK(TSRANK(CLOSE, 10))) * RANK(DELTA(DELTA(CLOSE, 1), 1))) * RANK(TSRANK((VOLUME/MEAN(VOLUME, 20)), 5))) | |
| ## | |
| rank1 = self.close.iloc[-10:,:].rank(axis=0, pct=True).iloc[-1,:].rank(pct=True) | |
| rank2 = self.close.diff(1).diff(1).iloc[-1,:].rank(pct=True) | |
| rank3 = (self.volume / self.volume.rolling(20).mean()).iloc[-5:,:].rank(axis=0, pct=True).iloc[-1,:].rank(pct=True) | |
| alpha = -(rank1 * rank2 * rank3).dropna() | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_143(self): | |
| #### CLOSE > DELAY(CLOSE, 1)?(CLOSE - DELAY(CLOSE, 1)) / DELAY(CLOSE, 1) * SELF : SELF | |
| return 0 | |
| def alpha_144(self): | |
| #### SUMIF(ABS(CLOSE/DELAY(CLOSE, 1) - 1)/AMOUNT, 20, CLOSE < DELAY(CLOSE, 1))/COUNT(CLOSE < DELAY(CLOSE, 1), 20) | |
| ## | |
| df1 = self.close < self.prev_close | |
| sumif = ((abs(self.close / self.prev_close - 1)/self.amount) * df1).iloc[-20:,:].sum() | |
| count = df1.iloc[-20:,:].sum() | |
| alpha = (sumif / count).dropna() | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_145(self): | |
| #### (MEAN(VOLUME, 9) - MEAN(VOLUME, 26)) / MEAN(VOLUME, 12) * 100 | |
| ## | |
| alpha = (self.volume.iloc[-9:,:].mean() - self.volume.iloc[-26:,:].mean()) / self.volume.iloc[-12:,:].mean() * 100 | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_146(self): | |
| return | |
| def alpha_147(self): | |
| return | |
| def alpha_148(self): | |
| #### ((RANK(CORR((OPEN), SUM(MEAN(VOLUME, 60), 9), 6)) < RANK((OPEN - TSMIN(OPEN, 14)))) * -1) | |
| ## | |
| df1 = self.volume.rolling(60).mean().rolling(9).sum() | |
| rank1 = self.open_price.iloc[-6:,:].corrwith(df1.iloc[-6:,:]).rank(pct=True) | |
| rank2 = (self.open_price - self.open_price.rolling(14).min()).iloc[-1,:].rank(pct=True) | |
| alpha = -1 * (rank1 < rank2) | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_149(self): | |
| return | |
| def alpha_150(self): | |
| #### (CLOSE + HIGH + LOW)/3 * VOLUME | |
| ## | |
| alpha = ((self.close + self.high + self.low)/3 * self.volume).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_151(self): | |
| return 0 | |
| ######################## alpha_152 ####################### | |
| # | |
| def alpha_152(self): | |
| # SMA(MEAN(DELAY(SMA(DELAY(CLOSE/DELAY(CLOSE,9),1),9,1),1),12)-MEAN(DELAY(SMA(DELAY(CLOSE/DELAY(CLOSE,9),1),9,1),1),26),9,1) # | |
| # | |
| data1 = pd.rolling_mean((pd.ewma(((self.close/self.close.shift(9)).shift()), span=17, adjust=False)).shift(), 12) | |
| data2 = pd.rolling_mean((pd.ewma(((self.close/self.close.shift(9)).shift()), span=17, adjust=False)).shift(), 26) | |
| alpha = (pd.ewma(data1-data2, span=17, adjust=False)).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| ######################## alpha_153 ####################### | |
| # | |
| def alpha_153(self): | |
| # (MEAN(CLOSE,3)+MEAN(CLOSE,6)+MEAN(CLOSE,12)+MEAN(CLOSE,24))/4 # | |
| alpha = ((pd.rolling_mean(self.close, 3)+pd.rolling_mean(self.close, 6)+pd.rolling_mean(self.close, 12)+pd.rolling_mean(self.close,24))/4).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| ######################## alpha_154 ####################### | |
| # | |
| def alpha_154(self): | |
| # (((VWAP-MIN(VWAP,16)))<(CORR(VWAP,MEAN(VOLUME,180),18))) # | |
| alpha = (self.avg_price-pd.rolling_min(self.avg_price, 16)).iloc[-1,:]<self.avg_price.iloc[-18:,:].corrwith((pd.rolling_mean(self.volume, 180)).iloc[-18:,:]) | |
| alpha=alpha.dropna() | |
| return alpha | |
| ######################## alpha_155 ####################### | |
| # | |
| def alpha_155(self): | |
| # SMA(VOLUME,13,2)-SMA(VOLUME,27,2)-SMA(SMA(VOLUME,13,2)-SMA(VOLUME,27,2),10,2) # | |
| sma1 = pd.ewma(self.volume, span=12, adjust=False) | |
| sma2 = pd.ewma(self.volume, span=26, adjust=False) | |
| sma = pd.ewma(sma1-sma2, span=9, adjust=False) | |
| alpha = sma.iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| ######################## alpha_156 ####################### | |
| def alpha_156(self): | |
| # (MAX(RANK(DECAYLINEAR(DELTA(VWAP,5),3)),RANK(DECAYLINEAR(((DELTA(((OPEN*0.15)+(LOW*0.85)),2)/((OPEN*0.15)+(LOW*0.85)))*-1),3)))*-1 # | |
| rank1 = (pd.rolling_apply(self.avg_price-self.avg_price.shift(5), 3, self.func_decaylinear)).rank(axis=1, pct=True) | |
| rank2 = pd.rolling_apply(-((self.open_price*0.15+self.low*0.85)-(self.open_price*0.15+self.low*0.85).shift(2))/(self.open_price*0.15+self.low*0.85), 3, self.func_decaylinear).rank(axis=1, pct=True) | |
| max_cond = rank1 > rank2 | |
| result = rank2 | |
| result[max_cond] = rank1[max_cond] | |
| alpha = (-result).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| ######################## alpha_157 ####################### | |
| # | |
| def alpha_157(self): | |
| # (MIN(PROD(RANK(RANK(LOG(SUM(TSMIN(RANK(RANK((-1*RANK(DELTA((CLOSE-1),5))))),2),1)))),1),5)+TSRANK(DELAY((-1*RET),6),5)) # | |
| rank1 = (-((self.close-1)-(self.close-1).shift(5)).rank(axis=1, pct=True)).rank(axis=1, pct=True).rank(axis=1, pct=True) | |
| min1 = rank1.rolling(2).min() | |
| log1 = np.log(min1) | |
| rank2 = log1.rank(axis=1, pct=True).rank(axis=1, pct=True) | |
| cond_min = rank2 > 5 | |
| rank2[cond_min] = 5 | |
| tsrank1 = pd.rolling_apply((-((self.close/self.prev_close)-1)).shift(6), 5, self.func_rank) | |
| alpha = (rank2+tsrank1).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| ######################## alpha_158 ####################### | |
| # | |
| def alpha_158(self): | |
| # ((HIGH-SMA(CLOSE,15,2))-(LOW-SMA(CLOSE,15,2)))/CLOSE # | |
| alpha = (((self.high-pd.ewma(self.close, span=14, adjust=False))-(self.low-pd.ewma(self.close, span=14, adjust=False)))/self.close).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_159(self): | |
| #########((close-sum(min(low,delay(close,1)),6))/sum(max(high,delay(close,1))-min(low,delay(close,1)),6)*12*24+(close-sum(min(low,delay(close,1)),12))/sum(max(high,delay(close,1))-min(low,delay(close,1)),12)*6*24+(close-sum(min(low,delay(close,1)),24))/sum(max(high,delay(close,1))-min(low,delay(close,1)),24)*6*24)*100/(6*12+6*24+12*24) | |
| ################### | |
| data1=self.low | |
| data2=self.close.shift() | |
| cond=data1>data2 | |
| data1[cond]=data2 | |
| data3=self.high | |
| data4=self.close.shift() | |
| cond=data3>data4 | |
| data3[~cond]=data4 | |
| #计算出公式核心部分x | |
| x=((self.close-pd.rolling_sum(data1,6))/pd.rolling_sum((data2-data1),6))*12*24 | |
| #计算出公式核心部分y | |
| y=((self.close-pd.rolling_sum(data1,12))/pd.rolling_sum((data2-data1),12))*6*24 | |
| #计算出公式核心部分z | |
| z=((self.close-pd.rolling_sum(data1,24))/pd.rolling_sum((data2-data1),24))*6*24 | |
| data5=(x+y+z)*(100/(6*12+12*24+6*24)) | |
| alpha=data5.iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_160(self): | |
| ################ | |
| ############sma((close<=delay(close,1)?std(close,20):0),20,1) | |
| data1=pd.rolling_std(self.close,20) | |
| cond=self.close<=self.close.shift(0) | |
| data1[~cond]=0 | |
| data2=pd.ewma(data1,span=39) | |
| alpha=data2.iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_161(self): | |
| ###########mean((max(max(high-low),abs(delay(close,1)-high)),abs(delay(close,1)-low)),12) | |
| ################ | |
| data1=(self.high-self.low) | |
| data2=pd.Series.abs(self.close.shift()-self.high) | |
| cond=data1>data2 | |
| data1[~cond]=data2 | |
| data3=pd.Series.abs(self.close.shift()-self.low) | |
| cond=data1>data3 | |
| data1[~cond]=data3 | |
| alpha=(pd.rolling_mean(data1,12)).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_162(self): | |
| ###############(sma(max(close-delay(close,1),0),12,1)/sma(abs(close-delay(close,1)),12,1)*100-min(sma(max(close-delay(close,1),0),12,1)/sma(abs(close-delay(close,1)),12,1)*100,12))/(max(sma(max(close-delay(close,1),0),12,1)/sma(abs(close-delay(close,1)),12,1)*100),12)-min(sma(max(close-delay(close,1),0),12,1)/sma(abs(close-delay(close,1)),12,1)*100),12)) | |
| ################# | |
| #算出公式核心部分X | |
| data1=self.close-self.close.shift() | |
| cond=data1>0 | |
| data1[~cond]=0 | |
| x=pd.ewma(data1,span=23) | |
| data2=pd.Series.abs(self.close-self.close.shift()) | |
| y=pd.ewma(data2,span=23) | |
| z=(x/y)*100 | |
| cond=z>12 | |
| z[cond]=12 | |
| c=(x/y)*100 | |
| cond=c>12 | |
| c[~cond]=12 | |
| data3=(x/y)*100-(z/c)-c | |
| alpha=data3.iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_163(self): | |
| ################ | |
| #######rank(((((-1*ret)*,ean(volume,20))*vwap)*(high-close))) | |
| data1=(-1)*(self.close/self.close.shift()-1)*pd.rolling_mean(self.volume,20)*self.avg_price*(self.high-self.close) | |
| data2=(data1.rank(axis=1,pct=True)).iloc[-1,:] | |
| alpha=data2 | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_164(self): | |
| ################ | |
| ############sma((((close>delay(close,1))?1/(close-delay(close,1)):1)-min(((close>delay(close,1))?1/(close/delay(close,1)):1),12))/(high-low)*100,13,2) | |
| cond=self.close>self.close.shift() | |
| data1=1/(self.close-self.close.shift()) | |
| data1[~cond]=1 | |
| data2=1/(self.close-self.close.shift()) | |
| cond=data2>12 | |
| data2[cond]=12 | |
| data3=data1-data2/((self.high-self.low)*100) | |
| alpha=(pd.ewma(data3,span=12)).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_165(self): | |
| return 0 | |
| def alpha_166(self): | |
| return 0 | |
| def alpha_167(self): | |
| ## | |
| ####sum(((close-delay(close,1)>0)?(close-delay(close,1)):0),12)#### | |
| data1=self.close-self.close.shift() | |
| cond=(data1<0) | |
| data1[cond]=0 | |
| data2=(pd.rolling_sum(data1,12)).iloc[-1,:] | |
| alpha=data2 | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_168(self): | |
| ## | |
| #####-1*volume/mean(volume,20)#### | |
| data1=(-1*self.volume)/pd.rolling_mean(self.volume,20) | |
| alpha=data1.iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_169(self): | |
| ## | |
| ###sma(mean(delay(sma(close-delay(close,1),9,1),1),12)-mean(delay(sma(close-delay(close,1),1,1),1),26),10,1)##### | |
| data1=self.close-self.close.shift() | |
| data2=(pd.ewma(data1,span=17)).shift() | |
| data3=pd.rolling_mean(data2,12)-pd.rolling_mean(data2,26) | |
| alpha=(pd.ewma(data3,span=19)).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_170(self): | |
| ## | |
| #####((((rank((1/close))*volume)/mean(volume,20))*((high*rank((high-close)))/(sum(high,5)/5)))-rank((vwap-delay(vwap,5))))#### | |
| data1=(1/self.close).rank(axis=0,pct=True) | |
| data2=pd.rolling_mean(self.volume,20) | |
| x=(data1*self.volume)/data2 | |
| data3=(self.high-self.close).rank(axis=0,pct=True) | |
| data4=pd.rolling_mean(self.high,5) | |
| y=(data3*self.high)/data4 | |
| z=(self.avg_price.iloc[-1,:]-self.avg_price.iloc[-5,:]).rank(axis=0,pct=True) | |
| alpha=(x*y-z).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_171(self): | |
| ## | |
| ####(((low-close)*open^5)*-1)/((close-high)*close^5)##### | |
| data1=-1*(self.low-self.close)*(self.open_price**5) | |
| data2=(self.close-self.high)*(self.close**5) | |
| alpha = (data1/data2).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| # | |
| def alpha_172(self): | |
| # MEAN(ABS(SUM((LD>0&LD>HD)?LD:0,14)*100/SUM(TR,14)-SUM((HD>0&HD>LD)?HD:0,14)*100/(SUM((LD>0&LD>HD)?LD:0,14)*100/SUM(TR,14)+SUM(TR,14)+SUM((HD>0&HD>LD)?HD:0,14)*100/SUM(TR,14))*100,6) # | |
| hd = self.high-self.high.shift() | |
| ld = self.low.shift()-self.low | |
| temp1 = self.high-self.low | |
| temp2 = (self.high-self.close.shift()).abs() | |
| cond1 = temp1>temp2 | |
| temp2[cond1] = temp1[cond1] | |
| temp3 = (self.low-self.close.shift()).abs() | |
| cond2 = temp2>temp3 | |
| temp3[cond2] = temp2[cond2] | |
| tr = temp3 # MAX(MAX(HIGH-LOW,ABS(HIGH-DELAY(CLOSE,1))),ABS(LOW-DELAY(CLOSE,1))) | |
| sum_tr14 = pd.rolling_sum(tr, 14) | |
| cond3 = ld>0 | |
| cond4 = ld>hd | |
| cond3[~cond4] = False | |
| data1 = ld | |
| data1[~cond3] = 0 | |
| sum1 = pd.rolling_sum(data1, 14)*100/sum_tr14 | |
| cond5 = hd>0 | |
| cond6 = hd>ld | |
| cond5[~cond6] = False | |
| data2 = hd | |
| data2[~cond5] = 0 | |
| sum2 = pd.rolling_sum(data2, 14)*100/sum_tr14 | |
| alpha = pd.rolling_mean((sum1-sum2).abs()/(sum1+sum2)*100, 6).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_173(self): | |
| ## | |
| ####3*sma(close,13,2)-2*sma(sma(close,13,2),13,2)+sma(sma(sma(log(close),13,2),13,2),13,2)##### | |
| data1=pd.ewma(self.close,span=12) | |
| data2=pd.ewma(data1,span=12) | |
| close_log=np.log(self.close) | |
| data3=pd.ewma(close_log,span=12) | |
| data4=pd.ewma(data3,span=12) | |
| data5=pd.ewma(data4,span=12) | |
| alpha=(3*data1-2*data2+data5).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_174(self): | |
| ## | |
| ####sma((close>delay(close,1)?std(close,20):0),20,1)##### | |
| cond=self.close>self.prev_close | |
| data2=pd.rolling_std(self.close, 20) | |
| data2[~cond] = 0 | |
| alpha=(pd.ewma(data2,span=39,adjust=False)).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_175(self): | |
| ## | |
| #####mean(max(max(high-low),abs(delay(close,1)-high)),abs(delay(close,1)-low)),6)#### | |
| data1=self.high-self.low | |
| data2=pd.Series.abs(self.close.shift()-self.high) | |
| cond=(data1>data2) | |
| data2[cond] = data1[cond] | |
| data3=pd.Series.abs(self.close.shift()-self.low) | |
| cond=(data2>data3) | |
| data3[cond] = data2[cond] | |
| data4=(pd.rolling_mean(data3,window=6)).iloc[-1,:] | |
| alpha=data4 | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_176(self): | |
| ## | |
| ######### #########corr(rank((close-tsmin(low,12))/(tsmax(high,12)-tsmin(low,12))),rank(volume),6)############# | |
| data1=(self.close-pd.rolling_min(self.low,window=12))/(pd.rolling_max(self.high,window=12)-pd.rolling_min(self.low,window=12)) | |
| data2=data1.rank(axis=0,pct=True) | |
| #获取数据求出rank2 | |
| data3=self.volume.rank(axis=0,pct=True) | |
| corr=data2.iloc[-6:,:].corrwith(data3.iloc[-6:,:]) | |
| alpha=corr | |
| alpha=alpha.dropna() | |
| return alpha | |
| ################## alpha_177 #################### | |
| # | |
| def alpha_177(self): | |
| ##### ((20-HIGHDAY(HIGH,20))/20)*100 ##### | |
| alpha = (20 - self.high.iloc[-20:,:].apply(self.func_highday))/20*100 | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_178(self): | |
| ##### (close-delay(close,1))/delay(close,1)*volume #### | |
| ## | |
| alpha=((self.close-self.close.shift())/self.close.shift()*self.volume).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_179(self): | |
| #####（rank(corr(vwap,volume,4))*rank(corr(rank(low),rank(mean(volume,50)),12))#### | |
| ## | |
| rank1=(self.avg_price.iloc[-4:,:].corrwith(self.volume.iloc[-4:,:])).rank(axis=0,pct=True) | |
| data2=self.low.rank(axis=0,pct=True) | |
| data3=(pd.rolling_mean(self.volume,window=50)).rank(axis=0,pct=True) | |
| rank2=(data2.iloc[-12:,:].corrwith(data3.iloc[-12:,:])).rank(axis=0,pct=True) | |
| alpha=rank1*rank2 | |
| alpha=alpha.dropna() | |
| return alpha | |
| ##################### alpha_180 ####################### | |
| # | |
| def alpha_180(self): | |
| ##### ((MEAN(VOLUME,20)<VOLUME)?((-1*TSRANK(ABS(DELTA(CLOSE,7)),60))*SIGN(DELTA(CLOSE,7)):(-1*VOLUME))) ##### | |
| ma = pd.rolling_mean(self.volume, window=20) | |
| cond = (ma < self.volume).iloc[-20:,:] | |
| sign = delta_close_7 = self.close.diff(7) | |
| sign[sign.iloc[:,:]<0] = -1 | |
| sign[sign.iloc[:,:]>0] = 1 | |
| sign[sign.iloc[:,:]==0] = 0 | |
| left = (((self.close.diff(7).abs()).iloc[-60:,:].rank(axis=0, pct=True)*(-1)).iloc[-20:,:] * sign.iloc[-20:,:]).iloc[-20:,:] | |
| right = self.volume.iloc[-20:,:]*(-1) | |
| right[cond] = left[cond] | |
| alpha = right.iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_181(self): | |
| return 0 | |
| ######################## alpha_182 ####################### | |
| # | |
| def count_cond_182(self, x): | |
| num = 0 | |
| for i in x: | |
| if i == np.True_: | |
| num += 1 | |
| return num | |
| def alpha_182(self): | |
| ##### COUNT((CLOSE>OPEN & BANCHMARKINDEXCLOSE>BANCHMARKINDEXOPEN)OR(CLOSE<OPEN & BANCHMARKINDEXCLOSE<BANCHMARKINDEXOPEN),20)/20 ##### | |
| cond1 = (self.close>self.open_price) | |
| cond2 = (self.benchmark_open_price>self.benchmark_close_price) | |
| cond3 = (self.close<self.open_price) | |
| cond4 = (self.benchmark_open_price<self.benchmark_close_price) | |
| func1 = lambda x: np.asarray(x) & np.asarray(cond2) | |
| func2 = lambda x: np.asarray(x) & np.asarray(cond4) | |
| cond = cond1.apply(func1)|cond3.apply(func2) | |
| count = pd.rolling_apply(cond, 20, self.count_cond_182) | |
| alpha = (count/20).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_183(self): | |
| return 0 | |
| def alpha_184(self): | |
| #####(rank(corr(delay((open-close),1),close,200))+rank((open-close))) #### | |
| ## | |
| data1=self.open_price.shift()-self.close.shift() | |
| data2=self.open_price.iloc[-1,:] - self.close.iloc[-1,:] | |
| corr=data1.iloc[-200:,:].corrwith(self.close.iloc[-200:,:]) | |
| alpha=data2.rank(axis=0,pct=True)+corr.rank(axis=0,pct=True) | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_185(self): | |
| ##### RANK((-1 * ((1 - (OPEN / CLOSE))^2))) #### | |
| alpha = (-(1-self.open_price/self.close)**2).rank(axis=1, pct=True).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| # | |
| def alpha_186(self): | |
| # (MEAN(ABS(SUM((LD>0 & LD>HD)?LD:0,14)*100/SUM(TR,14)-SUM((HD>0 & HD>LD)?HD:0,14)*100/SUM(TR,14))/(SUM((LD>0 & LD>HD)?LD:0,14)*100/SUM(TR,14)+SUM((HD>0 & HD>LD)?HD:0,14)*100/SUM(TR,14))*100,6)+DELAY(MEAN(ABS(SUM((LD>0 & LD>HD)?LD:0,14)*100/SUM(TR,14)-SUM((HD>0 & HD>LD)?HD:0,14)*100/SUM(TR,14))/(SUM((LD>0 & LD>HD)?LD:0,14)*100/SUM(TR,14)+SUM((HD>0 & HD>LD)?HD:0,14)*100/SUM(TR,14))*100,6),6))/2 # | |
| hd = self.high-self.high.shift() | |
| ld = self.low.shift()-self.low | |
| temp1 = self.high-self.low | |
| temp2 = (self.high-self.close.shift()).abs() | |
| cond1 = temp1>temp2 | |
| temp2[cond1] = temp1[cond1] | |
| temp3 = (self.low-self.close.shift()).abs() | |
| cond2 = temp2>temp3 | |
| temp3[cond2] = temp2[cond2] | |
| tr = temp3 # MAX(MAX(HIGH-LOW,ABS(HIGH-DELAY(CLOSE,1))),ABS(LOW-DELAY(CLOSE,1))) | |
| sum_tr14 = pd.rolling_sum(tr, 14) | |
| cond3 = ld>0 | |
| cond4 = ld>hd | |
| cond3[~cond4] = False | |
| data1 = ld | |
| data1[~cond3] = 0 | |
| sum1 = pd.rolling_sum(data1, 14)*100/sum_tr14 | |
| cond5 = hd>0 | |
| cond6 = hd>ld | |
| cond5[~cond6] = False | |
| data2 = hd | |
| data2[~cond5] = 0 | |
| sum2 = pd.rolling_sum(data2, 14)*100/sum_tr14 | |
| mean1 = pd.rolling_mean((sum1-sum2).abs()/(sum1+sum2)*100, 6) | |
| alpha = ((mean1 + mean1.shift(6))/2).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_187(self): | |
| ##### SUM((OPEN<=DELAY(OPEN,1)?0:MAX((HIGH-OPEN),(OPEN-DELAY(OPEN,1)))),20) #### | |
| cond = (self.open_price <= self.open_price.shift()) | |
| data1 = self.high - self.low # HIGH-LOW | |
| data2 = self.open_price - self.open_price.shift() # OPEN-DELAY(OPEN,1) | |
| cond_max = data2 > data1 | |
| data1[cond_max] = data2[cond_max] | |
| data1[cond] = 0 | |
| alpha = data1.iloc[-20:,:].sum() | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_188(self): | |
| ##### ((HIGH-LOW–SMA(HIGH-LOW,11,2))/SMA(HIGH-LOW,11,2))*100 ##### | |
| sma = pd.ewma(self.high - self.low, span=10, adjust=False) | |
| alpha = ((self.high - self.low - sma)/sma*100).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_189(self): | |
| ##### mean(abs(close-mean(close,6),6)) #### | |
| ma6 = pd.rolling_mean(self.close, window=6) | |
| alpha = pd.rolling_mean((self.close - ma6).abs(), window=6).iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha | |
| def alpha_190(self): | |
| ##### LOG((COUNT(CLOSE/DELAY(CLOSE)-1>((CLOSE/DELAY(CLOSE,19))^(1/20)-1),20)-1)*(SUMIF(((CLOSE/DELAY(CLOSE) | |
| ##### -1-(CLOSE/DELAY(CLOSE,19))^(1/20)-1))^2,20,CLOSE/DELAY(CLOSE)-1<(CLOSE/DELAY(CLOSE,19))^(1/20)-1))/(( | |
| ##### COUNT((CLOSE/DELAY(CLOSE)-1<(CLOSE/DELAY(CLOSE,19))^(1/20)-1),20))*(SUMIF((CLOSE/DELAY(CLOSE)-1-((CLOSE | |
| ##### /DELAY(CLOSE,19))^(1/20)-1))^2,20,CLOSE/DELAY(CLOSE)-1>(CLOSE/DELAY(CLOSE,19))^(1/20)-1)))) #### | |
| return 0 | |
| def alpha_191(self): | |
| ##### (CORR(MEAN(VOLUME,20), LOW, 5) + ((HIGH + LOW) / 2)) - CLOSE #### | |
| /chencheng | |
| volume_avg = pd.rolling_mean(self.volume, window=20) | |
| corr = volume_avg.iloc[-5:,:].corrwith(self.low.iloc[-5:,:]) | |
| alpha = corr + (self.high.iloc[-1,:] + self.low.iloc[-1,:])/2 - self.close.iloc[-1,:] | |
| alpha=alpha.dropna() | |
| return alpha |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
you are the best ! thanks mate