You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
884 lines
27 KiB
884 lines
27 KiB
group_neutralize(ts_sum(if_else(implied_volatility_mean_10 > implied_volatility_mean_20, returns, -returns), 5), sector)
|
|
|
|
group_neutralize(ts_delta(log(volume), 10) * ts_rank(close, 20), sector)
|
|
|
|
group_neutralize(ts_corr(returns, scl12_sentiment, 30) * ts_std_dev(returns, 60), sector)
|
|
|
|
if_else(volume > ts_mean(volume, 30), ts_rank(returns, 10), -ts_rank(returns, 10))
|
|
|
|
ts_sum(if_else(ts_rank(close, 5) > ts_rank(close, 20), ts_delta(close, 1), -ts_delta(close, 1)), 10)
|
|
|
|
group_neutralize(ts_rank(ts_corr(vwap, volume, 20), 5), sector)
|
|
|
|
ts_av_diff(implied_volatility_mean_180, 30) * ts_zscore(returns, 60)
|
|
|
|
group_neutralize(ts_rank(pcr_oi_30, 10) * ts_delta(close, 5), sector)
|
|
|
|
ts_sum(signed_power(ts_delta(log(close), 2), sign(ts_delta(volume, 2))), 5)
|
|
|
|
scale(ts_rank(close, 10) - ts_rank(vwap, 10))
|
|
|
|
if_else(ts_std_dev(returns, 30) > ts_mean(ts_std_dev(returns, 5), 30), ts_rank(close, 5), ts_rank(-close, 5))
|
|
|
|
group_neutralize(ts_rank(ts_delta(close, 2), 10) * ts_sum(volume, 5), sector)
|
|
|
|
ts_delta(ts_corr(close, volume, 10), 5) * ts_scale(close, 20)
|
|
|
|
group_neutralize(ts_rank(fscore_momentum, 60) * ts_zscore(returns, 30), sector)
|
|
|
|
ts_sum(if_else(ts_rank(close, 20) > ts_rank(vwap, 20), log(volume), -log(volume)), 15)
|
|
|
|
if_else(historical_volatility_60 > ts_mean(historical_volatility_60, 60), ts_rank(returns, 10), ts_rank(-returns, 10))
|
|
|
|
ts_regression(returns, ts_delta(scl12_sentiment, 1), 30, 0, 0)
|
|
|
|
group_neutralize(ts_sum(signed_power(ts_delta(close, 1), sign(ts_delta(pcr_vol_10, 1))), 5), sector)
|
|
|
|
ts_av_diff(implied_volatility_mean_skew_30, 20) * ts_zscore(close, 50)
|
|
|
|
if_else(ts_mean(volume, 10) > ts_mean(volume, 30), ts_rank(close, 5), -ts_rank(close, 10))
|
|
|
|
group_neutralize(ts_rank(ts_corr(fscore_value, returns, 40), 10), sector)
|
|
|
|
ts_sum(if_else(ts_delta(log(volume), 5) > 0, ts_delta(close, 1), -ts_delta(close, 1)), 8)
|
|
|
|
ts_corr(ts_rank(close, 5), ts_rank(volume, 20), 10)
|
|
|
|
group_neutralize(ts_rank(ts_delta(vwap, 3), 15) * ts_std_dev(returns, 20), sector)
|
|
|
|
if_else(pcr_oi_90 > ts_mean(pcr_oi_90, 30), ts_rank(returns, 10), -ts_rank(returns, 10))
|
|
|
|
ts_av_diff(fscore_growth, 20) * ts_zscore(ts_delta(close, 2), 40)
|
|
|
|
group_neutralize(ts_rank(ts_corr(implied_volatility_call_30, returns, 30), 10), sector)
|
|
|
|
ts_sum(signed_power(ts_delta(vwap, 1), sign(ts_delta(fscore_profitability, 5))), 10)
|
|
|
|
scale(ts_rank(ts_sum(returns, 5), 20) - ts_rank(ts_sum(volume, 5), 20))
|
|
|
|
if_else(beta_last_30_days_spy > ts_mean(beta_last_30_days_spy, 60), ts_rank(close, 5), ts_rank(-close, 10))
|
|
|
|
group_neutralize(ts_rank(ts_delta(fscore_quality, 10), 20) * ts_zscore(returns, 30), sector)
|
|
|
|
ts_delta(ts_corr(close, parkinson_volatility_30, 20), 5) * ts_scale(close, 15)
|
|
|
|
group_neutralize(ts_rank(rp_css_earnings, 40) * ts_delta(close, 3), sector)
|
|
|
|
ts_sum(if_else(ts_rank(close, 15) > ts_rank(volume, 15), ts_delta(close, 1), -ts_delta(close, 1)), 10)
|
|
|
|
if_else(implied_volatility_mean_360 > ts_mean(implied_volatility_mean_360, 90), ts_rank(returns, 15), ts_rank(-returns, 15))
|
|
|
|
ts_regression(returns, ts_delta(rp_nip_price, 1), 25, 0, 0)
|
|
|
|
group_neutralize(ts_sum(signed_power(ts_delta(close, 1), sign(ts_delta(call_breakeven_30, 1))), 5), sector)
|
|
|
|
ts_av_diff(implied_volatility_mean_skew_120, 30) * ts_zscore(returns, 50)
|
|
|
|
if_else(ts_mean(adv20, 10) > ts_mean(adv20, 30), ts_rank(close, 8), -ts_rank(close, 12))
|
|
|
|
group_neutralize(ts_rank(ts_corr(forward_price_60, returns, 35), 10), sector)
|
|
|
|
ts_sum(if_else(ts_delta(log(adv20), 5) > 0, ts_delta(close, 1), -ts_delta(close, 1)), 12)
|
|
|
|
ts_corr(ts_rank(vwap, 8), ts_rank(pcr_vol_20, 25), 15)
|
|
|
|
group_neutralize(ts_rank(ts_delta(put_breakeven_30, 5), 20) * ts_std_dev(returns, 25), sector)
|
|
|
|
if_else(pcr_vol_30 > ts_mean(pcr_vol_30, 30), ts_rank(returns, 10), -ts_rank(returns, 10))
|
|
|
|
ts_av_diff(fscore_total, 25) * ts_zscore(ts_delta(close, 3), 60)
|
|
|
|
group_neutralize(ts_rank(ts_corr(implied_volatility_call_90, returns, 40), 10), sector)
|
|
|
|
ts_sum(signed_power(ts_delta(close, 2), sign(ts_delta(fscore_surface_accel, 7))), 8)
|
|
|
|
scale(ts_rank(ts_sum(returns, 7), 25) - ts_rank(ts_sum(adv20, 7), 25))
|
|
|
|
if_else(beta_last_90_days_spy > ts_mean(beta_last_90_days_spy, 90), ts_rank(close, 10), ts_rank(-close, 15))
|
|
|
|
group_neutralize(ts_rank(ts_delta(systematic_risk_last_30_days, 15), 30) * ts_zscore(returns, 40), sector)
|
|
|
|
ts_delta(ts_corr(close, nws18_nip, 25), 7) * ts_scale(close, 20)
|
|
|
|
group_neutralize(ts_rank(rp_css_ptg, 50) * ts_delta(close, 4), sector)
|
|
|
|
ts_sum(if_else(ts_rank(vwap, 20) > ts_rank(adv20, 20), ts_delta(close, 1), -ts_delta(close, 1)), 15)
|
|
|
|
if_else(implied_volatility_mean_720 > ts_mean(implied_volatility_mean_720, 120), ts_rank(returns, 20), ts_rank(-returns, 20))
|
|
|
|
ts_regression(returns, ts_delta(scl12_buzz, 1), 20, 0, 0)
|
|
|
|
group_neutralize(ts_sum(signed_power(ts_delta(close, 1), sign(ts_delta(option_breakeven_90, 1))), 6), sector)
|
|
|
|
ts_av_diff(implied_volatility_mean_skew_10, 15) * ts_zscore(returns, 30)
|
|
|
|
if_else(ts_mean(volume, 15) > ts_mean(volume, 45), ts_rank(close, 10), -ts_rank(close, 20))
|
|
|
|
group_neutralize(ts_rank(ts_corr(forward_price_180, returns, 45), 10), sector)
|
|
|
|
ts_sum(if_else(ts_delta(log(volume), 7) > 0, ts_delta(close, 2), -ts_delta(close, 2)), 10)
|
|
|
|
ts_corr(ts_rank(close, 10), ts_rank(pcr_oi_120, 30), 20)
|
|
|
|
group_neutralize(ts_rank(ts_delta(call_breakeven_180, 7), 25) * ts_std_dev(returns, 30), sector)
|
|
|
|
if_else(pcr_vol_270 > ts_mean(pcr_vol_270, 30), ts_rank(returns, 12), -ts_rank(returns, 12))
|
|
|
|
ts_av_diff(fscore_surface, 30) * ts_zscore(ts_delta(close, 4), 70)
|
|
|
|
group_neutralize(ts_rank(ts_corr(implied_volatility_call_270, returns, 50), 10), sector)
|
|
|
|
ts_sum(signed_power(ts_delta(vwap, 2), sign(ts_delta(fscore_momentum, 10))), 12)
|
|
|
|
scale(ts_rank(ts_sum(returns, 10), 30) - ts_rank(ts_sum(pcr_oi_20, 10), 30))
|
|
|
|
if_else(unsystematic_risk_last_60_days > ts_mean(unsystematic_risk_last_60_days, 120), ts_rank(close, 12), ts_rank(-close, 18))
|
|
|
|
group_neutralize(ts_rank(ts_delta(beta_last_60_days_spy, 20), 35) * ts_zscore(returns, 45), sector)
|
|
|
|
ts_delta(ts_corr(close, rp_ess_price, 30), 10) * ts_scale(close, 25)
|
|
|
|
group_neutralize(ts_rank(rp_css_dividends, 60) * ts_delta(close, 5), sector)
|
|
|
|
ts_sum(if_else(ts_rank(close, 25) > ts_rank(volume, 25), ts_delta(close, 2), -ts_delta(close, 2)), 20)
|
|
|
|
if_else(parkinson_volatility_90 > ts_mean(parkinson_volatility_90, 60), ts_rank(returns, 15), ts_rank(-returns, 15))
|
|
|
|
ts_regression(returns, ts_delta(fscore_profitability, 2), 35, 0, 0)
|
|
|
|
group_neutralize(ts_sum(signed_power(ts_delta(close, 1), sign(ts_delta(put_breakeven_270, 1))), 7), sector)
|
|
|
|
ts_av_diff(implied_volatility_mean_150, 40) * ts_zscore(returns, 60)
|
|
|
|
if_else(ts_mean(adv20, 20) > ts_mean(adv20, 60), ts_rank(close, 15), -ts_rank(close, 25))
|
|
|
|
group_neutralize(ts_rank(ts_corr(forward_price_720, returns, 60), 10), sector)
|
|
|
|
ts_sum(if_else(ts_delta(log(adv20), 10) > 0, ts_delta(close, 3), -ts_delta(close, 3)), 15)
|
|
|
|
ts_corr(ts_rank(vwap, 12), ts_rank(pcr_vol_360, 40), 25)
|
|
|
|
group_neutralize(ts_rank(ts_delta(option_breakeven_720, 10), 30) * ts_std_dev(returns, 35), sector)
|
|
|
|
if_else(pcr_oi_270 > ts_mean(pcr_oi_270, 30), ts_rank(returns, 15), -ts_rank(returns, 15))
|
|
|
|
ts_av_diff(fscore_bfl_surface_accel, 35) * ts_zscore(ts_delta(close, 5), 80)
|
|
|
|
group_neutralize(ts_rank(ts_corr(implied_volatility_call_1080, returns, 70), 10), sector)
|
|
|
|
ts_sum(signed_power(ts_delta(close, 3), sign(ts_delta(analyst_revision_rank_derivative, 15))), 15)
|
|
|
|
scale(ts_rank(ts_sum(returns, 12), 35) - ts_rank(ts_sum(pcr_oi_90, 12), 35))
|
|
|
|
if_else(correlation_last_90_days_spy > ts_mean(correlation_last_90_days_spy, 180), ts_rank(close, 15), ts_rank(-close, 22))
|
|
|
|
group_neutralize(ts_rank(ts_delta(systematic_risk_last_90_days, 25), 40) * ts_zscore(returns, 50), sector)
|
|
|
|
ts_delta(ts_corr(close, nws18_acb, 35), 12) * ts_scale(close, 30)
|
|
|
|
group_neutralize(ts_rank(rp_css_assets, 70) * ts_delta(close, 6), sector)
|
|
|
|
ts_sum(if_else(ts_rank(vwap, 30) > ts_rank(volume, 30), ts_delta(close, 3), -ts_delta(close, 3)), 25)
|
|
|
|
if_else(historical_volatility_150 > ts_mean(historical_volatility_150, 90), ts_rank(returns, 18), ts_rank(-returns, 18))
|
|
|
|
ts_regression(returns, ts_delta(fscore_growth, 3), 40, 0, 0)
|
|
|
|
group_neutralize(ts_sum(signed_power(ts_delta(close, 2), sign(ts_delta(call_breakeven_270, 2))), 8), sector)
|
|
|
|
ts_av_diff(implied_volatility_mean_360, 50) * ts_zscore(returns, 70)
|
|
|
|
if_else(ts_mean(volume, 25) > ts_mean(volume, 75), ts_rank(close, 20), -ts_rank(close, 30))
|
|
|
|
group_neutralize(ts_rank(ts_corr(forward_price_120, returns, 80), 10), sector)
|
|
|
|
ts_sum(if_else(ts_delta(log(volume), 12) > 0, ts_delta(close, 4), -ts_delta(close, 4)), 20)
|
|
|
|
ts_corr(ts_rank(close, 15), ts_rank(pcr_oi_720, 50), 30)
|
|
|
|
group_neutralize(ts_rank(ts_delta(put_breakeven_150, 12), 35) * ts_std_dev(returns, 40), sector)
|
|
|
|
if_else(pcr_vol_30 > 1, ts_rank(returns, 18), -ts_rank(returns, 18))
|
|
|
|
ts_av_diff(fscore_bfl_total, 40) * ts_zscore(ts_delta(close, 6), 90)
|
|
|
|
|
|
ts_rank(volume, 20) * ts_rank(returns, 20)
|
|
|
|
ts_delta(volume, 5) / ts_mean(volume, 20)
|
|
|
|
log(volume) * ts_rank(close, 10)
|
|
|
|
ts_rank(adv20, 60) - ts_rank(returns, 60)
|
|
|
|
ts_corr(volume, returns, 20)
|
|
|
|
ts_rank(multiply(volume, returns), 20)
|
|
|
|
sign(ts_delta(volume, 10)) * (-1 * ts_rank(returns, 10))
|
|
|
|
ts_rank(low, 5) - ts_rank(volume, 5)
|
|
|
|
ts_mean(volume, 5) / ts_mean(volume, 60)
|
|
|
|
rank(volume) - rank(returns)
|
|
|
|
ts_delta(log(volume), 5)
|
|
|
|
multiply(ts_rank(volume, 20), ts_delta(close, 20))
|
|
|
|
ts_mean(returns, 20) * ts_std_dev(volume, 20)
|
|
|
|
divide(ts_sum(volume, 5), ts_sum(volume, 20))
|
|
|
|
ts_rank(close, 20) / ts_rank(volume, 20)
|
|
|
|
ts_corr(ts_delta(close, 1), ts_delta(volume, 1), 5)
|
|
|
|
rank(ts_delta(close, 5)) * rank(volume)
|
|
|
|
ts_mean(divide(ts_delta(high, 1), close), 10) * rank(volume)
|
|
|
|
multiply(rank(volume), rank(close))
|
|
|
|
ts_rank(volume, 10) * ts_std_dev(returns, 10)
|
|
|
|
ts_zscore(volume, 60) * ts_rank(returns, 20)
|
|
|
|
ts_mean(rank(volume), 10) * sign(ts_delta(close, 10))
|
|
|
|
ts_delta(rank(volume), 20) * rank(returns)
|
|
|
|
inverse(rank(volume)) * ts_rank(returns, 5)
|
|
|
|
ts_mean(ts_delta(close, 1), 10) * rank(volume)
|
|
|
|
multiply(sign(ts_delta(close, 10)), ts_rank(volume, 20))
|
|
|
|
ts_coeff(returns, ts_mean(volume, 20), 10)
|
|
|
|
divide(ts_rank(volume, 10), ts_rank(volume, 60))
|
|
|
|
rank(multiply(volume, returns))
|
|
|
|
ts_mean(volume, 3) - ts_mean(volume, 20)
|
|
|
|
multiply(ts_rank(volume, 20), ts_rank(ts_delta(close, 20), 20))
|
|
|
|
ts_corr(rank(volume), rank(close), 20)
|
|
|
|
ts_mean(returns, 20) / ts_mean(volume, 20)
|
|
|
|
ts_rank(volume, 20) - ts_rank(volume, 60)
|
|
|
|
rank(volume) * rank(ts_delta(close, 10))
|
|
|
|
multiply(ts_rank(volume, 20), ts_corr(close, volume, 20))
|
|
|
|
divide(ts_sum(volume, 20), cap)
|
|
|
|
ts_mean(returns, 20) * ts_mean(volume, 20)
|
|
|
|
rank(returns) - rank(volume)
|
|
|
|
ts_delta(log(volume), 10) * rank(returns)
|
|
|
|
ts_mean(rank(volume), 20) * rank(close)
|
|
|
|
multiply(ts_std_dev(returns, 20), ts_std_dev(volume, 20))
|
|
|
|
ts_rank(volume, 20) * ts_mean(ts_delta(close, 1), 10)
|
|
|
|
divide(ts_mean(volume, 20), adv20)
|
|
|
|
rank(volume) + rank(returns)
|
|
|
|
ts_delta(volume, 20) * ts_std_dev(returns, 20)
|
|
|
|
multiply(rank(close), rank(volume))
|
|
|
|
ts_rank(returns, 20) / ts_rank(volume, 20)
|
|
|
|
ts_mean(ts_corr(close, volume, 10), 20)
|
|
|
|
ts_rank(volume, 20) * ts_rank(ts_delta(close, 5), 10)
|
|
|
|
rank(multiply(returns, volume))
|
|
|
|
ts_mean(returns, 20) * rank(volume)
|
|
|
|
ts_rank(volume, 60) - ts_rank(returns, 20)
|
|
|
|
multiply(ts_rank(volume, 20), ts_mean(ts_delta(close, 1), 5))
|
|
|
|
ts_corr(rank(volume), rank(returns), 20)
|
|
|
|
divide(ts_delta(volume, 10), ts_mean(volume, 60))
|
|
|
|
rank(volume) * rank(ts_delta(close, 20))
|
|
|
|
multiply(ts_std_dev(volume, 20), ts_rank(returns, 20))
|
|
|
|
ts_mean(rank(volume), 20) * rank(returns)
|
|
|
|
ts_rank(volume, 20) - ts_rank(close, 20)
|
|
|
|
rank(volume) * ts_std_dev(returns, 20)
|
|
|
|
ts_rank(multiply(volume, ts_delta(close, 10)), 20)
|
|
|
|
ts_mean(returns, 20) / rank(volume)
|
|
|
|
multiply(ts_rank(volume, 20), ts_corr(ts_delta(close, 1), ts_delta(volume, 1), 20))
|
|
|
|
divide(ts_sum(volume, 20), ts_sum(volume, 60))
|
|
|
|
rank(volume) * rank(returns) * -1
|
|
|
|
ts_delta(volume, 20) * ts_rank(close, 20)
|
|
|
|
ts_mean(rank(volume), 20) - rank(close)
|
|
|
|
multiply(ts_corr(close, volume, 20), ts_rank(returns, 20))
|
|
|
|
divide(ts_std_dev(volume, 20), ts_mean(volume, 20))
|
|
|
|
ts_rank(volume, 20) * ts_zscore(returns, 20)
|
|
|
|
multiply(rank(volume), rank(ts_delta(close, 5)))
|
|
|
|
ts_mean(ts_corr(close, volume, 10), 20) * rank(returns)
|
|
|
|
ts_rank(volume, 60) / ts_rank(close, 20)
|
|
|
|
(rank(volume) > rank(returns)) * (-1)
|
|
|
|
ts_delta(volume, 10) * ts_corr(close, volume, 20)
|
|
|
|
divide(ts_mean(volume, 10), adv20) * -1
|
|
|
|
multiply(rank(volume), rank(ts_delta(close, 20)))
|
|
|
|
ts_std_dev(returns, 20) * ts_rank(volume, 20)
|
|
|
|
rank(volume) - rank(close) * -1
|
|
|
|
multiply(ts_mean(ts_delta(close, 1), 10), rank(volume))
|
|
|
|
ts_corr(rank(returns), rank(volume), 20)
|
|
|
|
ts_rank(volume, 20) * ts_mean(rank(close), 20)
|
|
|
|
divide(ts_sum(volume, 10), ts_sum(volume, 20))
|
|
|
|
rank(volume) * rank(ts_delta(close, 10)) * -1
|
|
|
|
ts_delta(volume, 20) * ts_mean(returns, 20)
|
|
|
|
multiply(rank(volume), rank(returns))
|
|
|
|
ts_rank(volume, 20) * ts_rank(ts_delta(close, 20), 20) * -1
|
|
|
|
divide(ts_std_dev(volume, 20), ts_std_dev(returns, 20))
|
|
|
|
rank(volume) + rank(ts_delta(close, 20))
|
|
|
|
multiply(ts_corr(close, volume, 20), rank(volume))
|
|
|
|
ts_mean(returns, 20) * ts_mean(rank(volume), 20)
|
|
|
|
ts_rank(volume, 20) - ts_delta(close, 20)
|
|
|
|
rank(volume) * ts_zscore(returns, 20)
|
|
|
|
multiply(ts_rank(volume, 20), ts_corr(rank(close), rank(volume), 20))
|
|
|
|
divide(ts_delta(volume, 20), ts_mean(volume, 20))
|
|
|
|
rank(volume) * ts_rank(returns, 20) * -1
|
|
|
|
ts_delta(volume, 10) * ts_mean(ts_delta(close, 1), 10)
|
|
|
|
multiply(rank(volume), rank(ts_delta(close, 20))) * -1
|
|
|
|
ts_std_dev(returns, 20) / ts_std_dev(volume, 20)
|
|
|
|
rank(ts_delta(close, 5) / ts_std_dev(close, 30), 2) * sign(ts_delta(close, 10))
|
|
|
|
scale(ts_mean(volume, 20) / ts_mean(volume, 60), 1) - ts_delta(cap, 21) / cap
|
|
|
|
rank(ts_corr(ts_delta(close, 1), volume, 20), 2) * (ts_mean(close, 5) > ts_mean(close, 20))
|
|
|
|
ts_zscore(close, 30) * (1 - ts_count_nans(close, 5))
|
|
|
|
ts_decay_linear(close, 20) * (ts_mean(volume, 10) > ts_mean(volume, 40))
|
|
|
|
(ts_mean(close, 10) - ts_mean(close, 40)) / ts_std_dev(close, 90) * (volume > ts_mean(volume, 20))
|
|
|
|
rank(ts_arg_max(close, 30), 2) * -sign(ts_delta(close, 5))
|
|
|
|
(ts_delay(close, 5) - ts_delay(close, 20)) / ts_delay(close, 20) * ts_mean(volume, 10)
|
|
|
|
rank(ts_corr(returns, ts_mean(returns, 10), 20), 2) * (ts_std_dev(returns, 10) < 0.02)
|
|
|
|
ts_scale(ts_delta(close, 1), 1) * (ts_mean(volume, 5) > ts_mean(volume, 25))
|
|
|
|
(ts_delta(close, 5) / ts_std_dev(close, 30)) * ts_decay_linear(volume, 20)
|
|
|
|
rank(ts_backfill(fclose, 20, 1), 2) * sign(ts_delta(close, 1))
|
|
|
|
(ts_mean(close, 60) - ts_mean(close, 120)) / ts_std_dev(close, 180) * (ts_mean(volume, 60) > ts_mean(volume, 120))
|
|
|
|
(1 - ts_rank(close, 20)) * (ts_delay(close, 1) < ts_mean(close, 30))
|
|
|
|
ts_delta(ts_mean(close, 10), 30) * ts_std_dev(returns, 10)
|
|
|
|
rank(ts_delta(close, 10), 2) * (volume > ts_mean(volume, 20))
|
|
|
|
(ts_delay(close, 30) - ts_delay(close, 90)) / ts_delay(close, 90) * ts_std_dev(volume, 10)
|
|
|
|
ts_zscore(ts_delta(close, 5), 10) * (ts_mean(close, 5) < ts_mean(close, 20))
|
|
|
|
rank(ts_corr(close, ts_mean(close, 20), 60), 2) * ts_delay(volume, 1)
|
|
|
|
(ts_mean(close, 20) < ts_mean(close, 100)) * (ts_delta(close, 5) > 0.02)
|
|
|
|
rank(ts_delay(close, 5), 2) * (ts_delta(close, 15) / ts_std_dev(close, 30))
|
|
|
|
scale(ts_delta(volume, 10), 1) * (ts_corr(close, ts_mean(close, 30), 20) < 0.5)
|
|
|
|
ts_decay_linear(ts_delta(close, 1), 20) * (ts_rank(volume, 10) > 0.8)
|
|
|
|
rank(ts_corr(ts_delay(close, 5), ts_delay(close, 20), 30), 2) * (ts_std_dev(returns, 5) > 0.03)
|
|
|
|
(ts_delta(close, 20) / ts_std_dev(close, 60)) * (ts_mean(volume, 20) < ts_mean(volume, 100))
|
|
|
|
(1 - ts_rank(close, 30)) * (ts_delta(close, 10) < -0.01)
|
|
|
|
rank(ts_delta(ts_mean(high, 5), 10), 2) * (volume > ts_mean(volume, 20))
|
|
|
|
ts_zscore(ts_delta(ts_mean(close, 5), 20), 60) * (ts_rank(volume, 20) > 0.7)
|
|
|
|
(ts_corr(close, ts_mean(close, 10), 30) < 0.3) * ts_delta(close, 20)
|
|
|
|
rank(ts_backfill(close, 10, 1), 2) * sign(ts_delta(close, 5))
|
|
|
|
(ts_mean(high, 10) - ts_mean(low, 10)) / ts_mean(close, 10) * ts_volume(10)
|
|
|
|
rank(ts_arg_min(close, 30), 2) * (ts_delta(close, 5) < 0)
|
|
|
|
(ts_delta(close, 5) / ts_delay(close, 5)) * ts_decay_linear(volume, 20)
|
|
|
|
rank(ts_corr(returns, volume, 20), 2) * (ts_std_dev(returns, 20) > 0.025)
|
|
|
|
(ts_delay(close, 20) - ts_delay(close, 60)) / ts_delay(close, 60) * ts_mean(volume, 20)
|
|
|
|
ts_zscore(ts_delta(ts_mean(close, 20), 60), 90) * (ts_rank(close, 30) < 0.3)
|
|
|
|
(ts_delta(close, 10) > 0.02) * (ts_mean(volume, 5) / ts_mean(volume, 60) > 1.5)
|
|
|
|
rank(ts_corr(ts_delay(close, 10), ts_delay(close, 40), 60), 2) * (ts_std_dev(volume, 10) > 0.01)
|
|
|
|
ts_scale(ts_delta(close, 20), 1) * (ts_mean(close, 20) < ts_mean(close, 100))
|
|
|
|
(1 - ts_rank(close, 60)) * (ts_delta(close, 15) > 0)
|
|
|
|
ts_delta(ts_mean(close, 30), 90) * ts_std_dev(returns, 30)
|
|
|
|
rank(ts_arg_max(close, 90), 2) * sign(ts_delta(close, 10))
|
|
|
|
(ts_delay(close, 10) - ts_delay(close, 30)) / ts_delay(close, 30) * ts_mean(volume, 10)
|
|
|
|
ts_zscore(ts_delta(ts_mean(close, 10), 30), 60) * (ts_rank(volume, 30) > 0.8)
|
|
|
|
(ts_corr(close, ts_mean(close, 60), 120) < 0.4) * ts_delta(close, 30)
|
|
|
|
rank(ts_backfill(close, 30, 1), 2) * sign(ts_delta(close, 10))
|
|
|
|
(ts_mean(high, 20) - ts_mean(low, 20)) / ts_mean(close, 20) * ts_volume(20)
|
|
|
|
rank(ts_arg_min(close, 60), 2) * (ts_delta(close, 5) < 0)
|
|
|
|
(ts_delta(close, 5) / ts_delay(close, 5)) * ts_decay_linear(volume, 30)
|
|
|
|
rank(ts_corr(returns, volume, 30), 2) * (ts_std_dev(returns, 30) > 0.03)
|
|
|
|
(ts_delay(close, 30) - ts_delay(close, 90)) / ts_delay(close, 90) * ts_mean(volume, 30)
|
|
|
|
ts_zscore(ts_delta(ts_mean(close, 60), 120), 180) * (ts_rank(close, 60) < 0.2)
|
|
|
|
(ts_delta(close, 20) > 0.02) * (ts_mean(volume, 10) / ts_mean(volume, 120) > 1.5)
|
|
|
|
rank(ts_corr(ts_delay(close, 20), ts_delay(close, 80), 120), 2) * (ts_std_dev(volume, 20) > 0.02)
|
|
|
|
ts_scale(ts_delta(close, 40), 1) * (ts_mean(close, 40) < ts_mean(close, 160))
|
|
|
|
(1 - ts_rank(close, 90)) * (ts_delta(close, 30) > 0)
|
|
|
|
ts_delta(ts_mean(close, 60), 180) * ts_std_dev(returns, 60)
|
|
|
|
rank(ts_arg_max(close, 180), 2) * sign(ts_delta(close, 20))
|
|
|
|
(ts_delay(close, 20) - ts_delay(close, 60)) / ts_delay(close, 60) * ts_mean(volume, 20)
|
|
|
|
ts_zscore(ts_delta(ts_mean(close, 20), 60), 120) * (ts_rank(volume, 60) > 0.7)
|
|
|
|
(ts_corr(close, ts_mean(close, 120), 250) < 0.5) * ts_delta(close, 60)
|
|
|
|
rank(ts_backfill(close, 60, 1), 2) * sign(ts_delta(close, 20))
|
|
|
|
(ts_mean(high, 60) - ts_mean(low, 60)) / ts_mean(close, 60) * ts_volume(60)
|
|
|
|
rank(ts_arg_min(close, 120), 2) * (ts_delta(close, 10) < 0)
|
|
|
|
(ts_delta(close, 10) / ts_delay(close, 10)) * ts_decay_linear(volume, 60)
|
|
|
|
rank(ts_corr(returns, volume, 60), 2) * (ts_std_dev(returns, 60) > 0.04)
|
|
|
|
(ts_delay(close, 60) - ts_delay(close, 180)) / ts_delay(close, 180) * ts_mean(volume, 60)
|
|
|
|
ts_zscore(ts_delta(ts_mean(close, 120), 360), 720) * (ts_rank(close, 120) < 0.1)
|
|
|
|
(ts_delta(close, 30) > 0.03) * (ts_mean(volume, 20) / ts_mean(volume, 240) > 2.0)
|
|
|
|
rank(ts_corr(ts_delay(close, 30), ts_delay(close, 120), 180), 2) * (ts_std_dev(volume, 30) > 0.03)
|
|
|
|
ts_scale(ts_delta(close, 80), 1) * (ts_mean(close, 80) < ts_mean(close, 320))
|
|
|
|
(1 - ts_rank(close, 180)) * (ts_delta(close, 90) > 0)
|
|
|
|
ts_delta(ts_mean(close, 120), 360) * ts_std_dev(returns, 120)
|
|
|
|
rank(ts_arg_max(close, 360), 2) * sign(ts_delta(close, 30))
|
|
|
|
(ts_delay(close, 30) - ts_delay(close, 90)) / ts_delay(close, 90) * ts_mean(volume, 30)
|
|
|
|
ts_zscore(ts_delta(ts_mean(close, 40), 120), 240) * (ts_rank(volume, 120) > 0.75)
|
|
|
|
(ts_corr(close, ts_mean(close, 240), 500) < 0.6) * ts_delta(close, 90)
|
|
|
|
rank(ts_backfill(close, 90, 1), 2) * sign(ts_delta(close, 30))
|
|
|
|
(ts_mean(high, 120) - ts_mean(low, 120)) / ts_mean(close, 120) * ts_volume(120)
|
|
|
|
rank(ts_arg_min(close, 240), 2) * (ts_delta(close, 20) < 0)
|
|
|
|
(ts_delta(close, 20) / ts_delay(close, 20)) * ts_decay_linear(volume, 120)
|
|
|
|
rank(ts_corr(returns, volume, 120), 2) * (ts_std_dev(returns, 120) > 0.05)
|
|
|
|
(ts_delay(close, 120) - ts_delay(close, 360)) / ts_delay(close, 360) * ts_mean(volume, 120)
|
|
|
|
ts_zscore(ts_delta(ts_mean(close, 240), 720), 1440) * (ts_rank(close, 240) < 0.05)
|
|
|
|
(ts_delta(close, 60) > 0.04) * (ts_mean(volume, 40) / ts_mean(volume, 480) > 2.5)
|
|
|
|
rank(ts_corr(ts_delay(close, 60), ts_delay(close, 240), 360), 2) * (ts_std_dev(volume, 60) > 0.04)
|
|
|
|
ts_scale(ts_delta(close, 160), 1) * (ts_mean(close, 160) < ts_mean(close, 640))
|
|
|
|
(1 - ts_rank(close, 360)) * (ts_delta(close, 180) > 0)
|
|
|
|
ts_delta(ts_mean(close, 180), 540) * ts_std_dev(returns, 180)
|
|
|
|
rank(ts_arg_max(close, 540), 2) * sign(ts_delta(close, 60))
|
|
|
|
(ts_delay(close, 60) - ts_delay(close, 180)) / ts_delay(close, 180) * ts_mean(volume, 60)
|
|
|
|
ts_zscore(ts_delta(ts_mean(close, 60), 180), 360) * (ts_rank(volume, 180) > 0.8)
|
|
|
|
(ts_corr(close, ts_mean(close, 360), 720) < 0.7) * ts_delta(close, 180)
|
|
|
|
rank(ts_backfill(close, 180, 1), 2) * sign(ts_delta(close, 60))
|
|
|
|
(ts_mean(high, 180) - ts_mean(low, 180)) / ts_mean(close, 180) * ts_volume(180)
|
|
|
|
rank(ts_arg_min(close, 360), 2) * (ts_delta(close, 40) < 0)
|
|
|
|
(ts_delta(close, 40) / ts_delay(close, 40)) * ts_decay_linear(volume, 180)
|
|
|
|
rank(ts_corr(returns, volume, 180), 2) * (ts_std_dev(returns, 180) > 0.06)
|
|
|
|
(ts_delay(close, 180) - ts_delay(close, 540)) / ts_delay(close, 540) * ts_mean(volume, 180)
|
|
|
|
ts_zscore(ts_delta(ts_mean(close, 360), 1080), 2160) * (ts_rank(close, 360) < 0.03)
|
|
|
|
(ts_delta(close, 90) > 0.05) * (ts_mean(volume, 60) / ts_mean(volume, 720) > 3.0)
|
|
|
|
rank(ts_corr(ts_delay(close, 90), ts_delay(close, 360), 540), 2) * (ts_std_dev(volume, 90) > 0.05)
|
|
|
|
ts_scale(ts_delta(close, 240), 1) * (ts_mean(close, 240) < ts_mean(close, 960))
|
|
|
|
(1 - ts_rank(close, 540)) * (ts_delta(close, 270) > 0)
|
|
|
|
ts_delta(ts_mean(close, 270), 810) * ts_std_dev(returns, 270)
|
|
|
|
rank(ts_arg_max(close, 810), 2) * sign(ts_delta(close, 90))
|
|
|
|
(ts_delay(close, 90) - ts_delay(close, 270)) / ts_delay(close, 270) * ts_mean(volume, 90)
|
|
|
|
ts_zscore(ts_delta(ts_mean(close, 90), 270), 540) * (ts_rank(volume, 270) > 0.85)
|
|
|
|
(ts_corr(close, ts_mean(close, 540), 1080) < 0.75) * ts_delta(close
|
|
|
|
|
|
|
|
add(returns, ts_delay(returns,1))
|
|
|
|
multiply(returns, inverse(volume))
|
|
|
|
divide(multiply(returns, vwap), cap)
|
|
|
|
group_zscore(returns, sector)
|
|
|
|
ts_mean(multiply(returns, volume),5)
|
|
|
|
if_else(volume > ts_mean(volume,30), 1, 0)
|
|
|
|
scale(returns,1,0)
|
|
|
|
winsorize(returns)
|
|
|
|
add(zscore(returns), zscore(adv20))
|
|
|
|
multiply(zscore(returns), ts_mean(returns,20))
|
|
|
|
group_neutralize(returns, sector)
|
|
|
|
group_backfill(returns, sector,30)
|
|
|
|
divide(returns, beta_last_30_days_spy)
|
|
|
|
multiply(returns, fscore_surface)
|
|
|
|
ts_corr(close, adv20,20)
|
|
|
|
add(ts_delay(returns,1), ts_delay(returns,2))
|
|
|
|
multiply( adv20, 0.01 )
|
|
|
|
subtract( ts_mean(returns,20), multiply(adv20,0.001))
|
|
|
|
add(zscore(adv20), zscore(volume))
|
|
|
|
ts_zscore(multiply(returns, volume),60)
|
|
|
|
if_else( snt_value > 0.7, -1, 1 ) * returns
|
|
|
|
divide( nws12_allz_result1, close )
|
|
|
|
ts_delay( snt_value, 1) * returns
|
|
|
|
add( normalize(returns), group_neutralize(beta_last_30_days_spy, sector) )
|
|
|
|
multiply( group_zscore(fscore_momentum, sector), returns )
|
|
|
|
group_zscore(fscore_surface, sector)
|
|
|
|
group_zscore(fscore_value, sector)
|
|
|
|
scale( fscore_value, 1, 0 )
|
|
|
|
ts_corr( close, snt_value,30 )
|
|
|
|
multiply( snt_value, ts_delay(returns,5) )
|
|
|
|
add( ts_delay(snt_value,1), ts_delay(snt_value,2) )
|
|
|
|
divide( call_breakeven_20, put_breakeven_20 )
|
|
|
|
ts_mean( divide( call_breakeven_30, put_breakeven_30 ),10)
|
|
|
|
if_else( pcr_vol_20 > 1.2, 1, -1 ) * returns
|
|
|
|
multiply( pcr_oi_60, returns )
|
|
|
|
group_zscore( pcr_oi_60, sector )
|
|
|
|
add( zscore( pcr_oi_60 ), zscore( adv20 ) )
|
|
|
|
ts_delay( pcr_oi_60,1) * returns
|
|
|
|
group_mean( sales, pv13_revere_company )
|
|
|
|
divide( group_mean(sales, pv13_revere_company), group_mean(market_cap, pv13_revere_company) )
|
|
|
|
multiply( fscore_surface, fscore_momentum )
|
|
|
|
if_else( fscore_surface > 50, 1, 0 ) * returns
|
|
|
|
normalize( fscore_surface )
|
|
|
|
ts_rank( fscore_surface,60 )
|
|
|
|
ts_delay( fscore_surface,30 )
|
|
|
|
multiply( ts_delay(returns,10), ts_rank( fscore_bfl_total,60 ) )
|
|
|
|
add( ts_delay(fscore_total,30), returns )
|
|
|
|
divide( fscore_value, fscore_growth )
|
|
|
|
group_scale(adv20, sector)
|
|
|
|
multiply( group_zscore(adv20, sector), returns )
|
|
|
|
ts_corr( adv20, snt_value,60 )
|
|
|
|
ts_covariance( adv20, returns,60 )
|
|
|
|
add( returns, multiply( adv20, 0.001 ) )
|
|
|
|
add( multiply(returns, volume), ts_delay(returns,1) )
|
|
|
|
multiply( adv20, beta_last_30_days_spy )
|
|
|
|
group_zscore( beta_last_30_days_spy, sector )
|
|
|
|
scale(div ide(returns, adv20),1,0 )
|
|
|
|
winsorize(multiply(returns, volume))
|
|
|
|
if_else( volume > adv20 * 2, 1, -1 ) * returns
|
|
|
|
add( snt_value, ts_delay(snt_value,1) )
|
|
|
|
scale( snt_social_volume, 1, 0 )
|
|
|
|
if_else( is_nan(close), group_mean(close, sector ), close )
|
|
|
|
group_backfill(close, sector,30)
|
|
|
|
ad d( ts_mean(returns,5), ts_mean(returns,10) )
|
|
|
|
add( ts_mean(returns,5), ts_mean(returns,10) )
|
|
|
|
scale(returns, longscale=1, shortscale=1 )
|
|
|
|
winsorize(group_zscore(returns, pv13_revere_key_sector))
|
|
|
|
ts_delay( volume,1 )
|
|
|
|
ts_mean( volume,10 )
|
|
|
|
if_else( ts_std_dev(returns,30) > 0.15, ts_delta(close,5), ts_delta(close,30))
|
|
|
|
divide( fscore_bfl_tota, fscore_bfl_value )
|
|
|
|
add( normalize(returns), group_neutralize(beta_last_30_days_spy, sector) )
|
|
|
|
multiply( group_zscore(returns, pv13_revere_company ), returns )
|
|
|
|
add( ts_delta(close, 5), ts_delta(close,10) )
|
|
|
|
multiply( snt_social_volume, 10 )
|
|
|
|
normalize( snt_social_value )
|
|
|
|
scale( snt_social_value, 1, 0 )
|
|
|
|
if_else( nws12_prez_02l > 0, 1, -1 ) * returns
|
|
|
|
ts_corr( close, volume,20 )
|
|
|
|
add( zscore(adv20), zscore(volume) )
|
|
|
|
group_mean( fscore_surface, pv13_revere_company )
|
|
|
|
divide( group_mean(sales, pv13_revere_company), group_mean(market_cap, pv13_revere_company) )
|
|
|
|
multiply( group_zscore(returns, pv13_revere_company), fscore_surface )
|
|
|
|
if_else( group_zscore(fscore_surface, sector) > 0.5, 1, -1 ) * returns
|
|
|
|
ts_mean( divide( group_mean(sales, pv13_revere_company), group_mean(market_cap, pv13_revere_company) ),5)
|
|
|
|
add( normalize( fscore_surface ), normalize( fscore_momentum ) )
|
|
|
|
multiply( snt_value, ts_delay(returns,1) )
|
|
|
|
add( ts_delay(snt_value,1), ts_delay(snt_value,2) )
|
|
|
|
if_else( pcr_oi_60 > 0.5, 1, -1) * returns
|
|
|
|
ts_delay( pcr_oi_60,1) * returns
|
|
|
|
divide( call_breakeven_10, put_breakeven_10 )
|
|
|
|
ts_mean( divide( call_breakeven_30, put_breakeven_30 ),10)
|
|
|
|
group_zscore( volume, pv13_revere_key_sector )
|
|
|
|
multiply( group_zscore(returns, sector), volume )
|
|
|
|
if_else( adv20 < 100000, 1, 0 ) * returns
|
|
|
|
add( zscore( adv20 ), zscore( fscore_surface ) )
|
|
|
|
multiply( ts_delta(close,5), ts_std_dev(returns,60) )
|
|
|
|
winsorize(group_scale(returns, sector))
|
|
|
|
divide( market_cap, ts_mean(market_cap,90) )
|
|
|
|
scale( divide(returns, market_cap), 1,0 )
|
|
|
|
group_backfill(returns, pv13_revere_company,30)
|
|
|
|
add( returns, multiply( beta_last_30_days_spy, 0.05 ) )
|
|
|
|
multiply( group_zscore(fscore_surface, pv13_revere_sector), group_zscore(returns, pv13_revere_sector) )
|
|
|
|
if_else( ts_mean(returns,10) > 0, 1, -1 ) * snt_value
|
|
|
|
add( normalize( returns ), normalize( group_zscore(returns, pv13_revere_company) ) )
|
|
|
|
multiply( adv20, ts_delta(volume,5) )
|
|
|
|
ts_corr( close, adv20,30 )
|
|
|
|
add( ts_delay(close,5), multiply( adv20, 0.001 ) )
|
|
|
|
scale( snt_value, 1, 0 )
|
|
|
|
multiply( snt_value, 10 )
|
|
|
|
if_else( snt_value > 0.6, zscore(returns), 0 )
|
|
|
|
divide( nws12_prez_02l, close )
|
|
|
|
ts_delay( nws12_allz_result1,1) * returns
|
|
|
|
group_mean( fscore_surface, sector )
|
|
|
|
divide( group_mean(eps_estimate, pv13_revere_company), group_mean(earnings_actual, pv13_revere_company) )
|
|
|
|
add( normalize( fscore_surface ), normalize( fscore_momentum ) )
|
|
|
|
multiply( fscore_surface, ts_delay(returns,5) )
|
|
|
|
ts_corr( fscore_surface, close,30 )
|
|
|
|
add( ts_delay(returns,1), ts_delay(returns,2) )
|
|
|
|
multiply( snt_value, ts_delay(returns,5) )
|
|
|
|
add( ts_delay(snt_value,1), ts_delay(snt_value,2) )
|
|
|
|
scale( group_zscore(returns, sector), 1, 0 )
|
|
|
|
if_else( snt_value > 0.5, -ts_delta(close,5), ts_delta(close,5) )
|
|
|
|
ts_mean( divide( group_mean(eps_estimate, pv13_revere_company), group_mean(earnings_actual, pv13_revere_company) ),20)
|
|
|
|
add( normalize( bffl_surface ), normalize( fscore_momentum ) )
|
|
|
|
multiply( group_zscore(returns, pv13_revere_company), multiplier( adv20, 0.01 ) )
|
|
|
|
scale( snt_social_volume, 1, 0 )
|
|
|
|
divide( call_breakeven_60, put_breakeven_60 )
|
|
|
|
ts_scale( divide(returns, adv20), 30,1 )
|
|
|
|
if_else( group_zscore(returns, sector) < 0.2, 1, 0 ) |