├── 101 Formulaic Alphas.pdf
├── 101Alpha_code_1.py
└── 101Alpha_code_2.py


/101 Formulaic Alphas.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/robertmartin8/WorldQuant_alpha101_code/3bb9918dd7b62039f41a585a9e37bfd67ce3719f/101 Formulaic Alphas.pdf


--------------------------------------------------------------------------------
/101Alpha_code_1.py:
--------------------------------------------------------------------------------
  1 | import numpy as np
  2 | import pandas as pd
  3 | from numpy import abs
  4 | from numpy import log
  5 | from numpy import sign
  6 | from scipy.stats import rankdata
  7 | 
  8 | # region Auxiliary functions
  9 | def ts_sum(df, window=10):
 10 |     """
 11 |     Wrapper function to estimate rolling sum.
 12 |     :param df: a pandas DataFrame.
 13 |     :param window: the rolling window.
 14 |     :return: a pandas DataFrame with the time-series min over the past 'window' days.
 15 |     """
 16 |     
 17 |     return df.rolling(window).sum()
 18 | 
 19 | def sma(df, window=10):
 20 |     """
 21 |     Wrapper function to estimate SMA.
 22 |     :param df: a pandas DataFrame.
 23 |     :param window: the rolling window.
 24 |     :return: a pandas DataFrame with the time-series min over the past 'window' days.
 25 |     """
 26 |     return df.rolling(window).mean()
 27 | 
 28 | def stddev(df, window=10):
 29 |     """
 30 |     Wrapper function to estimate rolling standard deviation.
 31 |     :param df: a pandas DataFrame.
 32 |     :param window: the rolling window.
 33 |     :return: a pandas DataFrame with the time-series min over the past 'window' days.
 34 |     """
 35 |     return df.rolling(window).std()
 36 | 
 37 | def correlation(x, y, window=10):
 38 |     """
 39 |     Wrapper function to estimate rolling corelations.
 40 |     :param df: a pandas DataFrame.
 41 |     :param window: the rolling window.
 42 |     :return: a pandas DataFrame with the time-series min over the past 'window' days.
 43 |     """
 44 |     return x.rolling(window).corr(y)
 45 | 
 46 | def covariance(x, y, window=10):
 47 |     """
 48 |     Wrapper function to estimate rolling covariance.
 49 |     :param df: a pandas DataFrame.
 50 |     :param window: the rolling window.
 51 |     :return: a pandas DataFrame with the time-series min over the past 'window' days.
 52 |     """
 53 |     return x.rolling(window).cov(y)
 54 | 
 55 | def rolling_rank(na):
 56 |     """
 57 |     Auxiliary function to be used in pd.rolling_apply
 58 |     :param na: numpy array.
 59 |     :return: The rank of the last value in the array.
 60 |     """
 61 |     return rankdata(na)[-1]
 62 | 
 63 | def ts_rank(df, window=10):
 64 |     """
 65 |     Wrapper function to estimate rolling rank.
 66 |     :param df: a pandas DataFrame.
 67 |     :param window: the rolling window.
 68 |     :return: a pandas DataFrame with the time-series rank over the past window days.
 69 |     """
 70 |     return df.rolling(window).apply(rolling_rank)
 71 | 
 72 | def rolling_prod(na):
 73 |     """
 74 |     Auxiliary function to be used in pd.rolling_apply
 75 |     :param na: numpy array.
 76 |     :return: The product of the values in the array.
 77 |     """
 78 |     return np.prod(na)
 79 | 
 80 | def product(df, window=10):
 81 |     """
 82 |     Wrapper function to estimate rolling product.
 83 |     :param df: a pandas DataFrame.
 84 |     :param window: the rolling window.
 85 |     :return: a pandas DataFrame with the time-series product over the past 'window' days.
 86 |     """
 87 |     return df.rolling(window).apply(rolling_prod)
 88 | 
 89 | def ts_min(df, window=10):
 90 |     """
 91 |     Wrapper function to estimate rolling min.
 92 |     :param df: a pandas DataFrame.
 93 |     :param window: the rolling window.
 94 |     :return: a pandas DataFrame with the time-series min over the past 'window' days.
 95 |     """
 96 |     return df.rolling(window).min()
 97 | 
 98 | def ts_max(df, window=10):
 99 |     """
100 |     Wrapper function to estimate rolling min.
101 |     :param df: a pandas DataFrame.
102 |     :param window: the rolling window.
103 |     :return: a pandas DataFrame with the time-series max over the past 'window' days.
104 |     """
105 |     return df.rolling(window).max()
106 | 
107 | def delta(df, period=1):
108 |     """
109 |     Wrapper function to estimate difference.
110 |     :param df: a pandas DataFrame.
111 |     :param period: the difference grade.
112 |     :return: a pandas DataFrame with today’s value minus the value 'period' days ago.
113 |     """
114 |     return df.diff(period)
115 | 
116 | def delay(df, period=1):
117 |     """
118 |     Wrapper function to estimate lag.
119 |     :param df: a pandas DataFrame.
120 |     :param period: the lag grade.
121 |     :return: a pandas DataFrame with lagged time series
122 |     """
123 |     return df.shift(period)
124 | 
125 | def rank(df):
126 |     """
127 |     Cross sectional rank
128 |     :param df: a pandas DataFrame.
129 |     :return: a pandas DataFrame with rank along columns.
130 |     """
131 |     #return df.rank(axis=1, pct=True)
132 |     return df.rank(pct=True)
133 | 
134 | def scale(df, k=1):
135 |     """
136 |     Scaling time serie.
137 |     :param df: a pandas DataFrame.
138 |     :param k: scaling factor.
139 |     :return: a pandas DataFrame rescaled df such that sum(abs(df)) = k
140 |     """
141 |     return df.mul(k).div(np.abs(df).sum())
142 | 
143 | def ts_argmax(df, window=10):
144 |     """
145 |     Wrapper function to estimate which day ts_max(df, window) occurred on
146 |     :param df: a pandas DataFrame.
147 |     :param window: the rolling window.
148 |     :return: well.. that :)
149 |     """
150 |     return df.rolling(window).apply(np.argmax) + 1 
151 | 
152 | def ts_argmin(df, window=10):
153 |     """
154 |     Wrapper function to estimate which day ts_min(df, window) occurred on
155 |     :param df: a pandas DataFrame.
156 |     :param window: the rolling window.
157 |     :return: well.. that :)
158 |     """
159 |     return df.rolling(window).apply(np.argmin) + 1
160 | 
161 | def decay_linear(df, period=10):
162 |     """
163 |     Linear weighted moving average implementation.
164 |     :param df: a pandas DataFrame.
165 |     :param period: the LWMA period
166 |     :return: a pandas DataFrame with the LWMA.
167 |     """
168 |     # Clean data
169 |     if df.isnull().values.any():
170 |         df.fillna(method='ffill', inplace=True)
171 |         df.fillna(method='bfill', inplace=True)
172 |         df.fillna(value=0, inplace=True)
173 |     na_lwma = np.zeros_like(df)
174 |     na_lwma[:period, :] = df.iloc[:period, :] 
175 |     na_series = df.as_matrix()
176 | 
177 |     divisor = period * (period + 1) / 2
178 |     y = (np.arange(period) + 1) * 1.0 / divisor
179 |     # Estimate the actual lwma with the actual close.
180 |     # The backtest engine should assure to be snooping bias free.
181 |     for row in range(period - 1, df.shape[0]):
182 |         x = na_series[row - period + 1: row + 1, :]
183 |         na_lwma[row, :] = (np.dot(x.T, y))
184 |     return pd.DataFrame(na_lwma, index=df.index, columns=['CLOSE'])  
185 | # endregion
186 | 
187 | def get_alpha(df):
188 |         stock=Alphas(df)
189 |         df['alpha001']=stock.alpha001() 
190 |         df['alpha002']=stock.alpha002()
191 |         df['alpha003']=stock.alpha003()
192 |         df['alpha004']=stock.alpha004()
193 |         df['alpha005']=stock.alpha005()
194 |         df['alpha006']=stock.alpha006()
195 |         df['alpha007']=stock.alpha007()
196 |         df['alpha008']=stock.alpha008()
197 |         df['alpha009']=stock.alpha009()
198 |         df['alpha010']=stock.alpha010()
199 |         df['alpha011']=stock.alpha011()
200 |         df['alpha012']=stock.alpha012()
201 |         df['alpha013']=stock.alpha013()
202 |         df['alpha014']=stock.alpha014()
203 |         df['alpha015']=stock.alpha015()
204 |         df['alpha016']=stock.alpha016()
205 |         df['alpha017']=stock.alpha017()
206 |         df['alpha018']=stock.alpha018()
207 |         df['alpha019']=stock.alpha019()
208 |         df['alpha020']=stock.alpha020()
209 |         df['alpha021']=stock.alpha021()
210 |         df['alpha022']=stock.alpha022()
211 |         df['alpha023']=stock.alpha023()
212 |         df['alpha024']=stock.alpha024()
213 |         df['alpha025']=stock.alpha025()
214 |         df['alpha026']=stock.alpha026()
215 |         df['alpha027']=stock.alpha027()
216 |         df['alpha028']=stock.alpha028()
217 |         df['alpha029']=stock.alpha029()
218 |         df['alpha030']=stock.alpha030()
219 |         df['alpha031']=stock.alpha031()
220 |         df['alpha032']=stock.alpha032()
221 |         df['alpha033']=stock.alpha033()
222 |         df['alpha034']=stock.alpha034()
223 |         df['alpha035']=stock.alpha035()
224 |         df['alpha036']=stock.alpha036()
225 |         df['alpha037']=stock.alpha037()
226 |         df['alpha038']=stock.alpha038()
227 |         df['alpha039']=stock.alpha039()
228 |         df['alpha040']=stock.alpha040()
229 |         df['alpha041']=stock.alpha041()
230 |         df['alpha042']=stock.alpha042()
231 |         df['alpha043']=stock.alpha043()
232 |         df['alpha044']=stock.alpha044()
233 |         df['alpha045']=stock.alpha045()
234 |         df['alpha046']=stock.alpha046()
235 |         df['alpha047']=stock.alpha047()
236 |         df['alpha049']=stock.alpha049()
237 |         df['alpha050']=stock.alpha050()
238 |         df['alpha051']=stock.alpha051()
239 |         df['alpha052']=stock.alpha052()
240 |         df['alpha053']=stock.alpha053()
241 |         df['alpha054']=stock.alpha054()
242 |         df['alpha055']=stock.alpha055()
243 |         df['alpha057']=stock.alpha057()
244 |         df['alpha060']=stock.alpha060()
245 |         df['alpha061']=stock.alpha061()
246 |         df['alpha062']=stock.alpha062()
247 |         df['alpha064']=stock.alpha064()
248 |         df['alpha065']=stock.alpha065()
249 |         df['alpha066']=stock.alpha066()
250 |         df['alpha068']=stock.alpha068()
251 |         df['alpha071']=stock.alpha071()
252 |         df['alpha072']=stock.alpha072()
253 |         df['alpha073']=stock.alpha073()
254 |         df['alpha074']=stock.alpha074()
255 |         df['alpha075']=stock.alpha075()
256 |         df['alpha077']=stock.alpha077()
257 |         df['alpha078']=stock.alpha078()
258 |         df['alpha081']=stock.alpha081()
259 |         df['alpha083']=stock.alpha083()
260 |         df['alpha084']=stock.alpha084()
261 |         df['alpha085']=stock.alpha085()
262 |         df['alpha086']=stock.alpha086()
263 |         df['alpha088']=stock.alpha088()
264 |         df['alpha092']=stock.alpha092()
265 |         df['alpha094']=stock.alpha094()
266 |         df['alpha095']=stock.alpha095()
267 |         df['alpha096']=stock.alpha096()
268 |         df['alpha098']=stock.alpha098()
269 |         df['alpha099']=stock.alpha099()
270 |         df['alpha101']=stock.alpha101()  
271 |         return df
272 | 
273 | class Alphas(object):
274 |     def __init__(self, df_data):
275 | 
276 |         self.open = df_data['S_DQ_OPEN'] 
277 |         self.high = df_data['S_DQ_HIGH'] 
278 |         self.low = df_data['S_DQ_LOW']   
279 |         self.close = df_data['S_DQ_CLOSE'] 
280 |         self.volume = df_data['S_DQ_VOLUME']*100 
281 |         self.returns = df_data['S_DQ_PCTCHANGE'] 
282 |         self.vwap = (df_data['S_DQ_AMOUNT']*1000)/(df_data['S_DQ_VOLUME']*100+1) 
283 |         
284 |     # Alpha#1	 (rank(Ts_ArgMax(SignedPower(((returns < 0) ? stddev(returns, 20) : close), 2.), 5)) -0.5)
285 |     def alpha001(self):
286 |         inner = self.close
287 |         inner[self.returns < 0] = stddev(self.returns, 20)
288 |         return rank(ts_argmax(inner ** 2, 5))
289 |     
290 |     # Alpha#2	 (-1 * correlation(rank(delta(log(volume), 2)), rank(((close - open) / open)), 6))
291 |     def alpha002(self):
292 |         df = -1 * correlation(rank(delta(log(self.volume), 2)), rank((self.close - self.open) / self.open), 6)
293 |         return df.replace([-np.inf, np.inf], 0).fillna(value=0)
294 |     
295 |     # Alpha#3	 (-1 * correlation(rank(open), rank(volume), 10))
296 |     def alpha003(self):
297 |         df = -1 * correlation(rank(self.open), rank(self.volume), 10)
298 |         return df.replace([-np.inf, np.inf], 0).fillna(value=0)
299 |     
300 |     # Alpha#4	 (-1 * Ts_Rank(rank(low), 9))
301 |     def alpha004(self):
302 |         return -1 * ts_rank(rank(self.low), 9)
303 |     
304 |     # Alpha#5	 (rank((open - (sum(vwap, 10) / 10))) * (-1 * abs(rank((close - vwap)))))
305 |     def alpha005(self):
306 |         return  (rank((self.open - (sum(self.vwap, 10) / 10))) * (-1 * abs(rank((self.close - self.vwap)))))
307 |     
308 |     # Alpha#6	 (-1 * correlation(open, volume, 10))
309 |     def alpha006(self):
310 |         df = -1 * correlation(self.open, self.volume, 10)
311 |         return df.replace([-np.inf, np.inf], 0).fillna(value=0)
312 |     
313 |     # Alpha#7	 ((adv20 < volume) ? ((-1 * ts_rank(abs(delta(close, 7)), 60)) * sign(delta(close, 7))) : (-1* 1))
314 |     def alpha007(self):
315 |         adv20 = sma(self.volume, 20)
316 |         alpha = -1 * ts_rank(abs(delta(self.close, 7)), 60) * sign(delta(self.close, 7))
317 |         alpha[adv20 >= self.volume] = -1
318 |         return alpha
319 |     
320 |     # Alpha#8	 (-1 * rank(((sum(open, 5) * sum(returns, 5)) - delay((sum(open, 5) * sum(returns, 5)),10))))
321 |     def alpha008(self):
322 |         return -1 * (rank(((ts_sum(self.open, 5) * ts_sum(self.returns, 5)) -
323 |                            delay((ts_sum(self.open, 5) * ts_sum(self.returns, 5)), 10))))
324 |     
325 |     # Alpha#9	 ((0 < ts_min(delta(close, 1), 5)) ? delta(close, 1) : ((ts_max(delta(close, 1), 5) < 0) ?delta(close, 1) : (-1 * delta(close, 1))))
326 |     def alpha009(self):
327 |         delta_close = delta(self.close, 1)
328 |         cond_1 = ts_min(delta_close, 5) > 0
329 |         cond_2 = ts_max(delta_close, 5) < 0
330 |         alpha = -1 * delta_close
331 |         alpha[cond_1 | cond_2] = delta_close
332 |         return alpha
333 |     
334 |     # Alpha#10	 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)))))
335 |     def alpha010(self):
336 |         delta_close = delta(self.close, 1)
337 |         cond_1 = ts_min(delta_close, 4) > 0
338 |         cond_2 = ts_max(delta_close, 4) < 0
339 |         alpha = -1 * delta_close
340 |         alpha[cond_1 | cond_2] = delta_close
341 |         return alpha
342 |     
343 |     # Alpha#11	 ((rank(ts_max((vwap - close), 3)) + rank(ts_min((vwap - close), 3))) *rank(delta(volume, 3)))
344 |     def alpha011(self):
345 |         return ((rank(ts_max((self.vwap - self.close), 3)) + rank(ts_min((self.vwap - self.close), 3))) *rank(delta(self.volume, 3)))
346 |     
347 |     # Alpha#12	 (sign(delta(volume, 1)) * (-1 * delta(close, 1)))
348 |     def alpha012(self):
349 |         return sign(delta(self.volume, 1)) * (-1 * delta(self.close, 1))
350 | 
351 |     # Alpha#13	 (-1 * rank(covariance(rank(close), rank(volume), 5)))
352 |     def alpha013(self):
353 |         return -1 * rank(covariance(rank(self.close), rank(self.volume), 5))
354 |     
355 |     # Alpha#14	 ((-1 * rank(delta(returns, 3))) * correlation(open, volume, 10))
356 |     def alpha014(self):
357 |         df = correlation(self.open, self.volume, 10)
358 |         df = df.replace([-np.inf, np.inf], 0).fillna(value=0)
359 |         return -1 * rank(delta(self.returns, 3)) * df
360 |     
361 |     # Alpha#15	 (-1 * sum(rank(correlation(rank(high), rank(volume), 3)), 3))
362 |     def alpha015(self):
363 |         df = correlation(rank(self.high), rank(self.volume), 3)
364 |         df = df.replace([-np.inf, np.inf], 0).fillna(value=0)
365 |         return -1 * ts_sum(rank(df), 3)
366 |     
367 |     # Alpha#16	 (-1 * rank(covariance(rank(high), rank(volume), 5)))
368 |     def alpha016(self):
369 |         return -1 * rank(covariance(rank(self.high), rank(self.volume), 5))
370 |     
371 |     # Alpha#17	 (((-1 * rank(ts_rank(close, 10))) * rank(delta(delta(close, 1), 1))) *rank(ts_rank((volume / adv20), 5)))
372 |     def alpha017(self):
373 |         adv20 = sma(self.volume, 20)
374 |         return -1 * (rank(ts_rank(self.close, 10)) *
375 |                      rank(delta(delta(self.close, 1), 1)) *
376 |                      rank(ts_rank((self.volume / adv20), 5)))
377 |         
378 |     # Alpha#18	 (-1 * rank(((stddev(abs((close - open)), 5) + (close - open)) + correlation(close, open,10))))
379 |     def alpha018(self):
380 |         df = correlation(self.close, self.open, 10)
381 |         df = df.replace([-np.inf, np.inf], 0).fillna(value=0)
382 |         return -1 * (rank((stddev(abs((self.close - self.open)), 5) + (self.close - self.open)) +
383 |                           df))
384 |     
385 |     # Alpha#19	 ((-1 * sign(((close - delay(close, 7)) + delta(close, 7)))) * (1 + rank((1 + sum(returns,250)))))
386 |     def alpha019(self):
387 |         return ((-1 * sign((self.close - delay(self.close, 7)) + delta(self.close, 7))) *
388 |                 (1 + rank(1 + ts_sum(self.returns, 250))))
389 |     
390 |     # Alpha#20	 (((-1 * rank((open - delay(high, 1)))) * rank((open - delay(close, 1)))) * rank((open -delay(low, 1))))
391 |     def alpha020(self):
392 |         return -1 * (rank(self.open - delay(self.high, 1)) *
393 |                      rank(self.open - delay(self.close, 1)) *
394 |                      rank(self.open - delay(self.low, 1)))
395 | 
396 |     # Alpha#21	 ((((sum(close, 8) / 8) + stddev(close, 8)) < (sum(close, 2) / 2)) ? (-1 * 1) : (((sum(close,2) / 2) < ((sum(close, 8) / 8) - stddev(close, 8))) ? 1 : (((1 < (volume / adv20)) || ((volume /adv20) == 1)) ? 1 : (-1 * 1))))
397 |     def alpha021(self):
398 |         cond_1 = sma(self.close, 8) + stddev(self.close, 8) < sma(self.close, 2)
399 |         cond_2 = sma(self.volume, 20) / self.volume < 1
400 |         alpha = pd.DataFrame(np.ones_like(self.close), index=self.close.index
401 |                              )
402 | #        alpha = pd.DataFrame(np.ones_like(self.close), index=self.close.index,
403 | #                             columns=self.close.columns)
404 |         alpha[cond_1 | cond_2] = -1
405 |         return alpha
406 |     
407 |     # Alpha#22	 (-1 * (delta(correlation(high, volume, 5), 5) * rank(stddev(close, 20))))
408 |     def alpha022(self):
409 |         df = correlation(self.high, self.volume, 5)
410 |         df = df.replace([-np.inf, np.inf], 0).fillna(value=0)
411 |         return -1 * delta(df, 5) * rank(stddev(self.close, 20))
412 | 
413 |     # Alpha#23	 (((sum(high, 20) / 20) < high) ? (-1 * delta(high, 2)) : 0)
414 |     def alpha023(self):
415 |         cond = sma(self.high, 20) < self.high
416 |         alpha = pd.DataFrame(np.zeros_like(self.close),index=self.close.index,columns=['close'])
417 |         alpha.at[cond,'close'] = -1 * delta(self.high, 2).fillna(value=0)
418 |         return alpha
419 |     
420 |     # Alpha#24	 ((((delta((sum(close, 100) / 100), 100) / delay(close, 100)) < 0.05) ||((delta((sum(close, 100) / 100), 100) / delay(close, 100)) == 0.05)) ? (-1 * (close - ts_min(close,100))) : (-1 * delta(close, 3)))
421 |     def alpha024(self):
422 |         cond = delta(sma(self.close, 100), 100) / delay(self.close, 100) <= 0.05
423 |         alpha = -1 * delta(self.close, 3)
424 |         alpha[cond] = -1 * (self.close - ts_min(self.close, 100))
425 |         return alpha
426 |     
427 |     # Alpha#25	 rank(((((-1 * returns) * adv20) * vwap) * (high - close)))
428 |     def alpha025(self):
429 |         adv20 = sma(self.volume, 20)
430 |         return rank(((((-1 * self.returns) * adv20) * self.vwap) * (self.high - self.close)))
431 |     
432 |     # Alpha#26	 (-1 * ts_max(correlation(ts_rank(volume, 5), ts_rank(high, 5), 5), 3))
433 |     def alpha026(self):
434 |         df = correlation(ts_rank(self.volume, 5), ts_rank(self.high, 5), 5)
435 |         df = df.replace([-np.inf, np.inf], 0).fillna(value=0)
436 |         return -1 * ts_max(df, 3)
437 |     
438 |     # Alpha#27	 ((0.5 < rank((sum(correlation(rank(volume), rank(vwap), 6), 2) / 2.0))) ? (-1 * 1) : 1)
439 |     ###
440 |     ## Some Error, still fixing!!
441 |     def alpha027(self):
442 |         alpha = rank((sma(correlation(rank(self.volume), rank(self.vwap), 6), 2) / 2.0))
443 |         alpha[alpha > 0.5] = -1
444 |         alpha[alpha <= 0.5]=1
445 |         return alpha  
446 |     
447 |     # Alpha#28	 scale(((correlation(adv20, low, 5) + ((high + low) / 2)) - close))
448 |     def alpha028(self):
449 |         adv20 = sma(self.volume, 20)
450 |         df = correlation(adv20, self.low, 5)
451 |         df = df.replace([-np.inf, np.inf], 0).fillna(value=0)
452 |         return scale(((df + ((self.high + self.low) / 2)) - self.close))
453 | 
454 |     # Alpha#29	 (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))
455 |     def alpha029(self):
456 |         return (ts_min(rank(rank(scale(log(ts_sum(rank(rank(-1 * rank(delta((self.close - 1), 5)))), 2))))), 5) +
457 |                 ts_rank(delay((-1 * self.returns), 6), 5))
458 | 
459 |     # Alpha#30	 (((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))
460 |     def alpha030(self):
461 |         delta_close = delta(self.close, 1)
462 |         inner = sign(delta_close) + sign(delay(delta_close, 1)) + sign(delay(delta_close, 2))
463 |         return ((1.0 - rank(inner)) * ts_sum(self.volume, 5)) / ts_sum(self.volume, 20)
464 | 
465 |     # Alpha#31	 ((rank(rank(rank(decay_linear((-1 * rank(rank(delta(close, 10)))), 10)))) + rank((-1 *delta(close, 3)))) + sign(scale(correlation(adv20, low, 12))))
466 |     def alpha031(self):
467 |         adv20 = sma(self.volume, 20)
468 |         df = correlation(adv20, self.low, 12).replace([-np.inf, np.inf], 0).fillna(value=0)         
469 |         p1=rank(rank(rank(decay_linear((-1 * rank(rank(delta(self.close, 10)))).to_frame(), 10)))) 
470 |         p2=rank((-1 * delta(self.close, 3)))
471 |         p3=sign(scale(df))
472 |         
473 |         return p1.CLOSE+p2+p3
474 | 
475 |     # Alpha#32	 (scale(((sum(close, 7) / 7) - close)) + (20 * scale(correlation(vwap, delay(close, 5),230))))
476 |     def alpha032(self):
477 |         return scale(((sma(self.close, 7) / 7) - self.close)) + (20 * scale(correlation(self.vwap, delay(self.close, 5),230)))
478 |     
479 |     # Alpha#33	 rank((-1 * ((1 - (open / close))^1)))
480 |     def alpha033(self):
481 |         return rank(-1 + (self.open / self.close))
482 |     
483 |     # Alpha#34	 rank(((1 - rank((stddev(returns, 2) / stddev(returns, 5)))) + (1 - rank(delta(close, 1)))))
484 |     def alpha034(self):
485 |         inner = stddev(self.returns, 2) / stddev(self.returns, 5)
486 |         inner = inner.replace([-np.inf, np.inf], 1).fillna(value=1)
487 |         return rank(2 - rank(inner) - rank(delta(self.close, 1)))
488 | 
489 |     # Alpha#35	 ((Ts_Rank(volume, 32) * (1 - Ts_Rank(((close + high) - low), 16))) * (1 -Ts_Rank(returns, 32)))
490 |     def alpha035(self):
491 |         return ((ts_rank(self.volume, 32) *
492 |                  (1 - ts_rank(self.close + self.high - self.low, 16))) *
493 |                 (1 - ts_rank(self.returns, 32)))
494 |             
495 |     # Alpha#36	 (((((2.21 * rank(correlation((close - open), delay(volume, 1), 15))) + (0.7 * rank((open- close)))) + (0.73 * rank(Ts_Rank(delay((-1 * returns), 6), 5)))) + rank(abs(correlation(vwap,adv20, 6)))) + (0.6 * rank((((sum(close, 200) / 200) - open) * (close - open)))))
496 |     def alpha036(self):
497 |         adv20 = sma(self.volume, 20)
498 |         return (((((2.21 * rank(correlation((self.close - self.open), delay(self.volume, 1), 15))) + (0.7 * rank((self.open- self.close)))) + (0.73 * rank(ts_rank(delay((-1 * self.returns), 6), 5)))) + rank(abs(correlation(self.vwap,adv20, 6)))) + (0.6 * rank((((sma(self.close, 200) / 200) - self.open) * (self.close - self.open)))))
499 |     
500 |     # Alpha#37	 (rank(correlation(delay((open - close), 1), close, 200)) + rank((open - close)))
501 |     def alpha037(self):
502 |         return rank(correlation(delay(self.open - self.close, 1), self.close, 200)) + rank(self.open - self.close)
503 |     
504 |     # Alpha#38	 ((-1 * rank(Ts_Rank(close, 10))) * rank((close / open)))
505 |     def alpha038(self):
506 |         inner = self.close / self.open
507 |         inner = inner.replace([-np.inf, np.inf], 1).fillna(value=1)
508 |         return -1 * rank(ts_rank(self.open, 10)) * rank(inner)
509 |     
510 |     # Alpha#39	 ((-1 * rank((delta(close, 7) * (1 - rank(decay_linear((volume / adv20), 9)))))) * (1 +rank(sum(returns, 250))))
511 |     def alpha039(self):
512 |         adv20 = sma(self.volume, 20)
513 |         return ((-1 * rank(delta(self.close, 7) * (1 - rank(decay_linear((self.volume / adv20).to_frame(), 9).CLOSE)))) *
514 |                 (1 + rank(sma(self.returns, 250))))
515 |     
516 |     # Alpha#40	 ((-1 * rank(stddev(high, 10))) * correlation(high, volume, 10))
517 |     def alpha040(self):
518 |         return -1 * rank(stddev(self.high, 10)) * correlation(self.high, self.volume, 10)
519 | 
520 |     # Alpha#41	 (((high * low)^0.5) - vwap)
521 |     def alpha041(self):
522 |         return pow((self.high * self.low),0.5) - self.vwap
523 |     
524 |     # Alpha#42	 (rank((vwap - close)) / rank((vwap + close)))
525 |     def alpha042(self):
526 |         return rank((self.vwap - self.close)) / rank((self.vwap + self.close))
527 |         
528 |     # Alpha#43	 (ts_rank((volume / adv20), 20) * ts_rank((-1 * delta(close, 7)), 8))
529 |     def alpha043(self):
530 |         adv20 = sma(self.volume, 20)
531 |         return ts_rank(self.volume / adv20, 20) * ts_rank((-1 * delta(self.close, 7)), 8)
532 | 
533 |     # Alpha#44	 (-1 * correlation(high, rank(volume), 5))
534 |     def alpha044(self):
535 |         df = correlation(self.high, rank(self.volume), 5)
536 |         df = df.replace([-np.inf, np.inf], 0).fillna(value=0)
537 |         return -1 * df
538 | 
539 |     # Alpha#45	 (-1 * ((rank((sum(delay(close, 5), 20) / 20)) * correlation(close, volume, 2)) *rank(correlation(sum(close, 5), sum(close, 20), 2))))
540 |     def alpha045(self):
541 |         df = correlation(self.close, self.volume, 2)
542 |         df = df.replace([-np.inf, np.inf], 0).fillna(value=0)
543 |         return -1 * (rank(sma(delay(self.close, 5), 20)) * df *
544 |                      rank(correlation(ts_sum(self.close, 5), ts_sum(self.close, 20), 2)))
545 |     
546 |     # Alpha#46	 ((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)))))
547 |     def alpha046(self):
548 |         inner = ((delay(self.close, 20) - delay(self.close, 10)) / 10) - ((delay(self.close, 10) - self.close) / 10)
549 |         alpha = (-1 * delta(self.close))
550 |         alpha[inner < 0] = 1
551 |         alpha[inner > 0.25] = -1
552 |         return alpha
553 | 
554 |     # Alpha#47	 ((((rank((1 / close)) * volume) / adv20) * ((high * rank((high - close))) / (sum(high, 5) /5))) - rank((vwap - delay(vwap, 5))))
555 |     def alpha047(self):
556 |         adv20 = sma(self.volume, 20)
557 |         return ((((rank((1 / self.close)) * self.volume) / adv20) * ((self.high * rank((self.high - self.close))) / (sma(self.high, 5) /5))) - rank((self.vwap - delay(self.vwap, 5))))
558 |     
559 |     # Alpha#48	 (indneutralize(((correlation(delta(close, 1), delta(delay(close, 1), 1), 250) *delta(close, 1)) / close), IndClass.subindustry) / sum(((delta(close, 1) / delay(close, 1))^2), 250))
560 |      
561 |     
562 |     # Alpha#49	 (((((delay(close, 20) - delay(close, 10)) / 10) - ((delay(close, 10) - close) / 10)) < (-1 *0.1)) ? 1 : ((-1 * 1) * (close - delay(close, 1))))
563 |     def alpha049(self):
564 |         inner = (((delay(self.close, 20) - delay(self.close, 10)) / 10) - ((delay(self.close, 10) - self.close) / 10))
565 |         alpha = (-1 * delta(self.close))
566 |         alpha[inner < -0.1] = 1
567 |         return alpha
568 |     
569 |     # Alpha#50	 (-1 * ts_max(rank(correlation(rank(volume), rank(vwap), 5)), 5))
570 |     def alpha050(self):
571 |         return (-1 * ts_max(rank(correlation(rank(self.volume), rank(self.vwap), 5)), 5))
572 |     
573 |     # Alpha#51	 (((((delay(close, 20) - delay(close, 10)) / 10) - ((delay(close, 10) - close) / 10)) < (-1 *0.05)) ? 1 : ((-1 * 1) * (close - delay(close, 1))))
574 |     def alpha051(self):
575 |         inner = (((delay(self.close, 20) - delay(self.close, 10)) / 10) - ((delay(self.close, 10) - self.close) / 10))
576 |         alpha = (-1 * delta(self.close))
577 |         alpha[inner < -0.05] = 1
578 |         return alpha
579 |     
580 |     # Alpha#52	 ((((-1 * ts_min(low, 5)) + delay(ts_min(low, 5), 5)) * rank(((sum(returns, 240) -sum(returns, 20)) / 220))) * ts_rank(volume, 5))
581 |     def alpha052(self):
582 |         return (((-1 * delta(ts_min(self.low, 5), 5)) *
583 |                  rank(((ts_sum(self.returns, 240) - ts_sum(self.returns, 20)) / 220))) * ts_rank(self.volume, 5))
584 |         
585 |     # Alpha#53	 (-1 * delta((((close - low) - (high - close)) / (close - low)), 9))
586 |     def alpha053(self):
587 |         inner = (self.close - self.low).replace(0, 0.0001)
588 |         return -1 * delta((((self.close - self.low) - (self.high - self.close)) / inner), 9)
589 | 
590 |     # Alpha#54	 ((-1 * ((low - close) * (open^5))) / ((low - high) * (close^5)))
591 |     def alpha054(self):
592 |         inner = (self.low - self.high).replace(0, -0.0001)
593 |         return -1 * (self.low - self.close) * (self.open ** 5) / (inner * (self.close ** 5))
594 | 
595 |     # Alpha#55	 (-1 * correlation(rank(((close - ts_min(low, 12)) / (ts_max(high, 12) - ts_min(low,12)))), rank(volume), 6))
596 |     def alpha055(self):
597 |         divisor = (ts_max(self.high, 12) - ts_min(self.low, 12)).replace(0, 0.0001)
598 |         inner = (self.close - ts_min(self.low, 12)) / (divisor)
599 |         df = correlation(rank(inner), rank(self.volume), 6)
600 |         return -1 * df.replace([-np.inf, np.inf], 0).fillna(value=0)
601 | 
602 |     # Alpha#56	 (0 - (1 * (rank((sum(returns, 10) / sum(sum(returns, 2), 3))) * rank((returns * cap)))))
603 |     # This Alpha uses the Cap, however I have not acquired the data yet
604 | #    def alpha056(self):
605 | #        return (0 - (1 * (rank((sma(self.returns, 10) / sma(sma(self.returns, 2), 3))) * rank((self.returns * self.cap)))))
606 |     
607 |     # Alpha#57	 (0 - (1 * ((close - vwap) / decay_linear(rank(ts_argmax(close, 30)), 2))))
608 |     def alpha057(self):
609 |         return (0 - (1 * ((self.close - self.vwap) / decay_linear(rank(ts_argmax(self.close, 30)).to_frame(), 2).CLOSE)))
610 |     
611 |     # Alpha#58	 (-1 * Ts_Rank(decay_linear(correlation(IndNeutralize(vwap, IndClass.sector), volume,3.92795), 7.89291), 5.50322))
612 |      
613 |     # Alpha#59	 (-1 * Ts_Rank(decay_linear(correlation(IndNeutralize(((vwap * 0.728317) + (vwap *(1 - 0.728317))), IndClass.industry), volume, 4.25197), 16.2289), 8.19648))
614 |      
615 |     
616 |     # Alpha#60	 (0 - (1 * ((2 * scale(rank(((((close - low) - (high - close)) / (high - low)) * volume)))) -scale(rank(ts_argmax(close, 10))))))
617 |     def alpha060(self):
618 |         divisor = (self.high - self.low).replace(0, 0.0001)
619 |         inner = ((self.close - self.low) - (self.high - self.close)) * self.volume / divisor
620 |         return - ((2 * scale(rank(inner))) - scale(rank(ts_argmax(self.close, 10))))
621 |     
622 | 	# Alpha#61	 (rank((vwap - ts_min(vwap, 16.1219))) < rank(correlation(vwap, adv180, 17.9282)))
623 |     def alpha061(self):
624 |         adv180 = sma(self.volume, 180)
625 |         return (rank((self.vwap - ts_min(self.vwap, 16))) < rank(correlation(self.vwap, adv180, 18)))
626 |     
627 | 	# Alpha#62	 ((rank(correlation(vwap, sum(adv20, 22.4101), 9.91009)) < rank(((rank(open) +rank(open)) < (rank(((high + low) / 2)) + rank(high))))) * -1)
628 |     def alpha062(self):
629 |         adv20 = sma(self.volume, 20)
630 |         return ((rank(correlation(self.vwap, sma(adv20, 22), 10)) < rank(((rank(self.open) +rank(self.open)) < (rank(((self.high + self.low) / 2)) + rank(self.high))))) * -1)
631 |     
632 |     # Alpha#63	 ((rank(decay_linear(delta(IndNeutralize(close, IndClass.industry), 2.25164), 8.22237))- rank(decay_linear(correlation(((vwap * 0.318108) + (open * (1 - 0.318108))), sum(adv180,37.2467), 13.557), 12.2883))) * -1)
633 |      
634 |     
635 |     # Alpha#64	 ((rank(correlation(sum(((open * 0.178404) + (low * (1 - 0.178404))), 12.7054),sum(adv120, 12.7054), 16.6208)) < rank(delta(((((high + low) / 2) * 0.178404) + (vwap * (1 -0.178404))), 3.69741))) * -1)
636 |     def alpha064(self):
637 |         adv120 = sma(self.volume, 120)
638 |         return ((rank(correlation(sma(((self.open * 0.178404) + (self.low * (1 - 0.178404))), 13),sma(adv120, 13), 17)) < rank(delta(((((self.high + self.low) / 2) * 0.178404) + (self.vwap * (1 -0.178404))), 3.69741))) * -1)
639 |     
640 |     # Alpha#65	 ((rank(correlation(((open * 0.00817205) + (vwap * (1 - 0.00817205))), sum(adv60,8.6911), 6.40374)) < rank((open - ts_min(open, 13.635)))) * -1)
641 |     def alpha065(self):
642 |         adv60 = sma(self.volume, 60)
643 |         return ((rank(correlation(((self.open * 0.00817205) + (self.vwap * (1 - 0.00817205))), sma(adv60,9), 6)) < rank((self.open - ts_min(self.open, 14)))) * -1)
644 |       
645 |     # Alpha#66	 ((rank(decay_linear(delta(vwap, 3.51013), 7.23052)) + Ts_Rank(decay_linear(((((low* 0.96633) + (low * (1 - 0.96633))) - vwap) / (open - ((high + low) / 2))), 11.4157), 6.72611)) * -1)
646 |     def alpha066(self):
647 |         return ((rank(decay_linear(delta(self.vwap, 4).to_frame(), 7).CLOSE) + ts_rank(decay_linear(((((self.low* 0.96633) + (self.low * (1 - 0.96633))) - self.vwap) / (self.open - ((self.high + self.low) / 2))).to_frame(), 11).CLOSE, 7)) * -1)
648 |     
649 |     # Alpha#67	 ((rank((high - ts_min(high, 2.14593)))^rank(correlation(IndNeutralize(vwap,IndClass.sector), IndNeutralize(adv20, IndClass.subindustry), 6.02936))) * -1)
650 |      
651 |     
652 |     # Alpha#68	 ((Ts_Rank(correlation(rank(high), rank(adv15), 8.91644), 13.9333) <rank(delta(((close * 0.518371) + (low * (1 - 0.518371))), 1.06157))) * -1)
653 |     def alpha068(self):
654 |         adv15 = sma(self.volume, 15)
655 |         return ((ts_rank(correlation(rank(self.high), rank(adv15), 9), 14) <rank(delta(((self.close * 0.518371) + (self.low * (1 - 0.518371))), 1.06157))) * -1)
656 |     
657 |     # Alpha#69	 ((rank(ts_max(delta(IndNeutralize(vwap, IndClass.industry), 2.72412),4.79344))^Ts_Rank(correlation(((close * 0.490655) + (vwap * (1 - 0.490655))), adv20, 4.92416),9.0615)) * -1)
658 |          
659 |     # Alpha#70	 ((rank(delta(vwap, 1.29456))^Ts_Rank(correlation(IndNeutralize(close,IndClass.industry), adv50, 17.8256), 17.9171)) * -1)
660 |      
661 |     
662 |     # Alpha#71	 max(Ts_Rank(decay_linear(correlation(Ts_Rank(close, 3.43976), Ts_Rank(adv180,12.0647), 18.0175), 4.20501), 15.6948), Ts_Rank(decay_linear((rank(((low + open) - (vwap +vwap)))^2), 16.4662), 4.4388))
663 |     def alpha071(self):
664 |         adv180 = sma(self.volume, 180)
665 |         p1=ts_rank(decay_linear(correlation(ts_rank(self.close, 3), ts_rank(adv180,12), 18).to_frame(), 4).CLOSE, 16)
666 |         p2=ts_rank(decay_linear((rank(((self.low + self.open) - (self.vwap +self.vwap))).pow(2)).to_frame(), 16).CLOSE, 4)
667 |         df=pd.DataFrame({'p1':p1,'p2':p2})
668 |         df.at[df['p1']>=df['p2'],'max']=df['p1']
669 |         df.at[df['p2']>=df['p1'],'max']=df['p2']
670 |         return df['max']
671 |         #return max(ts_rank(decay_linear(correlation(ts_rank(self.close, 3), ts_rank(adv180,12), 18).to_frame(), 4).CLOSE, 16), ts_rank(decay_linear((rank(((self.low + self.open) - (self.vwap +self.vwap))).pow(2)).to_frame(), 16).CLOSE, 4))
672 |     
673 |     # Alpha#72	 (rank(decay_linear(correlation(((high + low) / 2), adv40, 8.93345), 10.1519)) /rank(decay_linear(correlation(Ts_Rank(vwap, 3.72469), Ts_Rank(volume, 18.5188), 6.86671),2.95011)))
674 |     def alpha072(self):
675 |         adv40 = sma(self.volume, 40)
676 |         return (rank(decay_linear(correlation(((self.high + self.low) / 2), adv40, 9).to_frame(), 10).CLOSE) /rank(decay_linear(correlation(ts_rank(self.vwap, 4), ts_rank(self.volume, 19), 7).to_frame(),3).CLOSE))
677 |     
678 |     # Alpha#73	 (max(rank(decay_linear(delta(vwap, 4.72775), 2.91864)),Ts_Rank(decay_linear(((delta(((open * 0.147155) + (low * (1 - 0.147155))), 2.03608) / ((open *0.147155) + (low * (1 - 0.147155)))) * -1), 3.33829), 16.7411)) * -1)
679 |     def alpha073(self):
680 |         p1=rank(decay_linear(delta(self.vwap, 5).to_frame(), 3).CLOSE)
681 |         p2=ts_rank(decay_linear(((delta(((self.open * 0.147155) + (self.low * (1 - 0.147155))), 2) / ((self.open *0.147155) + (self.low * (1 - 0.147155)))) * -1).to_frame(), 3).CLOSE, 17)
682 |         df=pd.DataFrame({'p1':p1,'p2':p2})
683 |         df.at[df['p1']>=df['p2'],'max']=df['p1']
684 |         df.at[df['p2']>=df['p1'],'max']=df['p2']
685 |         return -1*df['max']
686 |         #return (max(rank(decay_linear(delta(self.vwap, 5).to_frame(), 3).CLOSE),ts_rank(decay_linear(((delta(((self.open * 0.147155) + (self.low * (1 - 0.147155))), 2) / ((self.open *0.147155) + (self.low * (1 - 0.147155)))) * -1).to_frame(), 3).CLOSE, 17)) * -1)
687 |     
688 |     # Alpha#74	 ((rank(correlation(close, sum(adv30, 37.4843), 15.1365)) <rank(correlation(rank(((high * 0.0261661) + (vwap * (1 - 0.0261661)))), rank(volume), 11.4791)))* -1)
689 |     def alpha074(self):
690 |         adv30 = sma(self.volume, 30)
691 |         return ((rank(correlation(self.close, sma(adv30, 37), 15)) <rank(correlation(rank(((self.high * 0.0261661) + (self.vwap * (1 - 0.0261661)))), rank(self.volume), 11)))* -1)
692 |     
693 |     # Alpha#75	 (rank(correlation(vwap, volume, 4.24304)) < rank(correlation(rank(low), rank(adv50),12.4413)))
694 |     def alpha075(self):
695 |         adv50 = sma(self.volume, 50)
696 |         return (rank(correlation(self.vwap, self.volume, 4)) < rank(correlation(rank(self.low), rank(adv50),12)))
697 |     
698 |     # Alpha#76	 (max(rank(decay_linear(delta(vwap, 1.24383), 11.8259)),Ts_Rank(decay_linear(Ts_Rank(correlation(IndNeutralize(low, IndClass.sector), adv81,8.14941), 19.569), 17.1543), 19.383)) * -1)
699 |      
700 | 
701 |     # Alpha#77	 min(rank(decay_linear(((((high + low) / 2) + high) - (vwap + high)), 20.0451)),rank(decay_linear(correlation(((high + low) / 2), adv40, 3.1614), 5.64125)))
702 |     def alpha077(self):
703 |         adv40 = sma(self.volume, 40)
704 |         p1=rank(decay_linear(((((self.high + self.low) / 2) + self.high) - (self.vwap + self.high)).to_frame(), 20).CLOSE)
705 |         p2=rank(decay_linear(correlation(((self.high + self.low) / 2), adv40, 3).to_frame(), 6).CLOSE)
706 |         df=pd.DataFrame({'p1':p1,'p2':p2})
707 |         df.at[df['p1']>=df['p2'],'min']=df['p2']
708 |         df.at[df['p2']>=df['p1'],'min']=df['p1']
709 |         return df['min']
710 |         #return min(rank(decay_linear(((((self.high + self.low) / 2) + self.high) - (self.vwap + self.high)).to_frame(), 20).CLOSE),rank(decay_linear(correlation(((self.high + self.low) / 2), adv40, 3).to_frame(), 6).CLOSE))
711 |     
712 |     # Alpha#78	 (rank(correlation(sum(((low * 0.352233) + (vwap * (1 - 0.352233))), 19.7428),sum(adv40, 19.7428), 6.83313))^rank(correlation(rank(vwap), rank(volume), 5.77492)))
713 |     def alpha078(self):
714 |         adv40 = sma(self.volume, 40)
715 |         return (rank(correlation(ts_sum(((self.low * 0.352233) + (self.vwap * (1 - 0.352233))), 20),ts_sum(adv40,20), 7)).pow(rank(correlation(rank(self.vwap), rank(self.volume), 6))))
716 |     
717 |     # Alpha#79	 (rank(delta(IndNeutralize(((close * 0.60733) + (open * (1 - 0.60733))),IndClass.sector), 1.23438)) < rank(correlation(Ts_Rank(vwap, 3.60973), Ts_Rank(adv150,9.18637), 14.6644)))
718 |      
719 |     # Alpha#80	 ((rank(Sign(delta(IndNeutralize(((open * 0.868128) + (high * (1 - 0.868128))),IndClass.industry), 4.04545)))^Ts_Rank(correlation(high, adv10, 5.11456), 5.53756)) * -1)
720 |      
721 |    
722 |     # Alpha#81	 ((rank(Log(product(rank((rank(correlation(vwap, sum(adv10, 49.6054),8.47743))^4)), 14.9655))) < rank(correlation(rank(vwap), rank(volume), 5.07914))) * -1)
723 |     def alpha081(self):
724 |         adv10 = sma(self.volume, 10)
725 |         return ((rank(log(product(rank((rank(correlation(self.vwap, ts_sum(adv10, 50),8)).pow(4))), 15))) < rank(correlation(rank(self.vwap), rank(self.volume), 5))) * -1)
726 |     
727 |     # Alpha#82	 (min(rank(decay_linear(delta(open, 1.46063), 14.8717)),Ts_Rank(decay_linear(correlation(IndNeutralize(volume, IndClass.sector), ((open * 0.634196) +(open * (1 - 0.634196))), 17.4842), 6.92131), 13.4283)) * -1)
728 |      
729 |     
730 |     # Alpha#83	 ((rank(delay(((high - low) / (sum(close, 5) / 5)), 2)) * rank(rank(volume))) / (((high -low) / (sum(close, 5) / 5)) / (vwap - close)))
731 |     def alpha083(self):
732 |         return ((rank(delay(((self.high - self.low) / (ts_sum(self.close, 5) / 5)), 2)) * rank(rank(self.volume))) / (((self.high -self.low) / (ts_sum(self.close, 5) / 5)) / (self.vwap - self.close)))
733 |     
734 |     # Alpha#84	 SignedPower(Ts_Rank((vwap - ts_max(vwap, 15.3217)), 20.7127), delta(close,4.96796))
735 |     def alpha084(self):
736 |         return pow(ts_rank((self.vwap - ts_max(self.vwap, 15)), 21), delta(self.close,5))
737 |     
738 |     # Alpha#85	 (rank(correlation(((high * 0.876703) + (close * (1 - 0.876703))), adv30,9.61331))^rank(correlation(Ts_Rank(((high + low) / 2), 3.70596), Ts_Rank(volume, 10.1595),7.11408)))
739 |     def alpha085(self):
740 |         adv30 = sma(self.volume, 30)
741 |         return (rank(correlation(((self.high * 0.876703) + (self.close * (1 - 0.876703))), adv30,10)).pow(rank(correlation(ts_rank(((self.high + self.low) / 2), 4), ts_rank(self.volume, 10),7))))
742 |     
743 |     # Alpha#86	 ((Ts_Rank(correlation(close, sum(adv20, 14.7444), 6.00049), 20.4195) < rank(((open+ close) - (vwap + open)))) * -1)
744 | 
745 |     def alpha086(self):
746 |         adv20 = sma(self.volume, 20)
747 |         return ((ts_rank(correlation(self.close, sma(adv20, 15), 6), 20) < rank(((self.open+ self.close) - (self.vwap +self.open)))) * -1)
748 |     
749 |     # Alpha#87	 (max(rank(decay_linear(delta(((close * 0.369701) + (vwap * (1 - 0.369701))),1.91233), 2.65461)), Ts_Rank(decay_linear(abs(correlation(IndNeutralize(adv81,IndClass.industry), close, 13.4132)), 4.89768), 14.4535)) * -1)
750 |      
751 |     
752 |     # Alpha#88	 min(rank(decay_linear(((rank(open) + rank(low)) - (rank(high) + rank(close))),8.06882)), Ts_Rank(decay_linear(correlation(Ts_Rank(close, 8.44728), Ts_Rank(adv60,20.6966), 8.01266), 6.65053), 2.61957))
753 |     def alpha088(self):
754 |         adv60 = sma(self.volume, 60)
755 |         p1=rank(decay_linear(((rank(self.open) + rank(self.low)) - (rank(self.high) + rank(self.close))).to_frame(),8).CLOSE)
756 |         p2=ts_rank(decay_linear(correlation(ts_rank(self.close, 8), ts_rank(adv60,21), 8).to_frame(), 7).CLOSE, 3)
757 |         df=pd.DataFrame({'p1':p1,'p2':p2})
758 |         df.at[df['p1']>=df['p2'],'min']=df['p2']
759 |         df.at[df['p2']>=df['p1'],'min']=df['p1']
760 |         return df['min']
761 |         #return min(rank(decay_linear(((rank(self.open) + rank(self.low)) - (rank(self.high) + rank(self.close))).to_frame(),8).CLOSE), ts_rank(decay_linear(correlation(ts_rank(self.close, 8), ts_rank(adv60,20.6966), 8).to_frame(), 7).CLOSE, 3))
762 |     
763 |     # Alpha#89	 (Ts_Rank(decay_linear(correlation(((low * 0.967285) + (low * (1 - 0.967285))), adv10,6.94279), 5.51607), 3.79744) - Ts_Rank(decay_linear(delta(IndNeutralize(vwap,IndClass.industry), 3.48158), 10.1466), 15.3012))
764 |      
765 |     # Alpha#90	 ((rank((close - ts_max(close, 4.66719)))^Ts_Rank(correlation(IndNeutralize(adv40,IndClass.subindustry), low, 5.38375), 3.21856)) * -1)
766 |      
767 |     # Alpha#91	 ((Ts_Rank(decay_linear(decay_linear(correlation(IndNeutralize(close,IndClass.industry), volume, 9.74928), 16.398), 3.83219), 4.8667) -rank(decay_linear(correlation(vwap, adv30, 4.01303), 2.6809))) * -1)
768 |      
769 | 
770 |     # Alpha#92	 min(Ts_Rank(decay_linear(((((high + low) / 2) + close) < (low + open)), 14.7221),18.8683), Ts_Rank(decay_linear(correlation(rank(low), rank(adv30), 7.58555), 6.94024),6.80584))
771 |     def alpha092(self):
772 |         adv30 = sma(self.volume, 30)
773 |         p1=ts_rank(decay_linear(((((self.high + self.low) / 2) + self.close) < (self.low + self.open)).to_frame(), 15).CLOSE,19)
774 |         p2=ts_rank(decay_linear(correlation(rank(self.low), rank(adv30), 8).to_frame(), 7).CLOSE,7)
775 |         df=pd.DataFrame({'p1':p1,'p2':p2})
776 |         df.at[df['p1']>=df['p2'],'min']=df['p2']
777 |         df.at[df['p2']>=df['p1'],'min']=df['p1']
778 |         return df['min']
779 |         #return  min(ts_rank(decay_linear(((((self.high + self.low) / 2) + self.close) < (self.low + self.open)).to_frame(), 15).CLOSE,19), ts_rank(decay_linear(correlation(rank(self.low), rank(adv30), 8).to_frame(), 7).CLOSE,7))
780 |     
781 |     # Alpha#93	 (Ts_Rank(decay_linear(correlation(IndNeutralize(vwap, IndClass.industry), adv81,17.4193), 19.848), 7.54455) / rank(decay_linear(delta(((close * 0.524434) + (vwap * (1 -0.524434))), 2.77377), 16.2664)))
782 |      
783 |     
784 |     # Alpha#94	 ((rank((vwap - ts_min(vwap, 11.5783)))^Ts_Rank(correlation(Ts_Rank(vwap,19.6462), Ts_Rank(adv60, 4.02992), 18.0926), 2.70756)) * -1)
785 |     def alpha094(self):
786 |         adv60 = sma(self.volume, 60)
787 |         return ((rank((self.vwap - ts_min(self.vwap, 12))).pow(ts_rank(correlation(ts_rank(self.vwap,20), ts_rank(adv60, 4), 18), 3)) * -1))
788 |     
789 |     # Alpha#95	 (rank((open - ts_min(open, 12.4105))) < Ts_Rank((rank(correlation(sum(((high + low)/ 2), 19.1351), sum(adv40, 19.1351), 12.8742))^5), 11.7584))
790 |     def alpha095(self):
791 |         adv40 = sma(self.volume, 40)
792 |         return (rank((self.open - ts_min(self.open, 12))) < ts_rank((rank(correlation(sma(((self.high + self.low)/ 2), 19), sma(adv40, 19), 13)).pow(5)), 12))
793 |     
794 |     # Alpha#96	 (max(Ts_Rank(decay_linear(correlation(rank(vwap), rank(volume), 3.83878),4.16783), 8.38151), Ts_Rank(decay_linear(Ts_ArgMax(correlation(Ts_Rank(close, 7.45404),Ts_Rank(adv60, 4.13242), 3.65459), 12.6556), 14.0365), 13.4143)) * -1)
795 |     def alpha096(self):
796 |         adv60 = sma(self.volume, 60)
797 |         p1=ts_rank(decay_linear(correlation(rank(self.vwap), rank(self.volume).to_frame(), 4),4).CLOSE, 8)
798 |         p2=ts_rank(decay_linear(ts_argmax(correlation(ts_rank(self.close, 7),ts_rank(adv60, 4), 4), 13).to_frame(), 14).CLOSE, 13)
799 |         df=pd.DataFrame({'p1':p1,'p2':p2})
800 |         df.at[df['p1']>=df['p2'],'max']=df['p1']
801 |         df.at[df['p2']>=df['p1'],'max']=df['p2']
802 |         return -1*df['max']
803 |         #return (max(ts_rank(decay_linear(correlation(rank(self.vwap), rank(self.volume).to_frame(), 4),4).CLOSE, 8), ts_rank(decay_linear(ts_argmax(correlation(ts_rank(self.close, 7),ts_rank(adv60, 4), 4), 13).to_frame(), 14).CLOSE, 13)) * -1)
804 |     
805 |     # Alpha#97	 ((rank(decay_linear(delta(IndNeutralize(((low * 0.721001) + (vwap * (1 - 0.721001))),IndClass.industry), 3.3705), 20.4523)) - Ts_Rank(decay_linear(Ts_Rank(correlation(Ts_Rank(low,7.87871), Ts_Rank(adv60, 17.255), 4.97547), 18.5925), 15.7152), 6.71659)) * -1)
806 |      
807 |     
808 |     # Alpha#98	 (rank(decay_linear(correlation(vwap, sum(adv5, 26.4719), 4.58418), 7.18088)) -rank(decay_linear(Ts_Rank(Ts_ArgMin(correlation(rank(open), rank(adv15), 20.8187), 8.62571),6.95668), 8.07206)))
809 |     def alpha098(self):
810 |         adv5 = sma(self.volume, 5)
811 |         adv15 = sma(self.volume, 15)
812 |         return (rank(decay_linear(correlation(self.vwap, sma(adv5, 26), 5).to_frame(), 7).CLOSE) -rank(decay_linear(ts_rank(ts_argmin(correlation(rank(self.open), rank(adv15), 21), 9),7).to_frame(), 8).CLOSE))
813 |     
814 |     # Alpha#99	 ((rank(correlation(sum(((high + low) / 2), 19.8975), sum(adv60, 19.8975), 8.8136)) <rank(correlation(low, volume, 6.28259))) * -1)
815 |     def alpha099(self):
816 |         adv60 = sma(self.volume, 60)
817 |         return ((rank(correlation(ts_sum(((self.high + self.low) / 2), 20), ts_sum(adv60, 20), 9)) <rank(correlation(self.low, self.volume, 6))) * -1)
818 |     
819 |     # Alpha#100	 (0 - (1 * (((1.5 * scale(indneutralize(indneutralize(rank(((((close - low) - (high -close)) / (high - low)) * volume)), IndClass.subindustry), IndClass.subindustry))) -scale(indneutralize((correlation(close, rank(adv20), 5) - rank(ts_argmin(close, 30))),IndClass.subindustry))) * (volume / adv20))))
820 |      
821 | 
822 |     # Alpha#101	 ((close - open) / ((high - low) + .001))
823 |     def alpha101(self):
824 |         return (self.close - self.open) /((self.high - self.low) + 0.001)
825 |      
826 |      


--------------------------------------------------------------------------------
/101Alpha_code_2.py:
--------------------------------------------------------------------------------
   1 | import pandas as pd
   2 | import numpy as np
   3 | from scipy import stats 
   4 | 
   5 | 
   6 |  def make_factors():
   7 |         
   8 |             #  (rank(Ts_ArgMax(SignedPower(((returns < 0) ? stddev(returns, 20) : close), 2.), 5)) - 0.5)
   9 |     class Alpha1(CustomFactor):
  10 |         inputs = [USEquityPricing.close, Returns(window_length=2)]
  11 |         window_length = 20
  12 | 
  13 |         def compute(self, today, assets, out, close, returns):
  14 |             v000 = np.empty((5, out.shape[0]))
  15 |             for i0 in range(1, 6):
  16 |                 v000000 = returns[-i0]
  17 |                 v000001 = np.full(out.shape[0], 0.0)
  18 |                 v00000 = v000000 < v000001
  19 |                 v000010 = np.empty((20, out.shape[0]))
  20 |                 for i1 in range(1, 21):
  21 |                     v000010[-i1] = returns[-i1]
  22 |                 v00001 = np.std(v000010, axis=0)
  23 |                 v00002 = close[-i0]
  24 |                 v0000lgcl = np.empty(out.shape[0])
  25 |                 v0000lgcl[v00000] = v00001[v00000]
  26 |                 v0000lgcl[~v00000] = v00002[~v00000]
  27 |                 v0000 = v0000lgcl
  28 |                 v0001 = np.full(out.shape[0], 2.0)
  29 |                 v000[-i0] = np.power(v0000, v0001)
  30 |             v00 = np.argmax(v000, axis=0)
  31 |             v0 = stats.rankdata(v00)
  32 |             v1 = np.full(out.shape[0], 0.5)
  33 |             out[:] = v0 - v1
  34 | 
  35 |     #  (-1 * correlation(rank(delta(log(volume), 2)), rank(((close - open) / open)), 6))
  36 |     class Alpha2(CustomFactor):
  37 |         inputs = [USEquityPricing.volume, USEquityPricing.close, USEquityPricing.open]
  38 |         window_length = 6
  39 | 
  40 |         def compute(self, today, assets, out, volume, close, open):
  41 |             v0 = np.full(out.shape[0], -1.0)
  42 |             v10 = np.empty((6, out.shape[0]))
  43 |             for i0 in range(1, 7):
  44 |                 v1000 = np.empty((3, out.shape[0]))
  45 |                 for i1 in range(1, 4):
  46 |                     v10000 = volume[-i1]
  47 |                     v1000[-i1] = np.log(v10000)
  48 |                 v100 = v1000[-1] - v1000[-3]
  49 |                 v10[-i0] = stats.rankdata(v100)
  50 |             v11 = np.empty((6, out.shape[0]))
  51 |             for i0 in range(1, 7):
  52 |                 v11000 = close[-i0]
  53 |                 v11001 = open[-i0]
  54 |                 v1100 = v11000 - v11001
  55 |                 v1101 = open[-i0]
  56 |                 v110 = v1100 / v1101
  57 |                 v11[-i0] = stats.rankdata(v110)
  58 |             v1 = pd.DataFrame(v10).rolling(window=6).cov(pd.DataFrame(v11)).tail(1).as_matrix()[-1]
  59 |             out[:] = v0 * v1
  60 | 
  61 |     #  (-1 * correlation(rank(open), rank(volume), 10))
  62 |     class Alpha3(CustomFactor):
  63 |         inputs = [USEquityPricing.volume, USEquityPricing.open]
  64 |         window_length = 10
  65 | 
  66 |         def compute(self, today, assets, out, volume, open):
  67 |             v0 = np.full(out.shape[0], -1.0)
  68 |             v10 = np.empty((10, out.shape[0]))
  69 |             for i0 in range(1, 11):
  70 |                 v100 = open[-i0]
  71 |                 v10[-i0] = stats.rankdata(v100)
  72 |             v11 = np.empty((10, out.shape[0]))
  73 |             for i0 in range(1, 11):
  74 |                 v110 = volume[-i0]
  75 |                 v11[-i0] = stats.rankdata(v110)
  76 |             v1 = pd.DataFrame(v10).rolling(window=10).cov(pd.DataFrame(v11)).tail(1).as_matrix()[-1]
  77 |             out[:] = v0 * v1
  78 | 
  79 |     #  (-1 * Ts_Rank(rank(low), 9))
  80 |     class Alpha4(CustomFactor):
  81 |         inputs = [USEquityPricing.low]
  82 |         window_length = 9
  83 | 
  84 |         def compute(self, today, assets, out, low):
  85 |             v0 = np.full(out.shape[0], -1.0)
  86 |             v10 = np.empty((9, out.shape[0]))
  87 |             for i0 in range(1, 10):
  88 |                 v100 = low[-i0]
  89 |                 v10[-i0] = stats.rankdata(v100)
  90 |             v1 = pd.DataFrame(v10).rank().tail(1).as_matrix()[-1]
  91 |             out[:] = v0 * v1
  92 | 
  93 |     #  (rank((open - (sum(vwap, 10) / 10))) * (-1 * abs(rank((close - vwap)))))
  94 |     class Alpha5(CustomFactor):
  95 |         vwap_in = VWAP(window_length=2)
  96 |         vwap_in.window_safe = True
  97 |         inputs = [USEquityPricing.close, USEquityPricing.open, vwap_in]
  98 |         window_length = 10
  99 | 
 100 |         def compute(self, today, assets, out, close, open, vwap):
 101 |             v000 = open[-1]
 102 |             v00100 = np.empty((10, out.shape[0]))
 103 |             for i0 in range(1, 11):
 104 |                 v00100[-i0] = vwap[-i0]
 105 |             v0010 = v00100.sum(axis=0)
 106 |             v0011 = np.full(out.shape[0], 10.0)
 107 |             v001 = v0010 / v0011
 108 |             v00 = v000 - v001
 109 |             v0 = stats.rankdata(v00)
 110 |             v10 = np.full(out.shape[0], -1.0)
 111 |             v11000 = close[-1]
 112 |             v11001 = vwap[-1]
 113 |             v1100 = v11000 - v11001
 114 |             v110 = stats.rankdata(v1100)
 115 |             v11 = np.abs(v110)
 116 |             v1 = v10 * v11
 117 |             out[:] = v0 * v1
 118 | 
 119 |     #  (-1 * correlation(open, volume, 10))
 120 |     class Alpha6(CustomFactor):
 121 |         inputs = [USEquityPricing.volume, USEquityPricing.open]
 122 |         window_length = 10
 123 | 
 124 |         def compute(self, today, assets, out, volume, open):
 125 |             v0 = np.full(out.shape[0], -1.0)
 126 |             v10 = np.empty((10, out.shape[0]))
 127 |             for i0 in range(1, 11):
 128 |                 v10[-i0] = open[-i0]
 129 |             v11 = np.empty((10, out.shape[0]))
 130 |             for i0 in range(1, 11):
 131 |                 v11[-i0] = volume[-i0]
 132 |             v1 = pd.DataFrame(v10).rolling(window=10).cov(pd.DataFrame(v11)).tail(1).as_matrix()[-1]
 133 |             out[:] = v0 * v1
 134 | 
 135 |     #  ((adv20 < volume) ? ((-1 * ts_rank(abs(delta(close, 7)), 60)) * sign(delta(close, 7))) : (-1 * 1))
 136 |     class Alpha7(CustomFactor):
 137 |         adv20_in = AverageDollarVolume(window_length=20)
 138 |         adv20_in.window_safe = True
 139 |         inputs = [USEquityPricing.volume, USEquityPricing.close, adv20_in]
 140 |         window_length = 60
 141 | 
 142 |         def compute(self, today, assets, out, volume, close, adv20):
 143 |             v00 = adv20[-1]
 144 |             v01 = volume[-1]
 145 |             v0 = v00 < v01
 146 |             v100 = np.full(out.shape[0], -1.0)
 147 |             v1010 = np.empty((60, out.shape[0]))
 148 |             for i0 in range(1, 61):
 149 |                 v101000 = np.empty((8, out.shape[0]))
 150 |                 for i1 in range(1, 9):
 151 |                     v101000[-i1] = close[-i1]
 152 |                 v10100 = v101000[-1] - v101000[-8]
 153 |                 v1010[-i0] = np.abs(v10100)
 154 |             v101 = pd.DataFrame(v1010).rank().tail(1).as_matrix()[-1]
 155 |             v10 = v100 * v101
 156 |             v1100 = np.empty((8, out.shape[0]))
 157 |             for i0 in range(1, 9):
 158 |                 v1100[-i0] = close[-i0]
 159 |             v110 = v1100[-1] - v1100[-8]
 160 |             v11 = np.sign(v110)
 161 |             v1 = v10 * v11
 162 |             v20 = np.full(out.shape[0], -1.0)
 163 |             v21 = np.full(out.shape[0], 1.0)
 164 |             v2 = v20 * v21
 165 |             vlgcl = np.empty(out.shape[0])
 166 |             vlgcl[v0] = v1[v0]
 167 |             vlgcl[~v0] = v2[~v0]
 168 |             out[:] = vlgcl
 169 | 
 170 |     #  (-1 * rank(((sum(open, 5) * sum(returns, 5)) - delay((sum(open, 5) * sum(returns, 5)), 10))))
 171 |     class Alpha8(CustomFactor):
 172 |         inputs = [Returns(window_length=2), USEquityPricing.open]
 173 |         window_length = 15
 174 | 
 175 |         def compute(self, today, assets, out, returns, open):
 176 |             v0 = np.full(out.shape[0], -1.0)
 177 |             v10000 = np.empty((5, out.shape[0]))
 178 |             for i0 in range(1, 6):
 179 |                 v10000[-i0] = open[-i0]
 180 |             v1000 = v10000.sum(axis=0)
 181 |             v10010 = np.empty((5, out.shape[0]))
 182 |             for i0 in range(1, 6):
 183 |                 v10010[-i0] = returns[-i0]
 184 |             v1001 = v10010.sum(axis=0)
 185 |             v100 = v1000 * v1001
 186 |             v101000 = np.empty((5, out.shape[0]))
 187 |             for i0 in range(11, 16):
 188 |                 v101000[10-i0] = open[-i0]
 189 |             v10100 = v101000.sum(axis=0)
 190 |             v101010 = np.empty((5, out.shape[0]))
 191 |             for i0 in range(11, 16):
 192 |                 v101010[10-i0] = returns[-i0]
 193 |             v10101 = v101010.sum(axis=0)
 194 |             v1010 = v10100 * v10101
 195 |             v101 = v1010 # delay
 196 |             v10 = v100 - v101
 197 |             v1 = stats.rankdata(v10)
 198 |             out[:] = v0 * v1
 199 | 
 200 |     #  ((0 < ts_min(delta(close, 1), 5)) ? delta(close, 1) : ((ts_max(delta(close, 1), 5) < 0) ? delta(close, 1) : (-1 * delta(close, 1))))
 201 |     class Alpha9(CustomFactor):
 202 |         inputs = [USEquityPricing.close]
 203 |         window_length = 5
 204 | 
 205 |         def compute(self, today, assets, out, close):
 206 |             v00 = np.full(out.shape[0], 0.0)
 207 |             v010 = np.empty((5, out.shape[0]))
 208 |             for i0 in range(1, 6):
 209 |                 v0100 = np.empty((2, out.shape[0]))
 210 |                 for i1 in range(1, 3):
 211 |                     v0100[-i1] = close[-i1]
 212 |                 v010[-i0] = v0100[-1] - v0100[-2]
 213 |             v01 = np.min(v010, axis=0)
 214 |             v0 = v00 < v01
 215 |             v10 = np.empty((2, out.shape[0]))
 216 |             for i0 in range(1, 3):
 217 |                 v10[-i0] = close[-i0]
 218 |             v1 = v10[-1] - v10[-2]
 219 |             v2000 = np.empty((5, out.shape[0]))
 220 |             for i0 in range(1, 6):
 221 |                 v20000 = np.empty((2, out.shape[0]))
 222 |                 for i1 in range(1, 3):
 223 |                     v20000[-i1] = close[-i1]
 224 |                 v2000[-i0] = v20000[-1] - v20000[-2]
 225 |             v200 = np.max(v2000, axis=0)
 226 |             v201 = np.full(out.shape[0], 0.0)
 227 |             v20 = v200 < v201
 228 |             v210 = np.empty((2, out.shape[0]))
 229 |             for i0 in range(1, 3):
 230 |                 v210[-i0] = close[-i0]
 231 |             v21 = v210[-1] - v210[-2]
 232 |             v220 = np.full(out.shape[0], -1.0)
 233 |             v2210 = np.empty((2, out.shape[0]))
 234 |             for i0 in range(1, 3):
 235 |                 v2210[-i0] = close[-i0]
 236 |             v221 = v2210[-1] - v2210[-2]
 237 |             v22 = v220 * v221
 238 |             v2lgcl = np.empty(out.shape[0])
 239 |             v2lgcl[v20] = v21[v20]
 240 |             v2lgcl[~v20] = v22[~v20]
 241 |             v2 = v2lgcl
 242 |             vlgcl = np.empty(out.shape[0])
 243 |             vlgcl[v0] = v1[v0]
 244 |             vlgcl[~v0] = v2[~v0]
 245 |             out[:] = vlgcl
 246 | 
 247 |     #  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)))))
 248 |     class Alpha10(CustomFactor):
 249 |         inputs = [USEquityPricing.close]
 250 |         window_length = 4
 251 | 
 252 |         def compute(self, today, assets, out, close):
 253 |             v000 = np.full(out.shape[0], 0.0)
 254 |             v0010 = np.empty((4, out.shape[0]))
 255 |             for i0 in range(1, 5):
 256 |                 v00100 = np.empty((2, out.shape[0]))
 257 |                 for i1 in range(1, 3):
 258 |                     v00100[-i1] = close[-i1]
 259 |                 v0010[-i0] = v00100[-1] - v00100[-2]
 260 |             v001 = np.min(v0010, axis=0)
 261 |             v00 = v000 < v001
 262 |             v010 = np.empty((2, out.shape[0]))
 263 |             for i0 in range(1, 3):
 264 |                 v010[-i0] = close[-i0]
 265 |             v01 = v010[-1] - v010[-2]
 266 |             v02000 = np.empty((4, out.shape[0]))
 267 |             for i0 in range(1, 5):
 268 |                 v020000 = np.empty((2, out.shape[0]))
 269 |                 for i1 in range(1, 3):
 270 |                     v020000[-i1] = close[-i1]
 271 |                 v02000[-i0] = v020000[-1] - v020000[-2]
 272 |             v0200 = np.max(v02000, axis=0)
 273 |             v0201 = np.full(out.shape[0], 0.0)
 274 |             v020 = v0200 < v0201
 275 |             v0210 = np.empty((2, out.shape[0]))
 276 |             for i0 in range(1, 3):
 277 |                 v0210[-i0] = close[-i0]
 278 |             v021 = v0210[-1] - v0210[-2]
 279 |             v0220 = np.full(out.shape[0], -1.0)
 280 |             v02210 = np.empty((2, out.shape[0]))
 281 |             for i0 in range(1, 3):
 282 |                 v02210[-i0] = close[-i0]
 283 |             v0221 = v02210[-1] - v02210[-2]
 284 |             v022 = v0220 * v0221
 285 |             v02lgcl = np.empty(out.shape[0])
 286 |             v02lgcl[v020] = v021[v020]
 287 |             v02lgcl[~v020] = v022[~v020]
 288 |             v02 = v02lgcl
 289 |             v0lgcl = np.empty(out.shape[0])
 290 |             v0lgcl[v00] = v01[v00]
 291 |             v0lgcl[~v00] = v02[~v00]
 292 |             v0 = v0lgcl
 293 |             out[:] = stats.rankdata(v0)
 294 | 
 295 |     #  ((rank(ts_max((vwap - close), 3)) + rank(ts_min((vwap - close), 3))) * rank(delta(volume, 3)))
 296 |     class Alpha11(CustomFactor):
 297 |         vwap_in = VWAP(window_length=2)
 298 |         vwap_in.window_safe = True
 299 |         inputs = [USEquityPricing.volume, USEquityPricing.close, vwap_in]
 300 |         window_length = 4
 301 | 
 302 |         def compute(self, today, assets, out, volume, close, vwap):
 303 |             v0000 = np.empty((3, out.shape[0]))
 304 |             for i0 in range(1, 4):
 305 |                 v00000 = vwap[-i0]
 306 |                 v00001 = close[-i0]
 307 |                 v0000[-i0] = v00000 - v00001
 308 |             v000 = np.max(v0000, axis=0)
 309 |             v00 = stats.rankdata(v000)
 310 |             v0100 = np.empty((3, out.shape[0]))
 311 |             for i0 in range(1, 4):
 312 |                 v01000 = vwap[-i0]
 313 |                 v01001 = close[-i0]
 314 |                 v0100[-i0] = v01000 - v01001
 315 |             v010 = np.min(v0100, axis=0)
 316 |             v01 = stats.rankdata(v010)
 317 |             v0 = v00 + v01
 318 |             v100 = np.empty((4, out.shape[0]))
 319 |             for i0 in range(1, 5):
 320 |                 v100[-i0] = volume[-i0]
 321 |             v10 = v100[-1] - v100[-4]
 322 |             v1 = stats.rankdata(v10)
 323 |             out[:] = v0 * v1
 324 | 
 325 |     #  (sign(delta(volume, 1)) * (-1 * delta(close, 1)))
 326 |     class Alpha12(CustomFactor):
 327 |         inputs = [USEquityPricing.volume, USEquityPricing.close]
 328 |         window_length = 2
 329 | 
 330 |         def compute(self, today, assets, out, volume, close):
 331 |             v000 = np.empty((2, out.shape[0]))
 332 |             for i0 in range(1, 3):
 333 |                 v000[-i0] = volume[-i0]
 334 |             v00 = v000[-1] - v000[-2]
 335 |             v0 = np.sign(v00)
 336 |             v10 = np.full(out.shape[0], -1.0)
 337 |             v110 = np.empty((2, out.shape[0]))
 338 |             for i0 in range(1, 3):
 339 |                 v110[-i0] = close[-i0]
 340 |             v11 = v110[-1] - v110[-2]
 341 |             v1 = v10 * v11
 342 |             out[:] = v0 * v1
 343 | 
 344 |     #  (-1 * rank(covariance(rank(close), rank(volume), 5)))
 345 |     class Alpha13(CustomFactor):
 346 |         inputs = [USEquityPricing.volume, USEquityPricing.close]
 347 |         window_length = 5
 348 | 
 349 |         def compute(self, today, assets, out, volume, close):
 350 |             v0 = np.full(out.shape[0], -1.0)
 351 |             v100 = np.empty((5, out.shape[0]))
 352 |             for i0 in range(1, 6):
 353 |                 v1000 = close[-i0]
 354 |                 v100[-i0] = stats.rankdata(v1000)
 355 |             v101 = np.empty((5, out.shape[0]))
 356 |             for i0 in range(1, 6):
 357 |                 v1010 = volume[-i0]
 358 |                 v101[-i0] = stats.rankdata(v1010)
 359 |             v10 = pd.DataFrame(v100).rolling(window=5).corr(pd.DataFrame(v101)).tail(1).as_matrix()[-1]
 360 |             v1 = stats.rankdata(v10)
 361 |             out[:] = v0 * v1
 362 | 
 363 |     #  ((-1 * rank(delta(returns, 3))) * correlation(open, volume, 10))
 364 |     class Alpha14(CustomFactor):
 365 |         inputs = [USEquityPricing.volume, Returns(window_length=2), USEquityPricing.open]
 366 |         window_length = 10
 367 | 
 368 |         def compute(self, today, assets, out, volume, returns, open):
 369 |             v00 = np.full(out.shape[0], -1.0)
 370 |             v0100 = np.empty((4, out.shape[0]))
 371 |             for i0 in range(1, 5):
 372 |                 v0100[-i0] = returns[-i0]
 373 |             v010 = v0100[-1] - v0100[-4]
 374 |             v01 = stats.rankdata(v010)
 375 |             v0 = v00 * v01
 376 |             v10 = np.empty((10, out.shape[0]))
 377 |             for i0 in range(1, 11):
 378 |                 v10[-i0] = open[-i0]
 379 |             v11 = np.empty((10, out.shape[0]))
 380 |             for i0 in range(1, 11):
 381 |                 v11[-i0] = volume[-i0]
 382 |             v1 = pd.DataFrame(v10).rolling(window=10).cov(pd.DataFrame(v11)).tail(1).as_matrix()[-1]
 383 |             out[:] = v0 * v1
 384 | 
 385 |     #  (-1 * sum(rank(correlation(rank(high), rank(volume), 3)), 3))
 386 |     class Alpha15(CustomFactor):
 387 |         inputs = [USEquityPricing.high, USEquityPricing.volume]
 388 |         window_length = 3
 389 | 
 390 |         def compute(self, today, assets, out, high, volume):
 391 |             v0 = np.full(out.shape[0], -1.0)
 392 |             v10 = np.empty((3, out.shape[0]))
 393 |             for i0 in range(1, 4):
 394 |                 v1000 = np.empty((3, out.shape[0]))
 395 |                 for i1 in range(1, 4):
 396 |                     v10000 = high[-i1]
 397 |                     v1000[-i1] = stats.rankdata(v10000)
 398 |                 v1001 = np.empty((3, out.shape[0]))
 399 |                 for i1 in range(1, 4):
 400 |                     v10010 = volume[-i1]
 401 |                     v1001[-i1] = stats.rankdata(v10010)
 402 |                 v100 = pd.DataFrame(v1000).rolling(window=3).cov(pd.DataFrame(v1001)).tail(1).as_matrix()[-1]
 403 |                 v10[-i0] = stats.rankdata(v100)
 404 |             v1 = v10.sum(axis=0)
 405 |             out[:] = v0 * v1
 406 | 
 407 |     #  (-1 * rank(covariance(rank(high), rank(volume), 5)))
 408 |     class Alpha16(CustomFactor):
 409 |         inputs = [USEquityPricing.high, USEquityPricing.volume]
 410 |         window_length = 5
 411 | 
 412 |         def compute(self, today, assets, out, high, volume):
 413 |             v0 = np.full(out.shape[0], -1.0)
 414 |             v100 = np.empty((5, out.shape[0]))
 415 |             for i0 in range(1, 6):
 416 |                 v1000 = high[-i0]
 417 |                 v100[-i0] = stats.rankdata(v1000)
 418 |             v101 = np.empty((5, out.shape[0]))
 419 |             for i0 in range(1, 6):
 420 |                 v1010 = volume[-i0]
 421 |                 v101[-i0] = stats.rankdata(v1010)
 422 |             v10 = pd.DataFrame(v100).rolling(window=5).corr(pd.DataFrame(v101)).tail(1).as_matrix()[-1]
 423 |             v1 = stats.rankdata(v10)
 424 |             out[:] = v0 * v1
 425 | 
 426 |     #  (((-1 * rank(ts_rank(close, 10))) * rank(delta(delta(close, 1), 1))) * rank(ts_rank((volume / adv20), 5)))
 427 |     class Alpha17(CustomFactor):
 428 |         adv20_in = AverageDollarVolume(window_length=20)
 429 |         adv20_in.window_safe = True
 430 |         inputs = [USEquityPricing.volume, USEquityPricing.close, adv20_in]
 431 |         window_length = 10
 432 | 
 433 |         def compute(self, today, assets, out, volume, close, adv20):
 434 |             v000 = np.full(out.shape[0], -1.0)
 435 |             v00100 = np.empty((10, out.shape[0]))
 436 |             for i0 in range(1, 11):
 437 |                 v00100[-i0] = close[-i0]
 438 |             v0010 = pd.DataFrame(v00100).rank().tail(1).as_matrix()[-1]
 439 |             v001 = stats.rankdata(v0010)
 440 |             v00 = v000 * v001
 441 |             v0100 = np.empty((2, out.shape[0]))
 442 |             for i0 in range(1, 3):
 443 |                 v01000 = np.empty((2, out.shape[0]))
 444 |                 for i1 in range(1, 3):
 445 |                     v01000[-i1] = close[-i1]
 446 |                 v0100[-i0] = v01000[-1] - v01000[-2]
 447 |             v010 = v0100[-1] - v0100[-2]
 448 |             v01 = stats.rankdata(v010)
 449 |             v0 = v00 * v01
 450 |             v100 = np.empty((5, out.shape[0]))
 451 |             for i0 in range(1, 6):
 452 |                 v1000 = volume[-i0]
 453 |                 v1001 = adv20[-i0]
 454 |                 v100[-i0] = v1000 / v1001
 455 |             v10 = pd.DataFrame(v100).rank().tail(1).as_matrix()[-1]
 456 |             v1 = stats.rankdata(v10)
 457 |             out[:] = v0 * v1
 458 | 
 459 |     #  (-1 * rank(((stddev(abs((close - open)), 5) + (close - open)) + correlation(close, open, 10))))
 460 |     class Alpha18(CustomFactor):
 461 |         inputs = [USEquityPricing.close, USEquityPricing.open]
 462 |         window_length = 10
 463 | 
 464 |         def compute(self, today, assets, out, close, open):
 465 |             v0 = np.full(out.shape[0], -1.0)
 466 |             v10000 = np.empty((5, out.shape[0]))
 467 |             for i0 in range(1, 6):
 468 |                 v1000000 = close[-i0]
 469 |                 v1000001 = open[-i0]
 470 |                 v100000 = v1000000 - v1000001
 471 |                 v10000[-i0] = np.abs(v100000)
 472 |             v1000 = np.std(v10000, axis=0)
 473 |             v10010 = close[-1]
 474 |             v10011 = open[-1]
 475 |             v1001 = v10010 - v10011
 476 |             v100 = v1000 + v1001
 477 |             v1010 = np.empty((10, out.shape[0]))
 478 |             for i0 in range(1, 11):
 479 |                 v1010[-i0] = close[-i0]
 480 |             v1011 = np.empty((10, out.shape[0]))
 481 |             for i0 in range(1, 11):
 482 |                 v1011[-i0] = open[-i0]
 483 |             v101 = pd.DataFrame(v1010).rolling(window=10).cov(pd.DataFrame(v1011)).tail(1).as_matrix()[-1]
 484 |             v10 = v100 + v101
 485 |             v1 = stats.rankdata(v10)
 486 |             out[:] = v0 * v1
 487 | 
 488 |     #  ((-1 * sign(((close - delay(close, 7)) + delta(close, 7)))) * (1 + rank((1 + sum(returns, 250)))))
 489 |     class Alpha19(CustomFactor):
 490 |         inputs = [USEquityPricing.close, Returns(window_length=2)]
 491 |         window_length = 250
 492 | 
 493 |         def compute(self, today, assets, out, close, returns):
 494 |             v00 = np.full(out.shape[0], -1.0)
 495 |             v01000 = close[-1]
 496 |             v010010 = close[-1]
 497 |             v01001 = v010010 # delay
 498 |             v0100 = v01000 - v01001
 499 |             v01010 = np.empty((8, out.shape[0]))
 500 |             for i0 in range(1, 9):
 501 |                 v01010[-i0] = close[-i0]
 502 |             v0101 = v01010[-1] - v01010[-8]
 503 |             v010 = v0100 + v0101
 504 |             v01 = np.sign(v010)
 505 |             v0 = v00 * v01
 506 |             v10 = np.full(out.shape[0], 1.0)
 507 |             v1100 = np.full(out.shape[0], 1.0)
 508 |             v11010 = np.empty((250, out.shape[0]))
 509 |             for i0 in range(1, 251):
 510 |                 v11010[-i0] = returns[-i0]
 511 |             v1101 = v11010.sum(axis=0)
 512 |             v110 = v1100 + v1101
 513 |             v11 = stats.rankdata(v110)
 514 |             v1 = v10 + v11
 515 |             out[:] = v0 * v1
 516 | 
 517 |     #  (((-1 * rank((open - delay(high, 1)))) * rank((open - delay(close, 1)))) * rank((open - delay(low, 1))))
 518 |     class Alpha20(CustomFactor):
 519 |         inputs = [USEquityPricing.high, USEquityPricing.close, USEquityPricing.open, USEquityPricing.low]
 520 |         window_length = 2
 521 | 
 522 |         def compute(self, today, assets, out, high, close, open, low):
 523 |             v000 = np.full(out.shape[0], -1.0)
 524 |             v00100 = open[-1]
 525 |             v001010 = high[-1]
 526 |             v00101 = v001010 # delay
 527 |             v0010 = v00100 - v00101
 528 |             v001 = stats.rankdata(v0010)
 529 |             v00 = v000 * v001
 530 |             v0100 = open[-1]
 531 |             v01010 = close[-1]
 532 |             v0101 = v01010 # delay
 533 |             v010 = v0100 - v0101
 534 |             v01 = stats.rankdata(v010)
 535 |             v0 = v00 * v01
 536 |             v100 = open[-1]
 537 |             v1010 = low[-1]
 538 |             v101 = v1010 # delay
 539 |             v10 = v100 - v101
 540 |             v1 = stats.rankdata(v10)
 541 |             out[:] = v0 * v1
 542 | 
 543 |     #  ((((sum(close, 8) / 8) + stddev(close, 8)) < (sum(close, 2) / 2)) ? (-1 * 1) : (((sum(close, 2) / 2) < ((sum(close, 8) / 8) - stddev(close, 8))) ? 1 : (((1 < (volume / adv20)) || ((volume / adv20) == 1)) ? 1 : (-1 * 1))))
 544 |     class Alpha21(CustomFactor):
 545 |         adv20_in = AverageDollarVolume(window_length=20)
 546 |         adv20_in.window_safe = True
 547 |         inputs = [USEquityPricing.volume, USEquityPricing.close, adv20_in]
 548 |         window_length = 8
 549 | 
 550 |         def compute(self, today, assets, out, volume, close, adv20):
 551 |             v00000 = np.empty((8, out.shape[0]))
 552 |             for i0 in range(1, 9):
 553 |                 v00000[-i0] = close[-i0]
 554 |             v0000 = v00000.sum(axis=0)
 555 |             v0001 = np.full(out.shape[0], 8.0)
 556 |             v000 = v0000 / v0001
 557 |             v0010 = np.empty((8, out.shape[0]))
 558 |             for i0 in range(1, 9):
 559 |                 v0010[-i0] = close[-i0]
 560 |             v001 = np.std(v0010, axis=0)
 561 |             v00 = v000 + v001
 562 |             v0100 = np.empty((2, out.shape[0]))
 563 |             for i0 in range(1, 3):
 564 |                 v0100[-i0] = close[-i0]
 565 |             v010 = v0100.sum(axis=0)
 566 |             v011 = np.full(out.shape[0], 2.0)
 567 |             v01 = v010 / v011
 568 |             v0 = v00 < v01
 569 |             v10 = np.full(out.shape[0], -1.0)
 570 |             v11 = np.full(out.shape[0], 1.0)
 571 |             v1 = v10 * v11
 572 |             v20000 = np.empty((2, out.shape[0]))
 573 |             for i0 in range(1, 3):
 574 |                 v20000[-i0] = close[-i0]
 575 |             v2000 = v20000.sum(axis=0)
 576 |             v2001 = np.full(out.shape[0], 2.0)
 577 |             v200 = v2000 / v2001
 578 |             v201000 = np.empty((8, out.shape[0]))
 579 |             for i0 in range(1, 9):
 580 |                 v201000[-i0] = close[-i0]
 581 |             v20100 = v201000.sum(axis=0)
 582 |             v20101 = np.full(out.shape[0], 8.0)
 583 |             v2010 = v20100 / v20101
 584 |             v20110 = np.empty((8, out.shape[0]))
 585 |             for i0 in range(1, 9):
 586 |                 v20110[-i0] = close[-i0]
 587 |             v2011 = np.std(v20110, axis=0)
 588 |             v201 = v2010 - v2011
 589 |             v20 = v200 < v201
 590 |             v21 = np.full(out.shape[0], 1.0)
 591 |             v22000 = np.full(out.shape[0], 1.0)
 592 |             v220010 = volume[-1]
 593 |             v220011 = adv20[-1]
 594 |             v22001 = v220010 / v220011
 595 |             v2200 = v22000 < v22001
 596 |             v220100 = volume[-1]
 597 |             v220101 = adv20[-1]
 598 |             v22010 = v220100 / v220101
 599 |             v22011 = np.full(out.shape[0], 1.0)
 600 |             v2201 = v22010 == v22011
 601 |             v220 = v2200 | v2201
 602 |             v221 = np.full(out.shape[0], 1.0)
 603 |             v2220 = np.full(out.shape[0], -1.0)
 604 |             v2221 = np.full(out.shape[0], 1.0)
 605 |             v222 = v2220 * v2221
 606 |             v22lgcl = np.empty(out.shape[0])
 607 |             v22lgcl[v220] = 1
 608 |             v22lgcl[~v220] = v222[~v220]
 609 |             v22 = v22lgcl
 610 |             v2lgcl = np.empty(out.shape[0])
 611 |             v2lgcl[v20] = 1
 612 |             v2lgcl[~v20] = v22[~v20]
 613 |             v2 = v2lgcl
 614 |             vlgcl = np.empty(out.shape[0])
 615 |             vlgcl[v0] = v1[v0]
 616 |             vlgcl[~v0] = v2[~v0]
 617 |             out[:] = vlgcl
 618 | 
 619 |     #  (-1 * (delta(correlation(high, volume, 5), 5) * rank(stddev(close, 20))))
 620 |     class Alpha22(CustomFactor):
 621 |         inputs = [USEquityPricing.high, USEquityPricing.volume, USEquityPricing.close]
 622 |         window_length = 20
 623 | 
 624 |         def compute(self, today, assets, out, high, volume, close):
 625 |             v0 = np.full(out.shape[0], -1.0)
 626 |             v100 = np.empty((6, out.shape[0]))
 627 |             for i0 in range(1, 7):
 628 |                 v1000 = np.empty((5, out.shape[0]))
 629 |                 for i1 in range(1, 6):
 630 |                     v1000[-i1] = high[-i1]
 631 |                 v1001 = np.empty((5, out.shape[0]))
 632 |                 for i1 in range(1, 6):
 633 |                     v1001[-i1] = volume[-i1]
 634 |                 v100[-i0] = pd.DataFrame(v1000).rolling(window=5).cov(pd.DataFrame(v1001)).tail(1).as_matrix()[-1]
 635 |             v10 = v100[-1] - v100[-6]
 636 |             v1100 = np.empty((20, out.shape[0]))
 637 |             for i0 in range(1, 21):
 638 |                 v1100[-i0] = close[-i0]
 639 |             v110 = np.std(v1100, axis=0)
 640 |             v11 = stats.rankdata(v110)
 641 |             v1 = v10 * v11
 642 |             out[:] = v0 * v1
 643 | 
 644 |     #  (((sum(high, 20) / 20) < high) ? (-1 * delta(high, 2)) : 0)
 645 |     class Alpha23(CustomFactor):
 646 |         inputs = [USEquityPricing.high]
 647 |         window_length = 20
 648 | 
 649 |         def compute(self, today, assets, out, high):
 650 |             v0000 = np.empty((20, out.shape[0]))
 651 |             for i0 in range(1, 21):
 652 |                 v0000[-i0] = high[-i0]
 653 |             v000 = v0000.sum(axis=0)
 654 |             v001 = np.full(out.shape[0], 20.0)
 655 |             v00 = v000 / v001
 656 |             v01 = high[-1]
 657 |             v0 = v00 < v01
 658 |             v10 = np.full(out.shape[0], -1.0)
 659 |             v110 = np.empty((3, out.shape[0]))
 660 |             for i0 in range(1, 4):
 661 |                 v110[-i0] = high[-i0]
 662 |             v11 = v110[-1] - v110[-3]
 663 |             v1 = v10 * v11
 664 |             v2 = np.full(out.shape[0], 0.0)
 665 |             vlgcl = np.empty(out.shape[0])
 666 |             vlgcl[v0] = v1[v0]
 667 |             vlgcl[~v0] = 0
 668 |             out[:] = vlgcl
 669 | 
 670 |     #  ((((delta((sum(close, 100) / 100), 100) / delay(close, 100)) < 0.05) || ((delta((sum(close, 100) / 100), 100) / delay(close, 100)) == 0.05)) ? (-1 * (close - ts_min(close, 100))) : (-1 * delta(close, 3)))
 671 |     class Alpha24(CustomFactor):
 672 |         inputs = [USEquityPricing.close]
 673 |         window_length = 101
 674 | 
 675 |         def compute(self, today, assets, out, close):
 676 |             v00000 = np.empty((101, out.shape[0]))
 677 |             for i0 in range(1, 102):
 678 |                 v0000000 = np.empty((100, out.shape[0]))
 679 |                 for i1 in range(1, 101):
 680 |                     v0000000[-i1] = close[-i1]
 681 |                 v000000 = v0000000.sum(axis=0)
 682 |                 v000001 = np.full(out.shape[0], 100.0)
 683 |                 v00000[-i0] = v000000 / v000001
 684 |             v0000 = v00000[-1] - v00000[-101]
 685 |             v00010 = close[-1]
 686 |             v0001 = v00010 # delay
 687 |             v000 = v0000 / v0001
 688 |             v001 = np.full(out.shape[0], 0.05)
 689 |             v00 = v000 < v001
 690 |             v01000 = np.empty((101, out.shape[0]))
 691 |             for i0 in range(1, 102):
 692 |                 v0100000 = np.empty((100, out.shape[0]))
 693 |                 for i1 in range(1, 101):
 694 |                     v0100000[-i1] = close[-i1]
 695 |                 v010000 = v0100000.sum(axis=0)
 696 |                 v010001 = np.full(out.shape[0], 100.0)
 697 |                 v01000[-i0] = v010000 / v010001
 698 |             v0100 = v01000[-1] - v01000[-101]
 699 |             v01010 = close[-1]
 700 |             v0101 = v01010 # delay
 701 |             v010 = v0100 / v0101
 702 |             v011 = np.full(out.shape[0], 0.05)
 703 |             v01 = v010 == v011
 704 |             v0 = v00 | v01
 705 |             v10 = np.full(out.shape[0], -1.0)
 706 |             v110 = close[-1]
 707 |             v1110 = np.empty((100, out.shape[0]))
 708 |             for i0 in range(1, 101):
 709 |                 v1110[-i0] = close[-i0]
 710 |             v111 = np.min(v1110, axis=0)
 711 |             v11 = v110 - v111
 712 |             v1 = v10 * v11
 713 |             v20 = np.full(out.shape[0], -1.0)
 714 |             v210 = np.empty((4, out.shape[0]))
 715 |             for i0 in range(1, 5):
 716 |                 v210[-i0] = close[-i0]
 717 |             v21 = v210[-1] - v210[-4]
 718 |             v2 = v20 * v21
 719 |             vlgcl = np.empty(out.shape[0])
 720 |             vlgcl[v0] = v1[v0]
 721 |             vlgcl[~v0] = v2[~v0]
 722 |             out[:] = vlgcl
 723 | 
 724 |     #  rank(((((-1 * returns) * adv20) * vwap) * (high - close)))
 725 |     class Alpha25(CustomFactor):
 726 |         vwap_in = VWAP(window_length=2)
 727 |         vwap_in.window_safe = True
 728 |         adv20_in = AverageDollarVolume(window_length=20)
 729 |         adv20_in.window_safe = True
 730 |         inputs = [USEquityPricing.high, USEquityPricing.close, Returns(window_length=2), adv20_in, vwap_in]
 731 |         window_length = 2
 732 | 
 733 |         def compute(self, today, assets, out, high, close, returns, adv20, vwap):
 734 |             v00000 = np.full(out.shape[0], -1.0)
 735 |             v00001 = returns[-1]
 736 |             v0000 = v00000 * v00001
 737 |             v0001 = adv20[-1]
 738 |             v000 = v0000 * v0001
 739 |             v001 = vwap[-1]
 740 |             v00 = v000 * v001
 741 |             v010 = high[-1]
 742 |             v011 = close[-1]
 743 |             v01 = v010 - v011
 744 |             v0 = v00 * v01
 745 |             out[:] = stats.rankdata(v0)
 746 | 
 747 |     #  (-1 * ts_max(correlation(ts_rank(volume, 5), ts_rank(high, 5), 5), 3))
 748 |     class Alpha26(CustomFactor):
 749 |         inputs = [USEquityPricing.volume, USEquityPricing.high]
 750 |         window_length = 5
 751 | 
 752 |         def compute(self, today, assets, out, volume, high):
 753 |             v0 = np.full(out.shape[0], -1.0)
 754 |             v10 = np.empty((3, out.shape[0]))
 755 |             for i0 in range(1, 4):
 756 |                 v100 = np.empty((5, out.shape[0]))
 757 |                 for i1 in range(1, 6):
 758 |                     v1000 = np.empty((5, out.shape[0]))
 759 |                     for i2 in range(1, 6):
 760 |                         v1000[-i2] = volume[-i2]
 761 |                     v100[-i1] = pd.DataFrame(v1000).rank().tail(1).as_matrix()[-1]
 762 |                 v101 = np.empty((5, out.shape[0]))
 763 |                 for i1 in range(1, 6):
 764 |                     v1010 = np.empty((5, out.shape[0]))
 765 |                     for i2 in range(1, 6):
 766 |                         v1010[-i2] = high[-i2]
 767 |                     v101[-i1] = pd.DataFrame(v1010).rank().tail(1).as_matrix()[-1]
 768 |                 v10[-i0] = pd.DataFrame(v100).rolling(window=5).cov(pd.DataFrame(v101)).tail(1).as_matrix()[-1]
 769 |             v1 = np.max(v10, axis=0)
 770 |             out[:] = v0 * v1
 771 | 
 772 |     #  ((0.5 < rank((sum(correlation(rank(volume), rank(vwap), 6), 2) / 2.0))) ? (-1 * 1) : 1)
 773 |     class Alpha27(CustomFactor):
 774 |         vwap_in = VWAP(window_length=2)
 775 |         vwap_in.window_safe = True
 776 |         inputs = [USEquityPricing.volume, vwap_in]
 777 |         window_length = 6
 778 | 
 779 |         def compute(self, today, assets, out, volume, vwap):
 780 |             v00 = np.full(out.shape[0], 0.5)
 781 |             v01000 = np.empty((2, out.shape[0]))
 782 |             for i0 in range(1, 3):
 783 |                 v010000 = np.empty((6, out.shape[0]))
 784 |                 for i1 in range(1, 7):
 785 |                     v0100000 = volume[-i1]
 786 |                     v010000[-i1] = stats.rankdata(v0100000)
 787 |                 v010001 = np.empty((6, out.shape[0]))
 788 |                 for i1 in range(1, 7):
 789 |                     v0100010 = vwap[-i1]
 790 |                     v010001[-i1] = stats.rankdata(v0100010)
 791 |                 v01000[-i0] = pd.DataFrame(v010000).rolling(window=6).cov(pd.DataFrame(v010001)).tail(1).as_matrix()[-1]
 792 |             v0100 = v01000.sum(axis=0)
 793 |             v0101 = np.full(out.shape[0], 2.0)
 794 |             v010 = v0100 / v0101
 795 |             v01 = stats.rankdata(v010)
 796 |             v0 = v00 < v01
 797 |             v10 = np.full(out.shape[0], -1.0)
 798 |             v11 = np.full(out.shape[0], 1.0)
 799 |             v1 = v10 * v11
 800 |             v2 = np.full(out.shape[0], 1.0)
 801 |             vlgcl = np.empty(out.shape[0])
 802 |             vlgcl[v0] = v1[v0]
 803 |             vlgcl[~v0] = 1
 804 |             out[:] = vlgcl
 805 | 
 806 |     #  scale(((correlation(adv20, low, 5) + ((high + low) / 2)) - close))
 807 |     class Alpha28(CustomFactor):
 808 |         adv20_in = AverageDollarVolume(window_length=20)
 809 |         adv20_in.window_safe = True
 810 |         inputs = [USEquityPricing.high, USEquityPricing.close, adv20_in, USEquityPricing.low]
 811 |         window_length = 5
 812 | 
 813 |         def compute(self, today, assets, out, high, close, adv20, low):
 814 |             v0000 = np.empty((5, out.shape[0]))
 815 |             for i0 in range(1, 6):
 816 |                 v0000[-i0] = adv20[-i0]
 817 |             v0001 = np.empty((5, out.shape[0]))
 818 |             for i0 in range(1, 6):
 819 |                 v0001[-i0] = low[-i0]
 820 |             v000 = pd.DataFrame(v0000).rolling(window=5).cov(pd.DataFrame(v0001)).tail(1).as_matrix()[-1]
 821 |             v00100 = high[-1]
 822 |             v00101 = low[-1]
 823 |             v0010 = v00100 + v00101
 824 |             v0011 = np.full(out.shape[0], 2.0)
 825 |             v001 = v0010 / v0011
 826 |             v00 = v000 + v001
 827 |             v01 = close[-1]
 828 |             v0 = v00 - v01
 829 |             out[:] = v0/np.abs(v0).sum()
 830 | 
 831 |     #  (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))
 832 |     class Alpha29(CustomFactor):
 833 |         inputs = [USEquityPricing.close, Returns(window_length=2)]
 834 |         window_length = 7
 835 | 
 836 |         def compute(self, today, assets, out, close, returns):
 837 |             v00 = np.empty((5, out.shape[0]))
 838 |             for i0 in range(1, 6):
 839 |                 v000 = np.empty((1, out.shape[0]))
 840 |                 for i1 in range(1, 2):
 841 |                     v00000000 = np.empty((1, out.shape[0]))
 842 |                     for i2 in range(1, 2):
 843 |                         v000000000 = np.empty((2, out.shape[0]))
 844 |                         for i3 in range(1, 3):
 845 |                             v000000000000 = np.full(out.shape[0], -1.0)
 846 |                             v00000000000100 = np.empty((6, out.shape[0]))
 847 |                             for i4 in range(1, 7):
 848 |                                 v000000000001000 = close[-i4]
 849 |                                 v000000000001001 = np.full(out.shape[0], 1.0)
 850 |                                 v00000000000100[-i4] = v000000000001000 - v000000000001001
 851 |                             v0000000000010 = v00000000000100[-1] - v00000000000100[-6]
 852 |                             v000000000001 = stats.rankdata(v0000000000010)
 853 |                             v00000000000 = v000000000000 * v000000000001
 854 |                             v0000000000 = stats.rankdata(v00000000000)
 855 |                             v000000000[-i3] = stats.rankdata(v0000000000)
 856 |                         v00000000[-i2] = np.min(v000000000, axis=0)
 857 |                     v0000000 = v00000000.sum(axis=0)
 858 |                     v000000 = np.log(v0000000)
 859 |                     v00000 = v000000/np.abs(v000000).sum()
 860 |                     v0000 = stats.rankdata(v00000)
 861 |                     v000[-i1] = stats.rankdata(v0000)
 862 |                 v00[-i0] = np.prod(v000, axis=0)
 863 |             v0 = np.min(v00, axis=0)
 864 |             v10 = np.empty((5, out.shape[0]))
 865 |             for i0 in range(1, 6):
 866 |                 v1000 = np.full(out.shape[0], -1.0)
 867 |                 v1001 = returns[-1]
 868 |                 v100 = v1000 * v1001
 869 |                 v10[-i0] = v100 # delay
 870 |             v1 = pd.DataFrame(v10).rank().tail(1).as_matrix()[-1]
 871 |             out[:] = v0 + v1
 872 | 
 873 |     #  (((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))
 874 |     class Alpha30(CustomFactor):
 875 |         inputs = [USEquityPricing.volume, USEquityPricing.close]
 876 |         window_length = 20
 877 | 
 878 |         def compute(self, today, assets, out, volume, close):
 879 |             v000 = np.full(out.shape[0], 1.0)
 880 |             v00100000 = close[-1]
 881 |             v001000010 = close[-1]
 882 |             v00100001 = v001000010 # delay
 883 |             v0010000 = v00100000 - v00100001
 884 |             v001000 = np.sign(v0010000)
 885 |             v001001000 = close[-1]
 886 |             v00100100 = v001001000 # delay
 887 |             v001001010 = close[-1]
 888 |             v00100101 = v001001010 # delay
 889 |             v0010010 = v00100100 - v00100101
 890 |             v001001 = np.sign(v0010010)
 891 |             v00100 = v001000 + v001001
 892 |             v00101000 = close[-1]
 893 |             v0010100 = v00101000 # delay
 894 |             v00101010 = close[-1]
 895 |             v0010101 = v00101010 # delay
 896 |             v001010 = v0010100 - v0010101
 897 |             v00101 = np.sign(v001010)
 898 |             v0010 = v00100 + v00101
 899 |             v001 = stats.rankdata(v0010)
 900 |             v00 = v000 - v001
 901 |             v010 = np.empty((5, out.shape[0]))
 902 |             for i0 in range(1, 6):
 903 |                 v010[-i0] = volume[-i0]
 904 |             v01 = v010.sum(axis=0)
 905 |             v0 = v00 * v01
 906 |             v10 = np.empty((20, out.shape[0]))
 907 |             for i0 in range(1, 21):
 908 |                 v10[-i0] = volume[-i0]
 909 |             v1 = v10.sum(axis=0)
 910 |             out[:] = v0 / v1
 911 | 
 912 |     #  ((rank(rank(rank(decay_linear((-1 * rank(rank(delta(close, 10)))), 10)))) + rank((-1 * delta(close, 3)))) + sign(scale(correlation(adv20, low, 12))))
 913 |     class Alpha31(CustomFactor):
 914 |         adv20_in = AverageDollarVolume(window_length=20)
 915 |         adv20_in.window_safe = True
 916 |         inputs = [USEquityPricing.close, adv20_in, USEquityPricing.low]
 917 |         window_length = 12
 918 | 
 919 |         def compute(self, today, assets, out, close, adv20, low):
 920 |             v000000 = np.empty((10, out.shape[0]))
 921 |             for i0 in range(1, 11):
 922 |                 v0000000 = np.full(out.shape[0], -1.0)
 923 |                 v0000001000 = np.empty((11, out.shape[0]))
 924 |                 for i1 in range(1, 12):
 925 |                     v0000001000[-i1] = close[-i1]
 926 |                 v000000100 = v0000001000[-1] - v0000001000[-11]
 927 |                 v00000010 = stats.rankdata(v000000100)
 928 |                 v0000001 = stats.rankdata(v00000010)
 929 |                 v000000[-i0] = v0000000 * v0000001
 930 |             v00000 = (v000000 * (np.arange(1.0, 11, 1.0)/55)[:, np.newaxis]).sum(axis=0) # decay_linear
 931 |             v0000 = stats.rankdata(v00000)
 932 |             v000 = stats.rankdata(v0000)
 933 |             v00 = stats.rankdata(v000)
 934 |             v0100 = np.full(out.shape[0], -1.0)
 935 |             v01010 = np.empty((4, out.shape[0]))
 936 |             for i0 in range(1, 5):
 937 |                 v01010[-i0] = close[-i0]
 938 |             v0101 = v01010[-1] - v01010[-4]
 939 |             v010 = v0100 * v0101
 940 |             v01 = stats.rankdata(v010)
 941 |             v0 = v00 + v01
 942 |             v1000 = np.empty((12, out.shape[0]))
 943 |             for i0 in range(1, 13):
 944 |                 v1000[-i0] = adv20[-i0]
 945 |             v1001 = np.empty((12, out.shape[0]))
 946 |             for i0 in range(1, 13):
 947 |                 v1001[-i0] = low[-i0]
 948 |             v100 = pd.DataFrame(v1000).rolling(window=12).cov(pd.DataFrame(v1001)).tail(1).as_matrix()[-1]
 949 |             v10 = v100/np.abs(v100).sum()
 950 |             v1 = np.sign(v10)
 951 |             out[:] = v0 + v1
 952 | 
 953 |     #  (scale(((sum(close, 7) / 7) - close)) + (20 * scale(correlation(vwap, delay(close, 5), 230))))
 954 |     class Alpha32(CustomFactor):
 955 |         vwap_in = VWAP(window_length=2)
 956 |         vwap_in.window_safe = True
 957 |         inputs = [USEquityPricing.close, vwap_in]
 958 |         window_length = 230
 959 | 
 960 |         def compute(self, today, assets, out, close, vwap):
 961 |             v00000 = np.empty((7, out.shape[0]))
 962 |             for i0 in range(1, 8):
 963 |                 v00000[-i0] = close[-i0]
 964 |             v0000 = v00000.sum(axis=0)
 965 |             v0001 = np.full(out.shape[0], 7.0)
 966 |             v000 = v0000 / v0001
 967 |             v001 = close[-1]
 968 |             v00 = v000 - v001
 969 |             v0 = v00/np.abs(v00).sum()
 970 |             v10 = np.full(out.shape[0], 20.0)
 971 |             v1100 = np.empty((230, out.shape[0]))
 972 |             for i0 in range(1, 231):
 973 |                 v1100[-i0] = vwap[-i0]
 974 |             v1101 = np.empty((230, out.shape[0]))
 975 |             for i0 in range(1, 231):
 976 |                 v11010 = close[-1]
 977 |                 v1101[-i0] = v11010 # delay
 978 |             v110 = pd.DataFrame(v1100).rolling(window=230).cov(pd.DataFrame(v1101)).tail(1).as_matrix()[-1]
 979 |             v11 = v110/np.abs(v110).sum()
 980 |             v1 = v10 * v11
 981 |             out[:] = v0 + v1
 982 | 
 983 |     #  rank((-1 * ((1 - (open / close))^1)))
 984 |     class Alpha33(CustomFactor):
 985 |         inputs = [USEquityPricing.close, USEquityPricing.open]
 986 |         window_length = 2
 987 | 
 988 |         def compute(self, today, assets, out, close, open):
 989 |             v00 = np.full(out.shape[0], -1.0)
 990 |             v0100 = np.full(out.shape[0], 1.0)
 991 |             v01010 = open[-1]
 992 |             v01011 = close[-1]
 993 |             v0101 = v01010 / v01011
 994 |             v010 = v0100 - v0101
 995 |             v011 = np.full(out.shape[0], 1.0)
 996 |             v01 = np.power(v010, v011)
 997 |             v0 = v00 * v01
 998 |             out[:] = stats.rankdata(v0)
 999 | 
1000 |     #  rank(((1 - rank((stddev(returns, 2) / stddev(returns, 5)))) + (1 - rank(delta(close, 1)))))
1001 |     class Alpha34(CustomFactor):
1002 |         inputs = [USEquityPricing.close, Returns(window_length=2)]
1003 |         window_length = 5
1004 | 
1005 |         def compute(self, today, assets, out, close, returns):
1006 |             v000 = np.full(out.shape[0], 1.0)
1007 |             v001000 = np.empty((2, out.shape[0]))
1008 |             for i0 in range(1, 3):
1009 |                 v001000[-i0] = returns[-i0]
1010 |             v00100 = np.std(v001000, axis=0)
1011 |             v001010 = np.empty((5, out.shape[0]))
1012 |             for i0 in range(1, 6):
1013 |                 v001010[-i0] = returns[-i0]
1014 |             v00101 = np.std(v001010, axis=0)
1015 |             v0010 = v00100 / v00101
1016 |             v001 = stats.rankdata(v0010)
1017 |             v00 = v000 - v001
1018 |             v010 = np.full(out.shape[0], 1.0)
1019 |             v01100 = np.empty((2, out.shape[0]))
1020 |             for i0 in range(1, 3):
1021 |                 v01100[-i0] = close[-i0]
1022 |             v0110 = v01100[-1] - v01100[-2]
1023 |             v011 = stats.rankdata(v0110)
1024 |             v01 = v010 - v011
1025 |             v0 = v00 + v01
1026 |             out[:] = stats.rankdata(v0)
1027 | 
1028 |     #  ((Ts_Rank(volume, 32) * (1 - Ts_Rank(((close + high) - low), 16))) * (1 - Ts_Rank(returns, 32)))
1029 |     class Alpha35(CustomFactor):
1030 |         inputs = [USEquityPricing.volume, USEquityPricing.close, USEquityPricing.high, Returns(window_length=2), USEquityPricing.low]
1031 |         window_length = 32
1032 | 
1033 |         def compute(self, today, assets, out, volume, close, high, returns, low):
1034 |             v000 = np.empty((32, out.shape[0]))
1035 |             for i0 in range(1, 33):
1036 |                 v000[-i0] = volume[-i0]
1037 |             v00 = pd.DataFrame(v000).rank().tail(1).as_matrix()[-1]
1038 |             v010 = np.full(out.shape[0], 1.0)
1039 |             v0110 = np.empty((16, out.shape[0]))
1040 |             for i0 in range(1, 17):
1041 |                 v011000 = close[-i0]
1042 |                 v011001 = high[-i0]
1043 |                 v01100 = v011000 + v011001
1044 |                 v01101 = low[-i0]
1045 |                 v0110[-i0] = v01100 - v01101
1046 |             v011 = pd.DataFrame(v0110).rank().tail(1).as_matrix()[-1]
1047 |             v01 = v010 - v011
1048 |             v0 = v00 * v01
1049 |             v10 = np.full(out.shape[0], 1.0)
1050 |             v110 = np.empty((32, out.shape[0]))
1051 |             for i0 in range(1, 33):
1052 |                 v110[-i0] = returns[-i0]
1053 |             v11 = pd.DataFrame(v110).rank().tail(1).as_matrix()[-1]
1054 |             v1 = v10 - v11
1055 |             out[:] = v0 * v1
1056 | 
1057 |     #  (((((2.21 * rank(correlation((close - open), delay(volume, 1), 15))) + (0.7 * rank((open - close)))) + (0.73 * rank(Ts_Rank(delay((-1 * returns), 6), 5)))) + rank(abs(correlation(vwap, adv20, 6)))) + (0.6 * rank((((sum(close, 200) / 200) - open) * (close - open)))))
1058 |     class Alpha36(CustomFactor):
1059 |         vwap_in = VWAP(window_length=2)
1060 |         vwap_in.window_safe = True
1061 |         adv20_in = AverageDollarVolume(window_length=20)
1062 |         adv20_in.window_safe = True
1063 |         inputs = [adv20_in, vwap_in, USEquityPricing.volume, Returns(window_length=2), USEquityPricing.close, USEquityPricing.open]
1064 |         window_length = 200
1065 | 
1066 |         def compute(self, today, assets, out, adv20, vwap, volume, returns, close, open):
1067 |             v00000 = np.full(out.shape[0], 2.21)
1068 |             v0000100 = np.empty((15, out.shape[0]))
1069 |             for i0 in range(1, 16):
1070 |                 v00001000 = close[-i0]
1071 |                 v00001001 = open[-i0]
1072 |                 v0000100[-i0] = v00001000 - v00001001
1073 |             v0000101 = np.empty((15, out.shape[0]))
1074 |             for i0 in range(1, 16):
1075 |                 v00001010 = volume[-1]
1076 |                 v0000101[-i0] = v00001010 # delay
1077 |             v000010 = pd.DataFrame(v0000100).rolling(window=15).cov(pd.DataFrame(v0000101)).tail(1).as_matrix()[-1]
1078 |             v00001 = stats.rankdata(v000010)
1079 |             v0000 = v00000 * v00001
1080 |             v00010 = np.full(out.shape[0], 0.7)
1081 |             v0001100 = open[-1]
1082 |             v0001101 = close[-1]
1083 |             v000110 = v0001100 - v0001101
1084 |             v00011 = stats.rankdata(v000110)
1085 |             v0001 = v00010 * v00011
1086 |             v000 = v0000 + v0001
1087 |             v0010 = np.full(out.shape[0], 0.73)
1088 |             v001100 = np.empty((5, out.shape[0]))
1089 |             for i0 in range(1, 6):
1090 |                 v00110000 = np.full(out.shape[0], -1.0)
1091 |                 v00110001 = returns[-1]
1092 |                 v0011000 = v00110000 * v00110001
1093 |                 v001100[-i0] = v0011000 # delay
1094 |             v00110 = pd.DataFrame(v001100).rank().tail(1).as_matrix()[-1]
1095 |             v0011 = stats.rankdata(v00110)
1096 |             v001 = v0010 * v0011
1097 |             v00 = v000 + v001
1098 |             v01000 = np.empty((6, out.shape[0]))
1099 |             for i0 in range(1, 7):
1100 |                 v01000[-i0] = vwap[-i0]
1101 |             v01001 = np.empty((6, out.shape[0]))
1102 |             for i0 in range(1, 7):
1103 |                 v01001[-i0] = adv20[-i0]
1104 |             v0100 = pd.DataFrame(v01000).rolling(window=6).cov(pd.DataFrame(v01001)).tail(1).as_matrix()[-1]
1105 |             v010 = np.abs(v0100)
1106 |             v01 = stats.rankdata(v010)
1107 |             v0 = v00 + v01
1108 |             v10 = np.full(out.shape[0], 0.6)
1109 |             v1100000 = np.empty((200, out.shape[0]))
1110 |             for i0 in range(1, 201):
1111 |                 v1100000[-i0] = close[-i0]
1112 |             v110000 = v1100000.sum(axis=0)
1113 |             v110001 = np.full(out.shape[0], 200.0)
1114 |             v11000 = v110000 / v110001
1115 |             v11001 = open[-1]
1116 |             v1100 = v11000 - v11001
1117 |             v11010 = close[-1]
1118 |             v11011 = open[-1]
1119 |             v1101 = v11010 - v11011
1120 |             v110 = v1100 * v1101
1121 |             v11 = stats.rankdata(v110)
1122 |             v1 = v10 * v11
1123 |             out[:] = v0 + v1
1124 | 
1125 |     #  (rank(correlation(delay((open - close), 1), close, 200)) + rank((open - close)))
1126 |     class Alpha37(CustomFactor):
1127 |         inputs = [USEquityPricing.close, USEquityPricing.open]
1128 |         window_length = 200
1129 | 
1130 |         def compute(self, today, assets, out, close, open):
1131 |             v000 = np.empty((200, out.shape[0]))
1132 |             for i0 in range(1, 201):
1133 |                 v00000 = open[-1]
1134 |                 v00001 = close[-1]
1135 |                 v0000 = v00000 - v00001
1136 |                 v000[-i0] = v0000 # delay
1137 |             v001 = np.empty((200, out.shape[0]))
1138 |             for i0 in range(1, 201):
1139 |                 v001[-i0] = close[-i0]
1140 |             v00 = pd.DataFrame(v000).rolling(window=200).cov(pd.DataFrame(v001)).tail(1).as_matrix()[-1]
1141 |             v0 = stats.rankdata(v00)
1142 |             v100 = open[-1]
1143 |             v101 = close[-1]
1144 |             v10 = v100 - v101
1145 |             v1 = stats.rankdata(v10)
1146 |             out[:] = v0 + v1
1147 | 
1148 |     #  ((-1 * rank(Ts_Rank(close, 10))) * rank((close / open)))
1149 |     class Alpha38(CustomFactor):
1150 |         inputs = [USEquityPricing.close, USEquityPricing.open]
1151 |         window_length = 10
1152 | 
1153 |         def compute(self, today, assets, out, close, open):
1154 |             v00 = np.full(out.shape[0], -1.0)
1155 |             v0100 = np.empty((10, out.shape[0]))
1156 |             for i0 in range(1, 11):
1157 |                 v0100[-i0] = close[-i0]
1158 |             v010 = pd.DataFrame(v0100).rank().tail(1).as_matrix()[-1]
1159 |             v01 = stats.rankdata(v010)
1160 |             v0 = v00 * v01
1161 |             v100 = close[-1]
1162 |             v101 = open[-1]
1163 |             v10 = v100 / v101
1164 |             v1 = stats.rankdata(v10)
1165 |             out[:] = v0 * v1
1166 | 
1167 |     #  ((-1 * rank((delta(close, 7) * (1 - rank(decay_linear((volume / adv20), 9)))))) * (1 + rank(sum(returns, 250))))
1168 |     class Alpha39(CustomFactor):
1169 |         adv20_in = AverageDollarVolume(window_length=20)
1170 |         adv20_in.window_safe = True
1171 |         inputs = [USEquityPricing.volume, USEquityPricing.close, Returns(window_length=2), adv20_in]
1172 |         window_length = 250
1173 | 
1174 |         def compute(self, today, assets, out, volume, close, returns, adv20):
1175 |             v00 = np.full(out.shape[0], -1.0)
1176 |             v01000 = np.empty((8, out.shape[0]))
1177 |             for i0 in range(1, 9):
1178 |                 v01000[-i0] = close[-i0]
1179 |             v0100 = v01000[-1] - v01000[-8]
1180 |             v01010 = np.full(out.shape[0], 1.0)
1181 |             v0101100 = np.empty((9, out.shape[0]))
1182 |             for i0 in range(1, 10):
1183 |                 v01011000 = volume[-i0]
1184 |                 v01011001 = adv20[-i0]
1185 |                 v0101100[-i0] = v01011000 / v01011001
1186 |             v010110 = (v0101100 * (np.arange(1.0, 10, 1.0)/45)[:, np.newaxis]).sum(axis=0) # decay_linear
1187 |             v01011 = stats.rankdata(v010110)
1188 |             v0101 = v01010 - v01011
1189 |             v010 = v0100 * v0101
1190 |             v01 = stats.rankdata(v010)
1191 |             v0 = v00 * v01
1192 |             v10 = np.full(out.shape[0], 1.0)
1193 |             v1100 = np.empty((250, out.shape[0]))
1194 |             for i0 in range(1, 251):
1195 |                 v1100[-i0] = returns[-i0]
1196 |             v110 = v1100.sum(axis=0)
1197 |             v11 = stats.rankdata(v110)
1198 |             v1 = v10 + v11
1199 |             out[:] = v0 * v1
1200 | 
1201 |     #  ((-1 * rank(stddev(high, 10))) * correlation(high, volume, 10))
1202 |     class Alpha40(CustomFactor):
1203 |         inputs = [USEquityPricing.high, USEquityPricing.volume]
1204 |         window_length = 10
1205 | 
1206 |         def compute(self, today, assets, out, high, volume):
1207 |             v00 = np.full(out.shape[0], -1.0)
1208 |             v0100 = np.empty((10, out.shape[0]))
1209 |             for i0 in range(1, 11):
1210 |                 v0100[-i0] = high[-i0]
1211 |             v010 = np.std(v0100, axis=0)
1212 |             v01 = stats.rankdata(v010)
1213 |             v0 = v00 * v01
1214 |             v10 = np.empty((10, out.shape[0]))
1215 |             for i0 in range(1, 11):
1216 |                 v10[-i0] = high[-i0]
1217 |             v11 = np.empty((10, out.shape[0]))
1218 |             for i0 in range(1, 11):
1219 |                 v11[-i0] = volume[-i0]
1220 |             v1 = pd.DataFrame(v10).rolling(window=10).cov(pd.DataFrame(v11)).tail(1).as_matrix()[-1]
1221 |             out[:] = v0 * v1
1222 | 
1223 |     #  (((high * low)^0.5) - vwap)
1224 |     class Alpha41(CustomFactor):
1225 |         vwap_in = VWAP(window_length=2)
1226 |         vwap_in.window_safe = True
1227 |         inputs = [USEquityPricing.high, USEquityPricing.low, vwap_in]
1228 |         window_length = 2
1229 | 
1230 |         def compute(self, today, assets, out, high, low, vwap):
1231 |             v000 = high[-1]
1232 |             v001 = low[-1]
1233 |             v00 = v000 * v001
1234 |             v01 = np.full(out.shape[0], 0.5)
1235 |             v0 = np.power(v00, v01)
1236 |             v1 = vwap[-1]
1237 |             out[:] = v0 - v1
1238 | 
1239 |     #  (rank((vwap - close)) / rank((vwap + close)))
1240 |     class Alpha42(CustomFactor):
1241 |         vwap_in = VWAP(window_length=2)
1242 |         vwap_in.window_safe = True
1243 |         inputs = [USEquityPricing.close, vwap_in]
1244 |         window_length = 2
1245 | 
1246 |         def compute(self, today, assets, out, close, vwap):
1247 |             v000 = vwap[-1]
1248 |             v001 = close[-1]
1249 |             v00 = v000 - v001
1250 |             v0 = stats.rankdata(v00)
1251 |             v100 = vwap[-1]
1252 |             v101 = close[-1]
1253 |             v10 = v100 + v101
1254 |             v1 = stats.rankdata(v10)
1255 |             out[:] = v0 / v1
1256 | 
1257 |     #  (ts_rank((volume / adv20), 20) * ts_rank((-1 * delta(close, 7)), 8))
1258 |     class Alpha43(CustomFactor):
1259 |         adv20_in = AverageDollarVolume(window_length=20)
1260 |         adv20_in.window_safe = True
1261 |         inputs = [USEquityPricing.volume, USEquityPricing.close, adv20_in]
1262 |         window_length = 20
1263 | 
1264 |         def compute(self, today, assets, out, volume, close, adv20):
1265 |             v00 = np.empty((20, out.shape[0]))
1266 |             for i0 in range(1, 21):
1267 |                 v000 = volume[-i0]
1268 |                 v001 = adv20[-i0]
1269 |                 v00[-i0] = v000 / v001
1270 |             v0 = pd.DataFrame(v00).rank().tail(1).as_matrix()[-1]
1271 |             v10 = np.empty((8, out.shape[0]))
1272 |             for i0 in range(1, 9):
1273 |                 v100 = np.full(out.shape[0], -1.0)
1274 |                 v1010 = np.empty((8, out.shape[0]))
1275 |                 for i1 in range(1, 9):
1276 |                     v1010[-i1] = close[-i1]
1277 |                 v101 = v1010[-1] - v1010[-8]
1278 |                 v10[-i0] = v100 * v101
1279 |             v1 = pd.DataFrame(v10).rank().tail(1).as_matrix()[-1]
1280 |             out[:] = v0 * v1
1281 | 
1282 |     #  (-1 * correlation(high, rank(volume), 5))
1283 |     class Alpha44(CustomFactor):
1284 |         inputs = [USEquityPricing.high, USEquityPricing.volume]
1285 |         window_length = 5
1286 | 
1287 |         def compute(self, today, assets, out, high, volume):
1288 |             v0 = np.full(out.shape[0], -1.0)
1289 |             v10 = np.empty((5, out.shape[0]))
1290 |             for i0 in range(1, 6):
1291 |                 v10[-i0] = high[-i0]
1292 |             v11 = np.empty((5, out.shape[0]))
1293 |             for i0 in range(1, 6):
1294 |                 v110 = volume[-i0]
1295 |                 v11[-i0] = stats.rankdata(v110)
1296 |             v1 = pd.DataFrame(v10).rolling(window=5).cov(pd.DataFrame(v11)).tail(1).as_matrix()[-1]
1297 |             out[:] = v0 * v1
1298 | 
1299 |     #  (-1 * ((rank((sum(delay(close, 5), 20) / 20)) * correlation(close, volume, 2)) * rank(correlation(sum(close, 5), sum(close, 20), 2))))
1300 |     class Alpha45(CustomFactor):
1301 |         inputs = [USEquityPricing.volume, USEquityPricing.close]
1302 |         window_length = 20
1303 | 
1304 |         def compute(self, today, assets, out, volume, close):
1305 |             v0 = np.full(out.shape[0], -1.0)
1306 |             v100000 = np.empty((20, out.shape[0]))
1307 |             for i0 in range(1, 21):
1308 |                 v1000000 = close[-1]
1309 |                 v100000[-i0] = v1000000 # delay
1310 |             v10000 = v100000.sum(axis=0)
1311 |             v10001 = np.full(out.shape[0], 20.0)
1312 |             v1000 = v10000 / v10001
1313 |             v100 = stats.rankdata(v1000)
1314 |             v1010 = np.empty((2, out.shape[0]))
1315 |             for i0 in range(1, 3):
1316 |                 v1010[-i0] = close[-i0]
1317 |             v1011 = np.empty((2, out.shape[0]))
1318 |             for i0 in range(1, 3):
1319 |                 v1011[-i0] = volume[-i0]
1320 |             v101 = pd.DataFrame(v1010).rolling(window=2).cov(pd.DataFrame(v1011)).tail(1).as_matrix()[-1]
1321 |             v10 = v100 * v101
1322 |             v1100 = np.empty((2, out.shape[0]))
1323 |             for i0 in range(1, 3):
1324 |                 v11000 = np.empty((5, out.shape[0]))
1325 |                 for i1 in range(1, 6):
1326 |                     v11000[-i1] = close[-i1]
1327 |                 v1100[-i0] = v11000.sum(axis=0)
1328 |             v1101 = np.empty((2, out.shape[0]))
1329 |             for i0 in range(1, 3):
1330 |                 v11010 = np.empty((20, out.shape[0]))
1331 |                 for i1 in range(1, 21):
1332 |                     v11010[-i1] = close[-i1]
1333 |                 v1101[-i0] = v11010.sum(axis=0)
1334 |             v110 = pd.DataFrame(v1100).rolling(window=2).cov(pd.DataFrame(v1101)).tail(1).as_matrix()[-1]
1335 |             v11 = stats.rankdata(v110)
1336 |             v1 = v10 * v11
1337 |             out[:] = v0 * v1
1338 | 
1339 |     #  ((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)))))
1340 |     class Alpha46(CustomFactor):
1341 |         inputs = [USEquityPricing.close]
1342 |         window_length = 21
1343 | 
1344 |         def compute(self, today, assets, out, close):
1345 |             v00 = np.full(out.shape[0], 0.25)
1346 |             v010000 = close[-1]
1347 |             v01000 = v010000 # delay
1348 |             v010010 = close[-1]
1349 |             v01001 = v010010 # delay
1350 |             v0100 = v01000 - v01001
1351 |             v0101 = np.full(out.shape[0], 10.0)
1352 |             v010 = v0100 / v0101
1353 |             v011000 = close[-1]
1354 |             v01100 = v011000 # delay
1355 |             v01101 = close[-1]
1356 |             v0110 = v01100 - v01101
1357 |             v0111 = np.full(out.shape[0], 10.0)
1358 |             v011 = v0110 / v0111
1359 |             v01 = v010 - v011
1360 |             v0 = v00 < v01
1361 |             v10 = np.full(out.shape[0], -1.0)
1362 |             v11 = np.full(out.shape[0], 1.0)
1363 |             v1 = v10 * v11
1364 |             v2000000 = close[-1]
1365 |             v200000 = v2000000 # delay
1366 |             v2000010 = close[-1]
1367 |             v200001 = v2000010 # delay
1368 |             v20000 = v200000 - v200001
1369 |             v20001 = np.full(out.shape[0], 10.0)
1370 |             v2000 = v20000 / v20001
1371 |             v2001000 = close[-1]
1372 |             v200100 = v2001000 # delay
1373 |             v200101 = close[-1]
1374 |             v20010 = v200100 - v200101
1375 |             v20011 = np.full(out.shape[0], 10.0)
1376 |             v2001 = v20010 / v20011
1377 |             v200 = v2000 - v2001
1378 |             v201 = np.full(out.shape[0], 0.0)
1379 |             v20 = v200 < v201
1380 |             v21 = np.full(out.shape[0], 1.0)
1381 |             v2200 = np.full(out.shape[0], -1.0)
1382 |             v2201 = np.full(out.shape[0], 1.0)
1383 |             v220 = v2200 * v2201
1384 |             v2210 = close[-1]
1385 |             v22110 = close[-1]
1386 |             v2211 = v22110 # delay
1387 |             v221 = v2210 - v2211
1388 |             v22 = v220 * v221
1389 |             v2lgcl = np.empty(out.shape[0])
1390 |             v2lgcl[v20] = 1
1391 |             v2lgcl[~v20] = v22[~v20]
1392 |             v2 = v2lgcl
1393 |             vlgcl = np.empty(out.shape[0])
1394 |             vlgcl[v0] = v1[v0]
1395 |             vlgcl[~v0] = v2[~v0]
1396 |             out[:] = vlgcl
1397 | 
1398 |     #  ((((rank((1 / close)) * volume) / adv20) * ((high * rank((high - close))) / (sum(high, 5) / 5))) - rank((vwap - delay(vwap, 5))))
1399 |     class Alpha47(CustomFactor):
1400 |         vwap_in = VWAP(window_length=2)
1401 |         vwap_in.window_safe = True
1402 |         adv20_in = AverageDollarVolume(window_length=20)
1403 |         adv20_in.window_safe = True
1404 |         inputs = [USEquityPricing.volume, USEquityPricing.close, USEquityPricing.high, adv20_in, vwap_in]
1405 |         window_length = 6
1406 | 
1407 |         def compute(self, today, assets, out, volume, close, high, adv20, vwap):
1408 |             v000000 = np.full(out.shape[0], 1.0)
1409 |             v000001 = close[-1]
1410 |             v00000 = v000000 / v000001
1411 |             v0000 = stats.rankdata(v00000)
1412 |             v0001 = volume[-1]
1413 |             v000 = v0000 * v0001
1414 |             v001 = adv20[-1]
1415 |             v00 = v000 / v001
1416 |             v0100 = high[-1]
1417 |             v010100 = high[-1]
1418 |             v010101 = close[-1]
1419 |             v01010 = v010100 - v010101
1420 |             v0101 = stats.rankdata(v01010)
1421 |             v010 = v0100 * v0101
1422 |             v01100 = np.empty((5, out.shape[0]))
1423 |             for i0 in range(1, 6):
1424 |                 v01100[-i0] = high[-i0]
1425 |             v0110 = v01100.sum(axis=0)
1426 |             v0111 = np.full(out.shape[0], 5.0)
1427 |             v011 = v0110 / v0111
1428 |             v01 = v010 / v011
1429 |             v0 = v00 * v01
1430 |             v100 = vwap[-1]
1431 |             v1010 = vwap[-1]
1432 |             v101 = v1010 # delay
1433 |             v10 = v100 - v101
1434 |             v1 = stats.rankdata(v10)
1435 |             out[:] = v0 - v1
1436 | 
1437 |     #  (((((delay(close, 20) - delay(close, 10)) / 10) - ((delay(close, 10) - close) / 10)) < (-1 * 0.1)) ? 1 : ((-1 * 1) * (close - delay(close, 1))))
1438 |     class Alpha49(CustomFactor):
1439 |         inputs = [USEquityPricing.close]
1440 |         window_length = 21
1441 | 
1442 |         def compute(self, today, assets, out, close):
1443 |             v000000 = close[-1]
1444 |             v00000 = v000000 # delay
1445 |             v000010 = close[-1]
1446 |             v00001 = v000010 # delay
1447 |             v0000 = v00000 - v00001
1448 |             v0001 = np.full(out.shape[0], 10.0)
1449 |             v000 = v0000 / v0001
1450 |             v001000 = close[-1]
1451 |             v00100 = v001000 # delay
1452 |             v00101 = close[-1]
1453 |             v0010 = v00100 - v00101
1454 |             v0011 = np.full(out.shape[0], 10.0)
1455 |             v001 = v0010 / v0011
1456 |             v00 = v000 - v001
1457 |             v010 = np.full(out.shape[0], -1.0)
1458 |             v011 = np.full(out.shape[0], 0.1)
1459 |             v01 = v010 * v011
1460 |             v0 = v00 < v01
1461 |             v1 = np.full(out.shape[0], 1.0)
1462 |             v200 = np.full(out.shape[0], -1.0)
1463 |             v201 = np.full(out.shape[0], 1.0)
1464 |             v20 = v200 * v201
1465 |             v210 = close[-1]
1466 |             v2110 = close[-1]
1467 |             v211 = v2110 # delay
1468 |             v21 = v210 - v211
1469 |             v2 = v20 * v21
1470 |             vlgcl = np.empty(out.shape[0])
1471 |             vlgcl[v0] = 1
1472 |             vlgcl[~v0] = v2[~v0]
1473 |             out[:] = vlgcl
1474 | 
1475 |     #  (-1 * ts_max(rank(correlation(rank(volume), rank(vwap), 5)), 5))
1476 |     class Alpha50(CustomFactor):
1477 |         vwap_in = VWAP(window_length=2)
1478 |         vwap_in.window_safe = True
1479 |         inputs = [USEquityPricing.volume, vwap_in]
1480 |         window_length = 5
1481 | 
1482 |         def compute(self, today, assets, out, volume, vwap):
1483 |             v0 = np.full(out.shape[0], -1.0)
1484 |             v10 = np.empty((5, out.shape[0]))
1485 |             for i0 in range(1, 6):
1486 |                 v1000 = np.empty((5, out.shape[0]))
1487 |                 for i1 in range(1, 6):
1488 |                     v10000 = volume[-i1]
1489 |                     v1000[-i1] = stats.rankdata(v10000)
1490 |                 v1001 = np.empty((5, out.shape[0]))
1491 |                 for i1 in range(1, 6):
1492 |                     v10010 = vwap[-i1]
1493 |                     v1001[-i1] = stats.rankdata(v10010)
1494 |                 v100 = pd.DataFrame(v1000).rolling(window=5).cov(pd.DataFrame(v1001)).tail(1).as_matrix()[-1]
1495 |                 v10[-i0] = stats.rankdata(v100)
1496 |             v1 = np.max(v10, axis=0)
1497 |             out[:] = v0 * v1
1498 | 
1499 |     #  (((((delay(close, 20) - delay(close, 10)) / 10) - ((delay(close, 10) - close) / 10)) < (-1 * 0.05)) ? 1 : ((-1 * 1) * (close - delay(close, 1))))
1500 |     class Alpha51(CustomFactor):
1501 |         inputs = [USEquityPricing.close]
1502 |         window_length = 21
1503 | 
1504 |         def compute(self, today, assets, out, close):
1505 |             v000000 = close[-1]
1506 |             v00000 = v000000 # delay
1507 |             v000010 = close[-1]
1508 |             v00001 = v000010 # delay
1509 |             v0000 = v00000 - v00001
1510 |             v0001 = np.full(out.shape[0], 10.0)
1511 |             v000 = v0000 / v0001
1512 |             v001000 = close[-1]
1513 |             v00100 = v001000 # delay
1514 |             v00101 = close[-1]
1515 |             v0010 = v00100 - v00101
1516 |             v0011 = np.full(out.shape[0], 10.0)
1517 |             v001 = v0010 / v0011
1518 |             v00 = v000 - v001
1519 |             v010 = np.full(out.shape[0], -1.0)
1520 |             v011 = np.full(out.shape[0], 0.05)
1521 |             v01 = v010 * v011
1522 |             v0 = v00 < v01
1523 |             v1 = np.full(out.shape[0], 1.0)
1524 |             v200 = np.full(out.shape[0], -1.0)
1525 |             v201 = np.full(out.shape[0], 1.0)
1526 |             v20 = v200 * v201
1527 |             v210 = close[-1]
1528 |             v2110 = close[-1]
1529 |             v211 = v2110 # delay
1530 |             v21 = v210 - v211
1531 |             v2 = v20 * v21
1532 |             vlgcl = np.empty(out.shape[0])
1533 |             vlgcl[v0] = 1
1534 |             vlgcl[~v0] = v2[~v0]
1535 |             out[:] = vlgcl
1536 | 
1537 |     #  ((((-1 * ts_min(low, 5)) + delay(ts_min(low, 5), 5)) * rank(((sum(returns, 240) - sum(returns, 20)) / 220))) * ts_rank(volume, 5))
1538 |     class Alpha52(CustomFactor):
1539 |         inputs = [USEquityPricing.volume, Returns(window_length=2), USEquityPricing.low]
1540 |         window_length = 240
1541 | 
1542 |         def compute(self, today, assets, out, volume, returns, low):
1543 |             v0000 = np.full(out.shape[0], -1.0)
1544 |             v00010 = np.empty((5, out.shape[0]))
1545 |             for i0 in range(1, 6):
1546 |                 v00010[-i0] = low[-i0]
1547 |             v0001 = np.min(v00010, axis=0)
1548 |             v000 = v0000 * v0001
1549 |             v00100 = np.empty((5, out.shape[0]))
1550 |             for i0 in range(6, 11):
1551 |                 v00100[5-i0] = low[-i0]
1552 |             v0010 = np.min(v00100, axis=0)
1553 |             v001 = v0010 # delay
1554 |             v00 = v000 + v001
1555 |             v010000 = np.empty((240, out.shape[0]))
1556 |             for i0 in range(1, 241):
1557 |                 v010000[-i0] = returns[-i0]
1558 |             v01000 = v010000.sum(axis=0)
1559 |             v010010 = np.empty((20, out.shape[0]))
1560 |             for i0 in range(1, 21):
1561 |                 v010010[-i0] = returns[-i0]
1562 |             v01001 = v010010.sum(axis=0)
1563 |             v0100 = v01000 - v01001
1564 |             v0101 = np.full(out.shape[0], 220.0)
1565 |             v010 = v0100 / v0101
1566 |             v01 = stats.rankdata(v010)
1567 |             v0 = v00 * v01
1568 |             v10 = np.empty((5, out.shape[0]))
1569 |             for i0 in range(1, 6):
1570 |                 v10[-i0] = volume[-i0]
1571 |             v1 = pd.DataFrame(v10).rank().tail(1).as_matrix()[-1]
1572 |             out[:] = v0 * v1
1573 | 
1574 |     #  (-1 * delta((((close - low) - (high - close)) / (close - low)), 9))
1575 |     class Alpha53(CustomFactor):
1576 |         inputs = [USEquityPricing.high, USEquityPricing.close, USEquityPricing.low]
1577 |         window_length = 10
1578 | 
1579 |         def compute(self, today, assets, out, high, close, low):
1580 |             v0 = np.full(out.shape[0], -1.0)
1581 |             v10 = np.empty((10, out.shape[0]))
1582 |             for i0 in range(1, 11):
1583 |                 v10000 = close[-i0]
1584 |                 v10001 = low[-i0]
1585 |                 v1000 = v10000 - v10001
1586 |                 v10010 = high[-i0]
1587 |                 v10011 = close[-i0]
1588 |                 v1001 = v10010 - v10011
1589 |                 v100 = v1000 - v1001
1590 |                 v1010 = close[-i0]
1591 |                 v1011 = low[-i0]
1592 |                 v101 = v1010 - v1011
1593 |                 v10[-i0] = v100 / v101
1594 |             v1 = v10[-1] - v10[-10]
1595 |             out[:] = v0 * v1
1596 | 
1597 |     #  ((-1 * ((low - close) * (open^5))) / ((low - high) * (close^5)))
1598 |     class Alpha54(CustomFactor):
1599 |         inputs = [USEquityPricing.high, USEquityPricing.close, USEquityPricing.open, USEquityPricing.low]
1600 |         window_length = 2
1601 | 
1602 |         def compute(self, today, assets, out, high, close, open, low):
1603 |             v00 = np.full(out.shape[0], -1.0)
1604 |             v0100 = low[-1]
1605 |             v0101 = close[-1]
1606 |             v010 = v0100 - v0101
1607 |             v0110 = open[-1]
1608 |             v0111 = np.full(out.shape[0], 5.0)
1609 |             v011 = np.power(v0110, v0111)
1610 |             v01 = v010 * v011
1611 |             v0 = v00 * v01
1612 |             v100 = low[-1]
1613 |             v101 = high[-1]
1614 |             v10 = v100 - v101
1615 |             v110 = close[-1]
1616 |             v111 = np.full(out.shape[0], 5.0)
1617 |             v11 = np.power(v110, v111)
1618 |             v1 = v10 * v11
1619 |             out[:] = v0 / v1
1620 | 
1621 |     #  (-1 * correlation(rank(((close - ts_min(low, 12)) / (ts_max(high, 12) - ts_min(low, 12)))), rank(volume), 6))
1622 |     class Alpha55(CustomFactor):
1623 |         inputs = [USEquityPricing.high, USEquityPricing.close, USEquityPricing.low, USEquityPricing.volume]
1624 |         window_length = 12
1625 | 
1626 |         def compute(self, today, assets, out, high, close, low, volume):
1627 |             v0 = np.full(out.shape[0], -1.0)
1628 |             v10 = np.empty((6, out.shape[0]))
1629 |             for i0 in range(1, 7):
1630 |                 v10000 = close[-i0]
1631 |                 v100010 = np.empty((12, out.shape[0]))
1632 |                 for i1 in range(1, 13):
1633 |                     v100010[-i1] = low[-i1]
1634 |                 v10001 = np.min(v100010, axis=0)
1635 |                 v1000 = v10000 - v10001
1636 |                 v100100 = np.empty((12, out.shape[0]))
1637 |                 for i1 in range(1, 13):
1638 |                     v100100[-i1] = high[-i1]
1639 |                 v10010 = np.max(v100100, axis=0)
1640 |                 v100110 = np.empty((12, out.shape[0]))
1641 |                 for i1 in range(1, 13):
1642 |                     v100110[-i1] = low[-i1]
1643 |                 v10011 = np.min(v100110, axis=0)
1644 |                 v1001 = v10010 - v10011
1645 |                 v100 = v1000 / v1001
1646 |                 v10[-i0] = stats.rankdata(v100)
1647 |             v11 = np.empty((6, out.shape[0]))
1648 |             for i0 in range(1, 7):
1649 |                 v110 = volume[-i0]
1650 |                 v11[-i0] = stats.rankdata(v110)
1651 |             v1 = pd.DataFrame(v10).rolling(window=6).cov(pd.DataFrame(v11)).tail(1).as_matrix()[-1]
1652 |             out[:] = v0 * v1
1653 | 
1654 |     #  (0 - (1 * (rank((sum(returns, 10) / sum(sum(returns, 2), 3))) * rank((returns * cap)))))
1655 |     class Alpha56(CustomFactor):
1656 |         inputs = [Returns(window_length=2)]
1657 |         window_length = 10
1658 | 
1659 |         def compute(self, today, assets, out, returns):
1660 |             v0 = np.full(out.shape[0], 0.0)
1661 |             v10 = np.full(out.shape[0], 1.0)
1662 |             v110000 = np.empty((10, out.shape[0]))
1663 |             for i0 in range(1, 11):
1664 |                 v110000[-i0] = returns[-i0]
1665 |             v11000 = v110000.sum(axis=0)
1666 |             v110010 = np.empty((3, out.shape[0]))
1667 |             for i0 in range(1, 4):
1668 |                 v1100100 = np.empty((2, out.shape[0]))
1669 |                 for i1 in range(1, 3):
1670 |                     v1100100[-i1] = returns[-i1]
1671 |                 v110010[-i0] = v1100100.sum(axis=0)
1672 |             v11001 = v110010.sum(axis=0)
1673 |             v1100 = v11000 / v11001
1674 |             v110 = stats.rankdata(v1100)
1675 |             v11100 = returns[-1]
1676 |             v11101 = cap[-1]
1677 |             v1110 = v11100 * v11101
1678 |             v111 = stats.rankdata(v1110)
1679 |             v11 = v110 * v111
1680 |             v1 = v10 * v11
1681 |             out[:] = v0 - v1
1682 | 
1683 |     #  (0 - (1 * ((close - vwap) / decay_linear(rank(ts_argmax(close, 30)), 2))))
1684 |     class Alpha57(CustomFactor):
1685 |         vwap_in = VWAP(window_length=2)
1686 |         vwap_in.window_safe = True
1687 |         inputs = [USEquityPricing.close, vwap_in]
1688 |         window_length = 30
1689 | 
1690 |         def compute(self, today, assets, out, close, vwap):
1691 |             v0 = np.full(out.shape[0], 0.0)
1692 |             v10 = np.full(out.shape[0], 1.0)
1693 |             v1100 = close[-1]
1694 |             v1101 = vwap[-1]
1695 |             v110 = v1100 - v1101
1696 |             v1110 = np.empty((2, out.shape[0]))
1697 |             for i0 in range(1, 3):
1698 |                 v111000 = np.empty((30, out.shape[0]))
1699 |                 for i1 in range(1, 31):
1700 |                     v111000[-i1] = close[-i1]
1701 |                 v11100 = np.argmax(v111000, axis=0)
1702 |                 v1110[-i0] = stats.rankdata(v11100)
1703 |             v111 = (v1110 * (np.arange(1.0, 3, 1.0)/3)[:, np.newaxis]).sum(axis=0) # decay_linear
1704 |             v11 = v110 / v111
1705 |             v1 = v10 * v11
1706 |             out[:] = v0 - v1
1707 | 
1708 |     #  (0 - (1 * ((2 * scale(rank(((((close - low) - (high - close)) / (high - low)) * volume)))) - scale(rank(ts_argmax(close, 10))))))
1709 |     class Alpha60(CustomFactor):
1710 |         inputs = [USEquityPricing.high, USEquityPricing.close, USEquityPricing.low, USEquityPricing.volume]
1711 |         window_length = 10
1712 | 
1713 |         def compute(self, today, assets, out, high, close, low, volume):
1714 |             v0 = np.full(out.shape[0], 0.0)
1715 |             v10 = np.full(out.shape[0], 1.0)
1716 |             v1100 = np.full(out.shape[0], 2.0)
1717 |             v1101000000 = close[-1]
1718 |             v1101000001 = low[-1]
1719 |             v110100000 = v1101000000 - v1101000001
1720 |             v1101000010 = high[-1]
1721 |             v1101000011 = close[-1]
1722 |             v110100001 = v1101000010 - v1101000011
1723 |             v11010000 = v110100000 - v110100001
1724 |             v110100010 = high[-1]
1725 |             v110100011 = low[-1]
1726 |             v11010001 = v110100010 - v110100011
1727 |             v1101000 = v11010000 / v11010001
1728 |             v1101001 = volume[-1]
1729 |             v110100 = v1101000 * v1101001
1730 |             v11010 = stats.rankdata(v110100)
1731 |             v1101 = v11010/np.abs(v11010).sum()
1732 |             v110 = v1100 * v1101
1733 |             v111000 = np.empty((10, out.shape[0]))
1734 |             for i0 in range(1, 11):
1735 |                 v111000[-i0] = close[-i0]
1736 |             v11100 = np.argmax(v111000, axis=0)
1737 |             v1110 = stats.rankdata(v11100)
1738 |             v111 = v1110/np.abs(v1110).sum()
1739 |             v11 = v110 - v111
1740 |             v1 = v10 * v11
1741 |             out[:] = v0 - v1
1742 | 
1743 |     #  (rank((vwap - ts_min(vwap, 16.1219))) < rank(correlation(vwap, adv180, 17.9282)))
1744 |     class Alpha61(CustomFactor):
1745 |         vwap_in = VWAP(window_length=2)
1746 |         vwap_in.window_safe = True
1747 |         adv180_in = AverageDollarVolume(window_length=180)
1748 |         adv180_in.window_safe = True
1749 |         inputs = [adv180_in, vwap_in]
1750 |         window_length = 17
1751 | 
1752 |         def compute(self, today, assets, out, adv180, vwap):
1753 |             v000 = vwap[-1]
1754 |             v0010 = np.empty((16, out.shape[0]))
1755 |             for i0 in range(1, 17):
1756 |                 v0010[-i0] = vwap[-i0]
1757 |             v001 = np.min(v0010, axis=0)
1758 |             v00 = v000 - v001
1759 |             v0 = stats.rankdata(v00)
1760 |             v100 = np.empty((18, out.shape[0]))
1761 |             for i0 in range(1, 19):
1762 |                 v100[-i0] = vwap[-i0]
1763 |             v101 = np.empty((18, out.shape[0]))
1764 |             for i0 in range(1, 19):
1765 |                 v101[-i0] = adv180[-i0]
1766 |             v10 = pd.DataFrame(v100).rolling(window=18).cov(pd.DataFrame(v101)).tail(1).as_matrix()[-1]
1767 |             v1 = stats.rankdata(v10)
1768 |             out[:] = v0 < v1
1769 | 
1770 |     #  ((rank(correlation(vwap, sum(adv20, 22.4101), 9.91009)) < rank(((rank(open) + rank(open)) < (rank(((high + low) / 2)) + rank(high))))) * -1)
1771 |     class Alpha62(CustomFactor):
1772 |         vwap_in = VWAP(window_length=2)
1773 |         vwap_in.window_safe = True
1774 |         adv20_in = AverageDollarVolume(window_length=20)
1775 |         adv20_in.window_safe = True
1776 |         inputs = [USEquityPricing.high, USEquityPricing.open, adv20_in, USEquityPricing.low, vwap_in]
1777 |         window_length = 22
1778 | 
1779 |         def compute(self, today, assets, out, high, open, adv20, low, vwap):
1780 |             v0000 = np.empty((10, out.shape[0]))
1781 |             for i0 in range(1, 11):
1782 |                 v0000[-i0] = vwap[-i0]
1783 |             v0001 = np.empty((10, out.shape[0]))
1784 |             for i0 in range(1, 11):
1785 |                 v00010 = np.empty((22, out.shape[0]))
1786 |                 for i1 in range(1, 23):
1787 |                     v00010[-i1] = adv20[-i1]
1788 |                 v0001[-i0] = v00010.sum(axis=0)
1789 |             v000 = pd.DataFrame(v0000).rolling(window=10).cov(pd.DataFrame(v0001)).tail(1).as_matrix()[-1]
1790 |             v00 = stats.rankdata(v000)
1791 |             v010000 = open[-1]
1792 |             v01000 = stats.rankdata(v010000)
1793 |             v010010 = open[-1]
1794 |             v01001 = stats.rankdata(v010010)
1795 |             v0100 = v01000 + v01001
1796 |             v01010000 = high[-1]
1797 |             v01010001 = low[-1]
1798 |             v0101000 = v01010000 + v01010001
1799 |             v0101001 = np.full(out.shape[0], 2.0)
1800 |             v010100 = v0101000 / v0101001
1801 |             v01010 = stats.rankdata(v010100)
1802 |             v010110 = high[-1]
1803 |             v01011 = stats.rankdata(v010110)
1804 |             v0101 = v01010 + v01011
1805 |             v010 = v0100 < v0101
1806 |             v01 = stats.rankdata(v010)
1807 |             v0 = v00 < v01
1808 |             v1 = np.full(out.shape[0], -1.0)
1809 |             out[:] = v0 * v1
1810 | 
1811 |     #  ((rank(correlation(sum(((open * 0.178404) + (low * (1 - 0.178404))), 12.7054), sum(adv120, 12.7054), 16.6208)) < rank(delta(((((high + low) / 2) * 0.178404) + (vwap * (1 - 0.178404))), 3.69741))) * -1)
1812 |     class Alpha64(CustomFactor):
1813 |         vwap_in = VWAP(window_length=2)
1814 |         vwap_in.window_safe = True
1815 |         adv120_in = AverageDollarVolume(window_length=120)
1816 |         adv120_in.window_safe = True
1817 |         inputs = [adv120_in, USEquityPricing.high, USEquityPricing.open, USEquityPricing.low, vwap_in]
1818 |         window_length = 16
1819 | 
1820 |         def compute(self, today, assets, out, adv120, high, open, low, vwap):
1821 |             v0000 = np.empty((17, out.shape[0]))
1822 |             for i0 in range(1, 18):
1823 |                 v00000 = np.empty((13, out.shape[0]))
1824 |                 for i1 in range(1, 14):
1825 |                     v0000000 = open[-i1]
1826 |                     v0000001 = np.full(out.shape[0], 0.178404)
1827 |                     v000000 = v0000000 * v0000001
1828 |                     v0000010 = low[-i1]
1829 |                     v00000110 = np.full(out.shape[0], 1.0)
1830 |                     v00000111 = np.full(out.shape[0], 0.178404)
1831 |                     v0000011 = v00000110 - v00000111
1832 |                     v000001 = v0000010 * v0000011
1833 |                     v00000[-i1] = v000000 + v000001
1834 |                 v0000[-i0] = v00000.sum(axis=0)
1835 |             v0001 = np.empty((17, out.shape[0]))
1836 |             for i0 in range(1, 18):
1837 |                 v00010 = np.empty((13, out.shape[0]))
1838 |                 for i1 in range(1, 14):
1839 |                     v00010[-i1] = adv120[-i1]
1840 |                 v0001[-i0] = v00010.sum(axis=0)
1841 |             v000 = pd.DataFrame(v0000).rolling(window=17).cov(pd.DataFrame(v0001)).tail(1).as_matrix()[-1]
1842 |             v00 = stats.rankdata(v000)
1843 |             v0100 = np.empty((5, out.shape[0]))
1844 |             for i0 in range(1, 6):
1845 |                 v01000000 = high[-i0]
1846 |                 v01000001 = low[-i0]
1847 |                 v0100000 = v01000000 + v01000001
1848 |                 v0100001 = np.full(out.shape[0], 2.0)
1849 |                 v010000 = v0100000 / v0100001
1850 |                 v010001 = np.full(out.shape[0], 0.178404)
1851 |                 v01000 = v010000 * v010001
1852 |                 v010010 = vwap[-i0]
1853 |                 v0100110 = np.full(out.shape[0], 1.0)
1854 |                 v0100111 = np.full(out.shape[0], 0.178404)
1855 |                 v010011 = v0100110 - v0100111
1856 |                 v01001 = v010010 * v010011
1857 |                 v0100[-i0] = v01000 + v01001
1858 |             v010 = v0100[-1] - v0100[-5]
1859 |             v01 = stats.rankdata(v010)
1860 |             v0 = v00 < v01
1861 |             v1 = np.full(out.shape[0], -1.0)
1862 |             out[:] = v0 * v1
1863 | 
1864 |     #  ((rank(correlation(((open * 0.00817205) + (vwap * (1 - 0.00817205))), sum(adv60, 8.6911), 6.40374)) < rank((open - ts_min(open, 13.635)))) * -1)
1865 |     class Alpha65(CustomFactor):
1866 |         vwap_in = VWAP(window_length=2)
1867 |         vwap_in.window_safe = True
1868 |         adv60_in = AverageDollarVolume(window_length=60)
1869 |         adv60_in.window_safe = True
1870 |         inputs = [adv60_in, USEquityPricing.open, vwap_in]
1871 |         window_length = 13
1872 | 
1873 |         def compute(self, today, assets, out, adv60, open, vwap):
1874 |             v0000 = np.empty((6, out.shape[0]))
1875 |             for i0 in range(1, 7):
1876 |                 v000000 = open[-i0]
1877 |                 v000001 = np.full(out.shape[0], 0.00817205)
1878 |                 v00000 = v000000 * v000001
1879 |                 v000010 = vwap[-i0]
1880 |                 v0000110 = np.full(out.shape[0], 1.0)
1881 |                 v0000111 = np.full(out.shape[0], 0.00817205)
1882 |                 v000011 = v0000110 - v0000111
1883 |                 v00001 = v000010 * v000011
1884 |                 v0000[-i0] = v00000 + v00001
1885 |             v0001 = np.empty((6, out.shape[0]))
1886 |             for i0 in range(1, 7):
1887 |                 v00010 = np.empty((9, out.shape[0]))
1888 |                 for i1 in range(1, 10):
1889 |                     v00010[-i1] = adv60[-i1]
1890 |                 v0001[-i0] = v00010.sum(axis=0)
1891 |             v000 = pd.DataFrame(v0000).rolling(window=6).cov(pd.DataFrame(v0001)).tail(1).as_matrix()[-1]
1892 |             v00 = stats.rankdata(v000)
1893 |             v0100 = open[-1]
1894 |             v01010 = np.empty((14, out.shape[0]))
1895 |             for i0 in range(1, 15):
1896 |                 v01010[-i0] = open[-i0]
1897 |             v0101 = np.min(v01010, axis=0)
1898 |             v010 = v0100 - v0101
1899 |             v01 = stats.rankdata(v010)
1900 |             v0 = v00 < v01
1901 |             v1 = np.full(out.shape[0], -1.0)
1902 |             out[:] = v0 * v1
1903 | 
1904 |     #  ((rank(decay_linear(delta(vwap, 3.51013), 7.23052)) + Ts_Rank(decay_linear(((((low * 0.96633) + (low * (1 - 0.96633))) - vwap) / (open - ((high + low) / 2))), 11.4157), 6.72611)) * -1)
1905 |     class Alpha66(CustomFactor):
1906 |         vwap_in = VWAP(window_length=2)
1907 |         vwap_in.window_safe = True
1908 |         inputs = [USEquityPricing.high, USEquityPricing.open, USEquityPricing.low, vwap_in]
1909 |         window_length = 11
1910 | 
1911 |         def compute(self, today, assets, out, high, open, low, vwap):
1912 |             v0000 = np.empty((7, out.shape[0]))
1913 |             for i0 in range(1, 8):
1914 |                 v00000 = np.empty((5, out.shape[0]))
1915 |                 for i1 in range(1, 6):
1916 |                     v00000[-i1] = vwap[-i1]
1917 |                 v0000[-i0] = v00000[-1] - v00000[-5]
1918 |             v000 = (v0000 * (np.arange(1.0, 8, 1.0)/28)[:, np.newaxis]).sum(axis=0) # decay_linear
1919 |             v00 = stats.rankdata(v000)
1920 |             v010 = np.empty((7, out.shape[0]))
1921 |             for i0 in range(1, 8):
1922 |                 v0100 = np.empty((11, out.shape[0]))
1923 |                 for i1 in range(1, 12):
1924 |                     v01000000 = low[-i1]
1925 |                     v01000001 = np.full(out.shape[0], 0.96633)
1926 |                     v0100000 = v01000000 * v01000001
1927 |                     v01000010 = low[-i1]
1928 |                     v010000110 = np.full(out.shape[0], 1.0)
1929 |                     v010000111 = np.full(out.shape[0], 0.96633)
1930 |                     v01000011 = v010000110 - v010000111
1931 |                     v0100001 = v01000010 * v01000011
1932 |                     v010000 = v0100000 + v0100001
1933 |                     v010001 = vwap[-i1]
1934 |                     v01000 = v010000 - v010001
1935 |                     v010010 = open[-i1]
1936 |                     v01001100 = high[-i1]
1937 |                     v01001101 = low[-i1]
1938 |                     v0100110 = v01001100 + v01001101
1939 |                     v0100111 = np.full(out.shape[0], 2.0)
1940 |                     v010011 = v0100110 / v0100111
1941 |                     v01001 = v010010 - v010011
1942 |                     v0100[-i1] = v01000 / v01001
1943 |                 v010[-i0] = (v0100 * (np.arange(1.0, 12, 1.0)/66)[:, np.newaxis]).sum(axis=0) # decay_linear
1944 |             v01 = pd.DataFrame(v010).rank().tail(1).as_matrix()[-1]
1945 |             v0 = v00 + v01
1946 |             v1 = np.full(out.shape[0], -1.0)
1947 |             out[:] = v0 * v1
1948 | 
1949 |     #  ((Ts_Rank(correlation(rank(high), rank(adv15), 8.91644), 13.9333) < rank(delta(((close * 0.518371) + (low * (1 - 0.518371))), 1.06157))) * -1)
1950 |     class Alpha68(CustomFactor):
1951 |         adv15_in = AverageDollarVolume(window_length=15)
1952 |         adv15_in.window_safe = True
1953 |         inputs = [USEquityPricing.high, adv15_in, USEquityPricing.low, USEquityPricing.close]
1954 |         window_length = 13
1955 | 
1956 |         def compute(self, today, assets, out, high, adv15, low, close):
1957 |             v000 = np.empty((14, out.shape[0]))
1958 |             for i0 in range(1, 15):
1959 |                 v0000 = np.empty((9, out.shape[0]))
1960 |                 for i1 in range(1, 10):
1961 |                     v00000 = high[-i1]
1962 |                     v0000[-i1] = stats.rankdata(v00000)
1963 |                 v0001 = np.empty((9, out.shape[0]))
1964 |                 for i1 in range(1, 10):
1965 |                     v00010 = adv15[-i1]
1966 |                     v0001[-i1] = stats.rankdata(v00010)
1967 |                 v000[-i0] = pd.DataFrame(v0000).rolling(window=9).cov(pd.DataFrame(v0001)).tail(1).as_matrix()[-1]
1968 |             v00 = pd.DataFrame(v000).rank().tail(1).as_matrix()[-1]
1969 |             v0100 = np.empty((2, out.shape[0]))
1970 |             for i0 in range(1, 3):
1971 |                 v010000 = close[-i0]
1972 |                 v010001 = np.full(out.shape[0], 0.518371)
1973 |                 v01000 = v010000 * v010001
1974 |                 v010010 = low[-i0]
1975 |                 v0100110 = np.full(out.shape[0], 1.0)
1976 |                 v0100111 = np.full(out.shape[0], 0.518371)
1977 |                 v010011 = v0100110 - v0100111
1978 |                 v01001 = v010010 * v010011
1979 |                 v0100[-i0] = v01000 + v01001
1980 |             v010 = v0100[-1] - v0100[-2]
1981 |             v01 = stats.rankdata(v010)
1982 |             v0 = v00 < v01
1983 |             v1 = np.full(out.shape[0], -1.0)
1984 |             out[:] = v0 * v1
1985 | 
1986 |     #  (rank(decay_linear(correlation(((high + low) / 2), adv40, 8.93345), 10.1519)) / rank(decay_linear(correlation(Ts_Rank(vwap, 3.72469), Ts_Rank(volume, 18.5188), 6.86671), 2.95011)))
1987 |     class Alpha72(CustomFactor):
1988 |         vwap_in = VWAP(window_length=2)
1989 |         vwap_in.window_safe = True
1990 |         adv40_in = AverageDollarVolume(window_length=40)
1991 |         adv40_in.window_safe = True
1992 |         inputs = [USEquityPricing.high, USEquityPricing.volume, adv40_in, USEquityPricing.low, vwap_in]
1993 |         window_length = 18
1994 | 
1995 |         def compute(self, today, assets, out, high, volume, adv40, low, vwap):
1996 |             v000 = np.empty((10, out.shape[0]))
1997 |             for i0 in range(1, 11):
1998 |                 v0000 = np.empty((9, out.shape[0]))
1999 |                 for i1 in range(1, 10):
2000 |                     v000000 = high[-i1]
2001 |                     v000001 = low[-i1]
2002 |                     v00000 = v000000 + v000001
2003 |                     v00001 = np.full(out.shape[0], 2.0)
2004 |                     v0000[-i1] = v00000 / v00001
2005 |                 v0001 = np.empty((9, out.shape[0]))
2006 |                 for i1 in range(1, 10):
2007 |                     v0001[-i1] = adv40[-i1]
2008 |                 v000[-i0] = pd.DataFrame(v0000).rolling(window=9).cov(pd.DataFrame(v0001)).tail(1).as_matrix()[-1]
2009 |             v00 = (v000 * (np.arange(1.0, 11, 1.0)/55)[:, np.newaxis]).sum(axis=0) # decay_linear
2010 |             v0 = stats.rankdata(v00)
2011 |             v100 = np.empty((3, out.shape[0]))
2012 |             for i0 in range(1, 4):
2013 |                 v1000 = np.empty((7, out.shape[0]))
2014 |                 for i1 in range(1, 8):
2015 |                     v10000 = np.empty((4, out.shape[0]))
2016 |                     for i2 in range(1, 5):
2017 |                         v10000[-i2] = vwap[-i2]
2018 |                     v1000[-i1] = pd.DataFrame(v10000).rank().tail(1).as_matrix()[-1]
2019 |                 v1001 = np.empty((7, out.shape[0]))
2020 |                 for i1 in range(1, 8):
2021 |                     v10010 = np.empty((19, out.shape[0]))
2022 |                     for i2 in range(1, 20):
2023 |                         v10010[-i2] = volume[-i2]
2024 |                     v1001[-i1] = pd.DataFrame(v10010).rank().tail(1).as_matrix()[-1]
2025 |                 v100[-i0] = pd.DataFrame(v1000).rolling(window=7).cov(pd.DataFrame(v1001)).tail(1).as_matrix()[-1]
2026 |             v10 = (v100 * (np.arange(1.0, 4, 1.0)/6)[:, np.newaxis]).sum(axis=0) # decay_linear
2027 |             v1 = stats.rankdata(v10)
2028 |             out[:] = v0 / v1
2029 | 
2030 |     #  ((rank(correlation(close, sum(adv30, 37.4843), 15.1365)) < rank(correlation(rank(((high * 0.0261661) + (vwap * (1 - 0.0261661)))), rank(volume), 11.4791))) * -1)
2031 |     class Alpha74(CustomFactor):
2032 |         vwap_in = VWAP(window_length=2)
2033 |         vwap_in.window_safe = True
2034 |         adv30_in = AverageDollarVolume(window_length=30)
2035 |         adv30_in.window_safe = True
2036 |         inputs = [USEquityPricing.high, USEquityPricing.close, adv30_in, vwap_in, USEquityPricing.volume]
2037 |         window_length = 37
2038 | 
2039 |         def compute(self, today, assets, out, high, close, adv30, vwap, volume):
2040 |             v0000 = np.empty((15, out.shape[0]))
2041 |             for i0 in range(1, 16):
2042 |                 v0000[-i0] = close[-i0]
2043 |             v0001 = np.empty((15, out.shape[0]))
2044 |             for i0 in range(1, 16):
2045 |                 v00010 = np.empty((37, out.shape[0]))
2046 |                 for i1 in range(1, 38):
2047 |                     v00010[-i1] = adv30[-i1]
2048 |                 v0001[-i0] = v00010.sum(axis=0)
2049 |             v000 = pd.DataFrame(v0000).rolling(window=15).cov(pd.DataFrame(v0001)).tail(1).as_matrix()[-1]
2050 |             v00 = stats.rankdata(v000)
2051 |             v0100 = np.empty((11, out.shape[0]))
2052 |             for i0 in range(1, 12):
2053 |                 v0100000 = high[-i0]
2054 |                 v0100001 = np.full(out.shape[0], 0.0261661)
2055 |                 v010000 = v0100000 * v0100001
2056 |                 v0100010 = vwap[-i0]
2057 |                 v01000110 = np.full(out.shape[0], 1.0)
2058 |                 v01000111 = np.full(out.shape[0], 0.0261661)
2059 |                 v0100011 = v01000110 - v01000111
2060 |                 v010001 = v0100010 * v0100011
2061 |                 v01000 = v010000 + v010001
2062 |                 v0100[-i0] = stats.rankdata(v01000)
2063 |             v0101 = np.empty((11, out.shape[0]))
2064 |             for i0 in range(1, 12):
2065 |                 v01010 = volume[-i0]
2066 |                 v0101[-i0] = stats.rankdata(v01010)
2067 |             v010 = pd.DataFrame(v0100).rolling(window=11).cov(pd.DataFrame(v0101)).tail(1).as_matrix()[-1]
2068 |             v01 = stats.rankdata(v010)
2069 |             v0 = v00 < v01
2070 |             v1 = np.full(out.shape[0], -1.0)
2071 |             out[:] = v0 * v1
2072 | 
2073 |     #  (rank(correlation(vwap, volume, 4.24304)) < rank(correlation(rank(low), rank(adv50), 12.4413)))
2074 |     class Alpha75(CustomFactor):
2075 |         vwap_in = VWAP(window_length=2)
2076 |         vwap_in.window_safe = True
2077 |         adv50_in = AverageDollarVolume(window_length=50)
2078 |         adv50_in.window_safe = True
2079 |         inputs = [USEquityPricing.volume, adv50_in, USEquityPricing.low, vwap_in]
2080 |         window_length = 12
2081 | 
2082 |         def compute(self, today, assets, out, volume, adv50, low, vwap):
2083 |             v000 = np.empty((4, out.shape[0]))
2084 |             for i0 in range(1, 5):
2085 |                 v000[-i0] = vwap[-i0]
2086 |             v001 = np.empty((4, out.shape[0]))
2087 |             for i0 in range(1, 5):
2088 |                 v001[-i0] = volume[-i0]
2089 |             v00 = pd.DataFrame(v000).rolling(window=4).cov(pd.DataFrame(v001)).tail(1).as_matrix()[-1]
2090 |             v0 = stats.rankdata(v00)
2091 |             v100 = np.empty((12, out.shape[0]))
2092 |             for i0 in range(1, 13):
2093 |                 v1000 = low[-i0]
2094 |                 v100[-i0] = stats.rankdata(v1000)
2095 |             v101 = np.empty((12, out.shape[0]))
2096 |             for i0 in range(1, 13):
2097 |                 v1010 = adv50[-i0]
2098 |                 v101[-i0] = stats.rankdata(v1010)
2099 |             v10 = pd.DataFrame(v100).rolling(window=12).cov(pd.DataFrame(v101)).tail(1).as_matrix()[-1]
2100 |             v1 = stats.rankdata(v10)
2101 |             out[:] = v0 < v1
2102 | 
2103 |     #  (rank(correlation(sum(((low * 0.352233) + (vwap * (1 - 0.352233))), 19.7428), sum(adv40, 19.7428), 6.83313))^rank(correlation(rank(vwap), rank(volume), 5.77492)))
2104 |     class Alpha78(CustomFactor):
2105 |         vwap_in = VWAP(window_length=2)
2106 |         vwap_in.window_safe = True
2107 |         adv40_in = AverageDollarVolume(window_length=40)
2108 |         adv40_in.window_safe = True
2109 |         inputs = [USEquityPricing.volume, adv40_in, USEquityPricing.low, vwap_in]
2110 |         window_length = 19
2111 | 
2112 |         def compute(self, today, assets, out, volume, adv40, low, vwap):
2113 |             v000 = np.empty((7, out.shape[0]))
2114 |             for i0 in range(1, 8):
2115 |                 v0000 = np.empty((20, out.shape[0]))
2116 |                 for i1 in range(1, 21):
2117 |                     v000000 = low[-i1]
2118 |                     v000001 = np.full(out.shape[0], 0.352233)
2119 |                     v00000 = v000000 * v000001
2120 |                     v000010 = vwap[-i1]
2121 |                     v0000110 = np.full(out.shape[0], 1.0)
2122 |                     v0000111 = np.full(out.shape[0], 0.352233)
2123 |                     v000011 = v0000110 - v0000111
2124 |                     v00001 = v000010 * v000011
2125 |                     v0000[-i1] = v00000 + v00001
2126 |                 v000[-i0] = v0000.sum(axis=0)
2127 |             v001 = np.empty((7, out.shape[0]))
2128 |             for i0 in range(1, 8):
2129 |                 v0010 = np.empty((20, out.shape[0]))
2130 |                 for i1 in range(1, 21):
2131 |                     v0010[-i1] = adv40[-i1]
2132 |                 v001[-i0] = v0010.sum(axis=0)
2133 |             v00 = pd.DataFrame(v000).rolling(window=7).cov(pd.DataFrame(v001)).tail(1).as_matrix()[-1]
2134 |             v0 = stats.rankdata(v00)
2135 |             v100 = np.empty((6, out.shape[0]))
2136 |             for i0 in range(1, 7):
2137 |                 v1000 = vwap[-i0]
2138 |                 v100[-i0] = stats.rankdata(v1000)
2139 |             v101 = np.empty((6, out.shape[0]))
2140 |             for i0 in range(1, 7):
2141 |                 v1010 = volume[-i0]
2142 |                 v101[-i0] = stats.rankdata(v1010)
2143 |             v10 = pd.DataFrame(v100).rolling(window=6).cov(pd.DataFrame(v101)).tail(1).as_matrix()[-1]
2144 |             v1 = stats.rankdata(v10)
2145 |             out[:] = np.power(v0, v1)
2146 | 
2147 |     #  ((rank(Log(product(rank((rank(correlation(vwap, sum(adv10, 49.6054), 8.47743))^4)), 14.9655))) < rank(correlation(rank(vwap), rank(volume), 5.07914))) * -1)
2148 |     class Alpha81(CustomFactor):
2149 |         vwap_in = VWAP(window_length=2)
2150 |         vwap_in.window_safe = True
2151 |         adv10_in = AverageDollarVolume(window_length=10)
2152 |         adv10_in.window_safe = True
2153 |         inputs = [USEquityPricing.volume, adv10_in, vwap_in]
2154 |         window_length = 49
2155 | 
2156 |         def compute(self, today, assets, out, volume, adv10, vwap):
2157 |             v00000 = np.empty((15, out.shape[0]))
2158 |             for i0 in range(1, 16):
2159 |                 v000000000 = np.empty((8, out.shape[0]))
2160 |                 for i1 in range(1, 9):
2161 |                     v000000000[-i1] = vwap[-i1]
2162 |                 v000000001 = np.empty((8, out.shape[0]))
2163 |                 for i1 in range(1, 9):
2164 |                     v0000000010 = np.empty((50, out.shape[0]))
2165 |                     for i2 in range(1, 51):
2166 |                         v0000000010[-i2] = adv10[-i2]
2167 |                     v000000001[-i1] = v0000000010.sum(axis=0)
2168 |                 v00000000 = pd.DataFrame(v000000000).rolling(window=8).cov(pd.DataFrame(v000000001)).tail(1).as_matrix()[-1]
2169 |                 v0000000 = stats.rankdata(v00000000)
2170 |                 v0000001 = np.full(out.shape[0], 4.0)
2171 |                 v000000 = np.power(v0000000, v0000001)
2172 |                 v00000[-i0] = stats.rankdata(v000000)
2173 |             v0000 = np.prod(v00000, axis=0)
2174 |             v000 = np.log(v0000)
2175 |             v00 = stats.rankdata(v000)
2176 |             v0100 = np.empty((5, out.shape[0]))
2177 |             for i0 in range(1, 6):
2178 |                 v01000 = vwap[-i0]
2179 |                 v0100[-i0] = stats.rankdata(v01000)
2180 |             v0101 = np.empty((5, out.shape[0]))
2181 |             for i0 in range(1, 6):
2182 |                 v01010 = volume[-i0]
2183 |                 v0101[-i0] = stats.rankdata(v01010)
2184 |             v010 = pd.DataFrame(v0100).rolling(window=5).cov(pd.DataFrame(v0101)).tail(1).as_matrix()[-1]
2185 |             v01 = stats.rankdata(v010)
2186 |             v0 = v00 < v01
2187 |             v1 = np.full(out.shape[0], -1.0)
2188 |             out[:] = v0 * v1
2189 | 
2190 |     #  ((rank(delay(((high - low) / (sum(close, 5) / 5)), 2)) * rank(rank(volume))) / (((high - low) / (sum(close, 5) / 5)) / (vwap - close)))
2191 |     class Alpha83(CustomFactor):
2192 |         vwap_in = VWAP(window_length=2)
2193 |         vwap_in.window_safe = True
2194 |         inputs = [USEquityPricing.high, USEquityPricing.close, USEquityPricing.low, vwap_in, USEquityPricing.volume]
2195 |         window_length = 7
2196 | 
2197 |         def compute(self, today, assets, out, high, close, low, vwap, volume):
2198 |             v000000 = high[-1]
2199 |             v000001 = low[-1]
2200 |             v00000 = v000000 - v000001
2201 |             v0000100 = np.empty((5, out.shape[0]))
2202 |             for i0 in range(3, 8):
2203 |                 v0000100[2-i0] = close[-i0]
2204 |             v000010 = v0000100.sum(axis=0)
2205 |             v000011 = np.full(out.shape[0], 5.0)
2206 |             v00001 = v000010 / v000011
2207 |             v0000 = v00000 / v00001
2208 |             v000 = v0000 # delay
2209 |             v00 = stats.rankdata(v000)
2210 |             v0100 = volume[-1]
2211 |             v010 = stats.rankdata(v0100)
2212 |             v01 = stats.rankdata(v010)
2213 |             v0 = v00 * v01
2214 |             v1000 = high[-1]
2215 |             v1001 = low[-1]
2216 |             v100 = v1000 - v1001
2217 |             v10100 = np.empty((5, out.shape[0]))
2218 |             for i0 in range(1, 6):
2219 |                 v10100[-i0] = close[-i0]
2220 |             v1010 = v10100.sum(axis=0)
2221 |             v1011 = np.full(out.shape[0], 5.0)
2222 |             v101 = v1010 / v1011
2223 |             v10 = v100 / v101
2224 |             v110 = vwap[-1]
2225 |             v111 = close[-1]
2226 |             v11 = v110 - v111
2227 |             v1 = v10 / v11
2228 |             out[:] = v0 / v1
2229 | 
2230 |     #  SignedPower(Ts_Rank((vwap - ts_max(vwap, 15.3217)), 20.7127), delta(close, 4.96796))
2231 |     class Alpha84(CustomFactor):
2232 |         vwap_in = VWAP(window_length=2)
2233 |         vwap_in.window_safe = True
2234 |         inputs = [USEquityPricing.close, vwap_in]
2235 |         window_length = 20
2236 | 
2237 |         def compute(self, today, assets, out, close, vwap):
2238 |             v00 = np.empty((21, out.shape[0]))
2239 |             for i0 in range(1, 22):
2240 |                 v000 = vwap[-i0]
2241 |                 v0010 = np.empty((15, out.shape[0]))
2242 |                 for i1 in range(1, 16):
2243 |                     v0010[-i1] = vwap[-i1]
2244 |                 v001 = np.max(v0010, axis=0)
2245 |                 v00[-i0] = v000 - v001
2246 |             v0 = pd.DataFrame(v00).rank().tail(1).as_matrix()[-1]
2247 |             v10 = np.empty((6, out.shape[0]))
2248 |             for i0 in range(1, 7):
2249 |                 v10[-i0] = close[-i0]
2250 |             v1 = v10[-1] - v10[-6]
2251 |             out[:] = np.power(v0, v1)
2252 | 
2253 |     #  (rank(correlation(((high * 0.876703) + (close * (1 - 0.876703))), adv30, 9.61331))^rank(correlation(Ts_Rank(((high + low) / 2), 3.70596), Ts_Rank(volume, 10.1595), 7.11408)))
2254 |     class Alpha85(CustomFactor):
2255 |         adv30_in = AverageDollarVolume(window_length=30)
2256 |         adv30_in.window_safe = True
2257 |         inputs = [USEquityPricing.high, USEquityPricing.close, adv30_in, USEquityPricing.low, USEquityPricing.volume]
2258 |         window_length = 10
2259 | 
2260 |         def compute(self, today, assets, out, high, close, adv30, low, volume):
2261 |             v000 = np.empty((10, out.shape[0]))
2262 |             for i0 in range(1, 11):
2263 |                 v00000 = high[-i0]
2264 |                 v00001 = np.full(out.shape[0], 0.876703)
2265 |                 v0000 = v00000 * v00001
2266 |                 v00010 = close[-i0]
2267 |                 v000110 = np.full(out.shape[0], 1.0)
2268 |                 v000111 = np.full(out.shape[0], 0.876703)
2269 |                 v00011 = v000110 - v000111
2270 |                 v0001 = v00010 * v00011
2271 |                 v000[-i0] = v0000 + v0001
2272 |             v001 = np.empty((10, out.shape[0]))
2273 |             for i0 in range(1, 11):
2274 |                 v001[-i0] = adv30[-i0]
2275 |             v00 = pd.DataFrame(v000).rolling(window=10).cov(pd.DataFrame(v001)).tail(1).as_matrix()[-1]
2276 |             v0 = stats.rankdata(v00)
2277 |             v100 = np.empty((7, out.shape[0]))
2278 |             for i0 in range(1, 8):
2279 |                 v1000 = np.empty((4, out.shape[0]))
2280 |                 for i1 in range(1, 5):
2281 |                     v100000 = high[-i1]
2282 |                     v100001 = low[-i1]
2283 |                     v10000 = v100000 + v100001
2284 |                     v10001 = np.full(out.shape[0], 2.0)
2285 |                     v1000[-i1] = v10000 / v10001
2286 |                 v100[-i0] = pd.DataFrame(v1000).rank().tail(1).as_matrix()[-1]
2287 |             v101 = np.empty((7, out.shape[0]))
2288 |             for i0 in range(1, 8):
2289 |                 v1010 = np.empty((10, out.shape[0]))
2290 |                 for i1 in range(1, 11):
2291 |                     v1010[-i1] = volume[-i1]
2292 |                 v101[-i0] = pd.DataFrame(v1010).rank().tail(1).as_matrix()[-1]
2293 |             v10 = pd.DataFrame(v100).rolling(window=7).cov(pd.DataFrame(v101)).tail(1).as_matrix()[-1]
2294 |             v1 = stats.rankdata(v10)
2295 |             out[:] = np.power(v0, v1)
2296 | 
2297 |     #  ((Ts_Rank(correlation(close, sum(adv20, 14.7444), 6.00049), 20.4195) < rank(((open + close) - (vwap + open)))) * -1)
2298 |     class Alpha86(CustomFactor):
2299 |         vwap_in = VWAP(window_length=2)
2300 |         vwap_in.window_safe = True
2301 |         adv20_in = AverageDollarVolume(window_length=20)
2302 |         adv20_in.window_safe = True
2303 |         inputs = [USEquityPricing.close, adv20_in, vwap_in, USEquityPricing.open]
2304 |         window_length = 20
2305 | 
2306 |         def compute(self, today, assets, out, close, adv20, vwap, open):
2307 |             v000 = np.empty((20, out.shape[0]))
2308 |             for i0 in range(1, 21):
2309 |                 v0000 = np.empty((6, out.shape[0]))
2310 |                 for i1 in range(1, 7):
2311 |                     v0000[-i1] = close[-i1]
2312 |                 v0001 = np.empty((6, out.shape[0]))
2313 |                 for i1 in range(1, 7):
2314 |                     v00010 = np.empty((15, out.shape[0]))
2315 |                     for i2 in range(1, 16):
2316 |                         v00010[-i2] = adv20[-i2]
2317 |                     v0001[-i1] = v00010.sum(axis=0)
2318 |                 v000[-i0] = pd.DataFrame(v0000).rolling(window=6).cov(pd.DataFrame(v0001)).tail(1).as_matrix()[-1]
2319 |             v00 = pd.DataFrame(v000).rank().tail(1).as_matrix()[-1]
2320 |             v01000 = open[-1]
2321 |             v01001 = close[-1]
2322 |             v0100 = v01000 + v01001
2323 |             v01010 = vwap[-1]
2324 |             v01011 = open[-1]
2325 |             v0101 = v01010 + v01011
2326 |             v010 = v0100 - v0101
2327 |             v01 = stats.rankdata(v010)
2328 |             v0 = v00 < v01
2329 |             v1 = np.full(out.shape[0], -1.0)
2330 |             out[:] = v0 * v1
2331 | 
2332 |     #  ((rank((vwap - ts_min(vwap, 11.5783)))^Ts_Rank(correlation(Ts_Rank(vwap, 19.6462), Ts_Rank(adv60, 4.02992), 18.0926), 2.70756)) * -1)
2333 |     class Alpha94(CustomFactor):
2334 |         vwap_in = VWAP(window_length=2)
2335 |         vwap_in.window_safe = True
2336 |         adv60_in = AverageDollarVolume(window_length=60)
2337 |         adv60_in.window_safe = True
2338 |         inputs = [adv60_in, vwap_in]
2339 |         window_length = 19
2340 | 
2341 |         def compute(self, today, assets, out, adv60, vwap):
2342 |             v0000 = vwap[-1]
2343 |             v00010 = np.empty((12, out.shape[0]))
2344 |             for i0 in range(1, 13):
2345 |                 v00010[-i0] = vwap[-i0]
2346 |             v0001 = np.min(v00010, axis=0)
2347 |             v000 = v0000 - v0001
2348 |             v00 = stats.rankdata(v000)
2349 |             v010 = np.empty((3, out.shape[0]))
2350 |             for i0 in range(1, 4):
2351 |                 v0100 = np.empty((18, out.shape[0]))
2352 |                 for i1 in range(1, 19):
2353 |                     v01000 = np.empty((20, out.shape[0]))
2354 |                     for i2 in range(1, 21):
2355 |                         v01000[-i2] = vwap[-i2]
2356 |                     v0100[-i1] = pd.DataFrame(v01000).rank().tail(1).as_matrix()[-1]
2357 |                 v0101 = np.empty((18, out.shape[0]))
2358 |                 for i1 in range(1, 19):
2359 |                     v01010 = np.empty((4, out.shape[0]))
2360 |                     for i2 in range(1, 5):
2361 |                         v01010[-i2] = adv60[-i2]
2362 |                     v0101[-i1] = pd.DataFrame(v01010).rank().tail(1).as_matrix()[-1]
2363 |                 v010[-i0] = pd.DataFrame(v0100).rolling(window=18).cov(pd.DataFrame(v0101)).tail(1).as_matrix()[-1]
2364 |             v01 = pd.DataFrame(v010).rank().tail(1).as_matrix()[-1]
2365 |             v0 = np.power(v00, v01)
2366 |             v1 = np.full(out.shape[0], -1.0)
2367 |             out[:] = v0 * v1
2368 | 
2369 |     #  (rank((open - ts_min(open, 12.4105))) < Ts_Rank((rank(correlation(sum(((high + low) / 2), 19.1351), sum(adv40, 19.1351), 12.8742))^5), 11.7584))
2370 |     class Alpha95(CustomFactor):
2371 |         adv40_in = AverageDollarVolume(window_length=40)
2372 |         adv40_in.window_safe = True
2373 |         inputs = [USEquityPricing.high, adv40_in, USEquityPricing.open, USEquityPricing.low]
2374 |         window_length = 19
2375 | 
2376 |         def compute(self, today, assets, out, high, adv40, open, low):
2377 |             v000 = open[-1]
2378 |             v0010 = np.empty((12, out.shape[0]))
2379 |             for i0 in range(1, 13):
2380 |                 v0010[-i0] = open[-i0]
2381 |             v001 = np.min(v0010, axis=0)
2382 |             v00 = v000 - v001
2383 |             v0 = stats.rankdata(v00)
2384 |             v10 = np.empty((12, out.shape[0]))
2385 |             for i0 in range(1, 13):
2386 |                 v10000 = np.empty((13, out.shape[0]))
2387 |                 for i1 in range(1, 14):
2388 |                     v100000 = np.empty((19, out.shape[0]))
2389 |                     for i2 in range(1, 20):
2390 |                         v10000000 = high[-i2]
2391 |                         v10000001 = low[-i2]
2392 |                         v1000000 = v10000000 + v10000001
2393 |                         v1000001 = np.full(out.shape[0], 2.0)
2394 |                         v100000[-i2] = v1000000 / v1000001
2395 |                     v10000[-i1] = v100000.sum(axis=0)
2396 |                 v10001 = np.empty((13, out.shape[0]))
2397 |                 for i1 in range(1, 14):
2398 |                     v100010 = np.empty((19, out.shape[0]))
2399 |                     for i2 in range(1, 20):
2400 |                         v100010[-i2] = adv40[-i2]
2401 |                     v10001[-i1] = v100010.sum(axis=0)
2402 |                 v1000 = pd.DataFrame(v10000).rolling(window=13).cov(pd.DataFrame(v10001)).tail(1).as_matrix()[-1]
2403 |                 v100 = stats.rankdata(v1000)
2404 |                 v101 = np.full(out.shape[0], 5.0)
2405 |                 v10[-i0] = np.power(v100, v101)
2406 |             v1 = pd.DataFrame(v10).rank().tail(1).as_matrix()[-1]
2407 |             out[:] = v0 < v1
2408 | 
2409 |     #  (rank(decay_linear(correlation(vwap, sum(adv5, 26.4719), 4.58418), 7.18088)) - rank(decay_linear(Ts_Rank(Ts_ArgMin(correlation(rank(open), rank(adv15), 20.8187), 8.62571), 6.95668), 8.07206)))
2410 |     class Alpha98(CustomFactor):
2411 |         vwap_in = VWAP(window_length=2)
2412 |         vwap_in.window_safe = True
2413 |         adv5_in = AverageDollarVolume(window_length=5)
2414 |         adv5_in.window_safe = True
2415 |         adv15_in = AverageDollarVolume(window_length=15)
2416 |         adv15_in.window_safe = True
2417 |         inputs = [adv5_in, adv15_in, USEquityPricing.open, vwap_in]
2418 |         window_length = 26
2419 | 
2420 |         def compute(self, today, assets, out, adv5, adv15, open, vwap):
2421 |             v000 = np.empty((7, out.shape[0]))
2422 |             for i0 in range(1, 8):
2423 |                 v0000 = np.empty((5, out.shape[0]))
2424 |                 for i1 in range(1, 6):
2425 |                     v0000[-i1] = vwap[-i1]
2426 |                 v0001 = np.empty((5, out.shape[0]))
2427 |                 for i1 in range(1, 6):
2428 |                     v00010 = np.empty((26, out.shape[0]))
2429 |                     for i2 in range(1, 27):
2430 |                         v00010[-i2] = adv5[-i2]
2431 |                     v0001[-i1] = v00010.sum(axis=0)
2432 |                 v000[-i0] = pd.DataFrame(v0000).rolling(window=5).cov(pd.DataFrame(v0001)).tail(1).as_matrix()[-1]
2433 |             v00 = (v000 * (np.arange(1.0, 8, 1.0)/28)[:, np.newaxis]).sum(axis=0) # decay_linear
2434 |             v0 = stats.rankdata(v00)
2435 |             v100 = np.empty((8, out.shape[0]))
2436 |             for i0 in range(1, 9):
2437 |                 v1000 = np.empty((7, out.shape[0]))
2438 |                 for i1 in range(1, 8):
2439 |                     v10000 = np.empty((9, out.shape[0]))
2440 |                     for i2 in range(1, 10):
2441 |                         v100000 = np.empty((21, out.shape[0]))
2442 |                         for i3 in range(1, 22):
2443 |                             v1000000 = open[-i3]
2444 |                             v100000[-i3] = stats.rankdata(v1000000)
2445 |                         v100001 = np.empty((21, out.shape[0]))
2446 |                         for i3 in range(1, 22):
2447 |                             v1000010 = adv15[-i3]
2448 |                             v100001[-i3] = stats.rankdata(v1000010)
2449 |                         v10000[-i2] = pd.DataFrame(v100000).rolling(window=21).cov(pd.DataFrame(v100001)).tail(1).as_matrix()[-1]
2450 |                     v1000[-i1] = np.argmin(v10000, axis=0)
2451 |                 v100[-i0] = pd.DataFrame(v1000).rank().tail(1).as_matrix()[-1]
2452 |             v10 = (v100 * (np.arange(1.0, 9, 1.0)/36)[:, np.newaxis]).sum(axis=0) # decay_linear
2453 |             v1 = stats.rankdata(v10)
2454 |             out[:] = v0 - v1
2455 | 
2456 |     #  ((rank(correlation(sum(((high + low) / 2), 19.8975), sum(adv60, 19.8975), 8.8136)) < rank(correlation(low, volume, 6.28259))) * -1)
2457 |     class Alpha99(CustomFactor):
2458 |         adv60_in = AverageDollarVolume(window_length=60)
2459 |         adv60_in.window_safe = True
2460 |         inputs = [USEquityPricing.high, adv60_in, USEquityPricing.low, USEquityPricing.volume]
2461 |         window_length = 19
2462 | 
2463 |         def compute(self, today, assets, out, high, adv60, low, volume):
2464 |             v0000 = np.empty((9, out.shape[0]))
2465 |             for i0 in range(1, 10):
2466 |                 v00000 = np.empty((20, out.shape[0]))
2467 |                 for i1 in range(1, 21):
2468 |                     v0000000 = high[-i1]
2469 |                     v0000001 = low[-i1]
2470 |                     v000000 = v0000000 + v0000001
2471 |                     v000001 = np.full(out.shape[0], 2.0)
2472 |                     v00000[-i1] = v000000 / v000001
2473 |                 v0000[-i0] = v00000.sum(axis=0)
2474 |             v0001 = np.empty((9, out.shape[0]))
2475 |             for i0 in range(1, 10):
2476 |                 v00010 = np.empty((20, out.shape[0]))
2477 |                 for i1 in range(1, 21):
2478 |                     v00010[-i1] = adv60[-i1]
2479 |                 v0001[-i0] = v00010.sum(axis=0)
2480 |             v000 = pd.DataFrame(v0000).rolling(window=9).cov(pd.DataFrame(v0001)).tail(1).as_matrix()[-1]
2481 |             v00 = stats.rankdata(v000)
2482 |             v0100 = np.empty((6, out.shape[0]))
2483 |             for i0 in range(1, 7):
2484 |                 v0100[-i0] = low[-i0]
2485 |             v0101 = np.empty((6, out.shape[0]))
2486 |             for i0 in range(1, 7):
2487 |                 v0101[-i0] = volume[-i0]
2488 |             v010 = pd.DataFrame(v0100).rolling(window=6).cov(pd.DataFrame(v0101)).tail(1).as_matrix()[-1]
2489 |             v01 = stats.rankdata(v010)
2490 |             v0 = v00 < v01
2491 |             v1 = np.full(out.shape[0], -1.0)
2492 |             out[:] = v0 * v1
2493 | 
2494 |     #  ((close - open) / ((high - low) + 0.001))
2495 |     class Alpha101(CustomFactor):
2496 |         inputs = [USEquityPricing.high, USEquityPricing.close, USEquityPricing.open, USEquityPricing.low]
2497 |         window_length = 2
2498 | 
2499 |         def compute(self, today, assets, out, high, close, open, low):
2500 |             v00 = close[-1]
2501 |             v01 = open[-1]
2502 |             v0 = v00 - v01
2503 |             v100 = high[-1]
2504 |             v101 = low[-1]
2505 |             v10 = v100 - v101
2506 |             v11 = np.full(out.shape[0], 0.001)
2507 |             v1 = v10 + v11
2508 |             out[:] = v0 / v1
2509 |         
2510 |         
2511 |         all_factors = {
2512 |         'Alpha1' : Alpha1,
2513 |         'Alpha2' : Alpha2,
2514 |         'Alpha3' : Alpha3,
2515 |         'Alpha4' : Alpha4,
2516 |         'Alpha5' : Alpha5,
2517 |         'Alpha6' : Alpha6,
2518 |         'Alpha7' : Alpha7,
2519 |         'Alpha8' : Alpha8,
2520 |         'Alpha9' : Alpha9,
2521 |         'Alpha10' : Alpha10,
2522 |         'Alpha11' : Alpha11,
2523 |         'Alpha12' : Alpha12,
2524 |         'Alpha13' : Alpha13,
2525 |         'Alpha14' : Alpha14,
2526 |         'Alpha15' : Alpha15,
2527 |         'Alpha16' : Alpha16,
2528 |         'Alpha17' : Alpha17,
2529 |         'Alpha18' : Alpha18,
2530 |         'Alpha19' : Alpha19,
2531 |         'Alpha20' : Alpha20,
2532 |         'Alpha21' : Alpha21,
2533 |         'Alpha22' : Alpha22,
2534 |         'Alpha23' : Alpha23,
2535 |         'Alpha24' : Alpha24,
2536 |         'Alpha25' : Alpha25,
2537 |         'Alpha26' : Alpha26,
2538 |         'Alpha27' : Alpha27,
2539 |         'Alpha28' : Alpha28,
2540 |         'Alpha29' : Alpha29,
2541 |         'Alpha30' : Alpha30,
2542 |         'Alpha31' : Alpha31,
2543 |         'Alpha32' : Alpha32,
2544 |         'Alpha33' : Alpha33,
2545 |         'Alpha34' : Alpha34,
2546 |         'Alpha35' : Alpha35,
2547 |         'Alpha36' : Alpha36,
2548 |         'Alpha37' : Alpha37,
2549 |         'Alpha38' : Alpha38,
2550 |         'Alpha39' : Alpha39,
2551 |         'Alpha40' : Alpha40,
2552 |         'Alpha41' : Alpha41,
2553 |         'Alpha42' : Alpha42,
2554 |         'Alpha43' : Alpha43,
2555 |         'Alpha44' : Alpha44,
2556 |         'Alpha45' : Alpha45,
2557 |         'Alpha46' : Alpha46,
2558 |         'Alpha47' : Alpha47,
2559 |         'Alpha49' : Alpha49,
2560 |         'Alpha50' : Alpha50,
2561 |         'Alpha51' : Alpha51,
2562 |         'Alpha52' : Alpha52,
2563 |         'Alpha53' : Alpha53,
2564 |         'Alpha54' : Alpha54,
2565 |         'Alpha55' : Alpha55,
2566 |         'Alpha56' : Alpha56,
2567 |         'Alpha57' : Alpha57,
2568 |         'Alpha60' : Alpha60,
2569 |         'Alpha61' : Alpha61,
2570 |         'Alpha62' : Alpha62,
2571 |         'Alpha64' : Alpha64,
2572 |         'Alpha65' : Alpha65,
2573 |         'Alpha66' : Alpha66,
2574 |         'Alpha68' : Alpha68,
2575 |         'Alpha72' : Alpha72,
2576 |         'Alpha74' : Alpha74,
2577 |         'Alpha75' : Alpha75,
2578 |         'Alpha78' : Alpha78,
2579 |         'Alpha81' : Alpha81,
2580 |         'Alpha83' : Alpha83,
2581 |         'Alpha84' : Alpha84,
2582 |         'Alpha85' : Alpha85,
2583 |         'Alpha86' : Alpha86,
2584 |         'Alpha94' : Alpha94,
2585 |         'Alpha95' : Alpha95,
2586 |         'Alpha98' : Alpha98,
2587 |         'Alpha99' : Alpha99,
2588 |         'Alpha101' : Alpha101
2589 |     }     
2590 |     
2591 |     return all_factors
2592 | 


--------------------------------------------------------------------------------