
multiply(ts_delta(close, 5), rank(volume))

group_mean(ts_delta(close, 20), 1, bucket(rank(volume), range="0,3,0.4"))

if_else(ts_std_dev(returns, 20) > ts_mean(ts_std_dev(returns, 20), 120), ts_delta(close, 5), ts_delta(close, 60))

ts_corr(ts_delta(close, 5), ts_delta(volume, 5), 20)

multiply(ts_regression(close, ts_step(1), 30, 0, 1), if_else(rank(volume) > 0.7, 1, -1))

group_mean(ts_mean(returns, 10), 1, bucket(rank(volume), range="0,3,0.4"))

if_else(ts_rank(ts_std_dev(returns, 60), 120) > 0.8, ts_delta(close, 10), ts_decay_linear(returns, 60))

ts_std_dev(group_rank(returns, industry), 20)

multiply(ts_mean(ts_zscore(volume, 20), 30), ts_delta(close, 20))

if_else(bucket(rank(volume), range="0,3,0.4") == 0, ts_delta(close, 5), ts_delta(close, 30))

group_mean(ts_delta(close, 10), 1, bucket(rank(volume), range="0,2,0.5"))

divide(ts_delta(close, 20), ts_std_dev(returns, 20))

ts_corr(close, ts_delay(volume, 1), 60)

multiply(ts_regression(close, ts_step(1), 60, 0, 1), ts_zscore(volume, 60))

if_else(ts_std_dev(returns, 20) > 0.015, ts_mean(returns, 5), ts_mean(returns, 30))

group_rank(ts_delta(close, 5), industry)

multiply(ts_delta(volume, 5), ts_corr(close, volume, 10))

if_else(rank(volume) > 0.8, ts_rank(close, 20), reverse(ts_rank(close, 20)))

group_mean(ts_rank(close, 10), 1, sector)

divide(ts_delta(close, 5), ts_mean(abs(returns), 20))

multiply(ts_corr(ts_delta(close, 5), ts_delta(volume, 5), 30), ts_delta(close, 10))

if_else(ts_mean(volume, 20) > ts_mean(volume, 120), ts_delta(close, 5), reverse(ts_delta(close, 5)))

ts_mean(rank(returns), 30)

group_mean(ts_decay_linear(returns, 60), 1, bucket(rank(volume), range="0,3,0.4"))

if_else(ts_std_dev(returns, 60) > 0.025, ts_regression(close, ts_step(1), 10, 0, 1), ts_regression(close, ts_step(1), 60, 0, 1))

multiply(rank(volume), ts_delta(ts_delta(close, 5), 5))

group_neutralize(ts_delta(close, 20), industry)

divide(ts_mean(returns, 20), ts_std_dev(returns, 20))

multiply(ts_corr(close, volume, 20), ts_zscore(close, 20))

if_else(rank(volume) > 0.6, ts_zscore(returns, 10), reverse(ts_zscore(returns, 10)))

group_mean(ts_mean(close, 10), 1, bucket(rank(volume), range="0,2,0.5"))

ts_delta(ts_mean(close, 10), 30)

multiply(ts_zscore(volume, 10), ts_rank(close, 20))

group_rank(rank(returns), industry)

if_else(ts_std_dev(returns, 10) > ts_std_dev(returns, 60), ts_delta(close, 5), ts_delta(close, 30))

divide(ts_corr(close, volume, 10), ts_std_dev(returns, 20))

multiply(ts_rank(volume, 20), ts_mean(returns, 10))

group_mean(ts_zscore(returns, 20), 1, sector)

if_else(ts_rank(volume, 10) > 0.9, ts_mean(returns, 5), ts_mean(returns, 60))

reverse(ts_corr(volume, close, 30))

multiply(ts_delta(close, 60), if_else(rank(volume) > 0.7, 1, 0.5))

group_zscore(ts_delta(close, 10), industry)

divide(ts_regression(close, ts_step(1), 20, 0, 1), ts_std_dev(returns, 20))

ts_mean(ts_zscore(volume, 5), 30)

multiply(if_else(rank(volume) > 0.8, ts_delta(close, 5), ts_delta(close, 20)), ts_zscore(returns, 30))

group_mean(close, 1, bucket(rank(volume), range="0,3,0.3"))

if_else(ts_std_dev(returns, 30) > 0.02, ts_zscore(close, 10), ts_zscore(close, 60))

divide(ts_delta(close, 10), ts_mean(volume, 20))

multiply(ts_rank(ts_mean(returns, 10), 60), rank(volume))

group_rank(ts_corr(close, volume, 20), sector)

if_else(bucket(rank(volume), range="0,1,0.7") == 0, ts_delta(close, 10), ts_delta(close, 60))

ts_regression(close, ts_step(1), 30, 0, 1) / ts_regression(volume, ts_step(1), 30, 0, 1)

multiply(ts_zscore(returns, 20), ts_zscore(volume, 20))

group_mean(ts_rank(volume, 20), 1, bucket(rank(close), range="0,3,0.4"))

if_else(ts_rank(ts_std_dev(returns, 20), 60) > 0.7, ts_delta(close, 5), reverse(ts_delta(close, 5)))

divide(ts_mean(returns, 10), ts_mean(returns, 60))

multiply(ts_corr(ts_delta(close, 10), ts_delta(volume, 10), 20), ts_delta(close, 20))

group_neutralize(ts_regression(close, ts_step(1), 30, 0, 1), sector)

if_else(rank(volume) > 0.5, ts_scale(ts_delta(close, 20)), reverse(ts_scale(ts_delta(close, 20))))

ts_zscore(ts_corr(close, volume, 30), 60)

multiply(ts_delta(volume, 10), ts_rank(close, 60))

group_mean(ts_std_dev(returns, 20), 1, bucket(rank(volume), range="0,3,0.4"))

divide(ts_delta(close, 30), ts_mean(volume, 60))

if_else(ts_rank(volume, 60) > 0.8, ts_mean(returns, 10), reverse(ts_mean(returns, 10)))

multiply(ts_regression(close, ts_step(1), 60, 0, 1), ts_zscore(volume, 10))

group_rank(ts_zscore(returns, 30), industry)

ts_decay_linear(ts_corr(close, volume, 10), 20)

if_else(ts_std_dev(returns, 30) > 0.018, ts_delta(close, 10), ts_delta(close, 120))

multiply(ts_zscore(close, 20), if_else(bucket(rank(volume), range="0,3,0.5") == 0, 1, -1))

group_mean(ts_delta(close, 60), 1, bucket(rank(volume), range="0,2,0.6"))

divide(ts_delta(close, 20), ts_delta(volume, 20))

multiply(ts_corr(ts_zscore(close, 10), ts_zscore(volume, 10), 30), ts_mean(returns, 20))

if_else(rank(volume) > 0.75, ts_rank(close, 10), ts_rank(close, 60))

group_zscore(ts_std_dev(returns, 30), sector)

ts_mean(ts_zscore(returns, 5), 60)

multiply(ts_delta(close, 5), ts_rank(volume, 120))

group_mean(ts_regression(close, ts_step(1), 20, 0, 1), 1, industries)

if_else(ts_mean(abs(returns), 20) > 0.01, ts_rank(close, 5), ts_rank(close, 30))

divide(ts_corr(close, volume, 60), ts_std_dev(returns, 60))

multiply(ts_zscore(volume, 30), ts_delta(close, 30))

group_rank(if_else(rank(volume) > 0.7, 1, 0), industry)

if_else(ts_std_dev(ts_delta(close, 5), 20) > ts_std_dev(ts_delta(close, 20), 20), ts_delta(close, 5), ts_delta(close, 20))

reverse(ts_corr(returns, volume, 30))

multiply(ts_mean(ts_rank(close, 10), 30), ts_mean(ts_rank(volume, 10), 30))

group_mean(ts_zscore(returns, 60), 1, bucket(rank(volume), range="0,3,0.4"))

ts_delta(group_mean(close, 1, industry), 10)

if_else(rank(volume) > 0.6, ts_regression(close, ts_step(1), 10, 0, 1), ts_regression(close, ts_step(1), 60, 0, 1))

divide(ts_mean(close, 20), ts_std_dev(close, 20))

multiply(ts_rank(volume, 10), ts_corr(close, volume, 60))

group_rank(ts_zscore(ts_delta(close, 20)), sector)

if_else(bucket(rank(volume), range="0,1,0.8") == 0, ts_mean(returns, 20), reverse(ts_mean(returns, 20)))

ts_decau_linear(ts_mean(returns, 10), 30)

multiply(ts_zscore(ts_delta(close, 10), 20), ts_zscore(volume, 20))

group_mean(ts_corr(close, volume, 30), 1, industries)

divide(ts_regression(close, ts_step(1), 30, 0, 1), ts_mean(volume, 30))

if_else(ts_rank(volume, 30) > 0.85, ts_zscore(close, 5), ts_zscore(close, 60))

multiply(ts_corr(close, ts_delay(close, 5), 60), rank(volume))

group_rank(ts_mean(close, 60), industry)

if_else(ts_std_dev(returns, 20) > 0.022, ts_delta(close, 20), ts_delta(close, 120))

divide(ts_mean(returns, 5), ts_mean(returns, 20))

multiply(ts_zscore(volume, 20), ts_rank(returns, 20))

group_mean(ts_delta(close, 10), 1, bucket(rank(volume), range="0,3,0.3"))

ts_corr(ts_zscore(close, 20), ts_zscore(volume, 20), 60)

if_else(rank(volume) > 0.65, ts_scale(close), reverse(ts_scale(close)))

multiply(ts_delta(ts_delta(close, 5), 10), ts_delta(volume, 20))

group_rank(rank(volume), industry)

divide(ts_corr(close, volume, 10), ts_mean(abs(returns), 20))

multiply(ts_mean(ts_rank(volume, 10), 20), ts_delta(close, 10))

group_neutralize(ts_decay_linear(returns, 30), sector)

if_else(ts_rank(ts_std_dev(returns, 30), 60) > 0.75, ts_rank(close, 10), ts_rank(close, 30))

ts_mean(ts_zscore(volume, 20), 60)

multiply(ts_delta(close, 60), if_else(rank(volume) > 0.55, 1, -1))

group_mean(ts_regression(close, ts_step(1), 40, 0, 1), 1, industries)

if_else(ts_mean(ts_std_dev(returns, 20), 60) > 0.02, ts_delta(close, 5), ts_delta(close, 60))

divide(ts_delta(volume, 10), ts_std_dev(returns, 10))

multiply(ts_zscore(returns, 30), ts_corr(close, volume, 40))

group_zscore(ts_delta(close, 30), industry)

ts_rank(ts_corr(close, volume, 20), 60)

multiply(ts_decay_linear(returns, 20), ts_zscore(volume, 30))

group_mean(ts_std_dev(returns, 60), 1, bucket(rank(volume), range="0,3,0.4"))

if_else(rank(volume) > 0.9, ts_delta(close, 10), ts_delta(close, 120))

divide(ts_regression(close, ts_step(1), 20, 0, 1), ts_regression(volume, ts_step(1), 20, 0, 1))

multiply(ts_corr(ts_delta(close, 20), ts_delta(volume, 20), 30), ts_mean(returns, 30))

group_rank(ts_zscore(volume, 60), sector)