101 Formulaic Alphas - 完全ガイド

import numpy as np
import pandas as pd
from scipy import stats

# 基本関数
def rank(x):
    """クロスセクショナルランク（0から1の範囲に正規化）"""
    return x.rank(pct=True)

def delay(x, d):
    """d日前の値を返す"""
    return x.shift(d)

def correlation(x, y, d):
    """過去d日間の時系列相関"""
    return x.rolling(d).corr(y)

def covariance(x, y, d):
    """過去d日間の時系列共分散"""
    return x.rolling(d).cov(y)

def scale(x, a=1):
    """xの絶対値の合計がaになるようにスケール"""
    return a * x / x.abs().sum()

def delta(x, d):
    """今日の値からd日前の値を引く"""
    return x - delay(x, d)

def signedpower(x, a):
    """符号付きべき乗"""
    return np.sign(x) * (np.abs(x) ** a)

def decay_linear(x, d):
    """線形減衰加重移動平均"""
    weights = np.arange(d, 0, -1)
    weights = weights / weights.sum()
    return x.rolling(d).apply(lambda y: np.sum(y * weights))

def ts_min(x, d):
    """過去d日間の最小値"""
    return x.rolling(d).min()

def ts_max(x, d):
    """過去d日間の最大値"""
    return x.rolling(d).max()

def ts_argmax(x, d):
    """過去d日間で最大値が発生した日数"""
    return x.rolling(d).apply(lambda y: d - np.argmax(y))

def ts_argmin(x, d):
    """過去d日間で最小値が発生した日数"""
    return x.rolling(d).apply(lambda y: d - np.argmin(y))

def ts_rank(x, d):
    """過去d日間での時系列ランク"""
    return x.rolling(d).rank(pct=True)

def sum(x, d):
    """過去d日間の合計"""
    return x.rolling(d).sum()

def product(x, d):
    """過去d日間の積"""
    return x.rolling(d).apply(np.prod)

def stddev(x, d):
    """過去d日間の標準偏差"""
    return x.rolling(d).std()

IF リターン < 0 THEN
    power = (20日標準偏差)^2
ELSE
    power = (終値)^2
過去5日間でpowerが最大となった日を特定
そのランクから0.5を引く

def alpha001(close, returns):
    condition = returns < 0
    power = np.where(condition, stddev(returns, 20), close) ** 2
    return rank(ts_argmax(power, 5)) - 0.5

volume_change = log(出来高) - log(2日前の出来高)
price_gap = (終値 - 始値) / 始値
6日間相関(rank(volume_change), rank(price_gap)) × -1

def alpha002(open, close, volume):
    volume_delta = delta(np.log(volume), 2)
    price_gap_ratio = (close - open) / open
    return -1 * correlation(rank(volume_delta), rank(price_gap_ratio), 6)

10日間相関(rank(始値), rank(出来高)) × -1

def alpha003(open, volume):
    return -1 * correlation(rank(open), rank(volume), 10)

過去9日間での安値の時系列ランク × -1

def alpha004(low):
    return -1 * ts_rank(rank(low), 9)

open_deviation = 始値 - (10日間VWAPの平均)
vwap_distance = |rank(終値 - VWAP)|
rank(open_deviation) × (-1 × vwap_distance)

def alpha005(open, close, vwap):
    vwap_ma10 = sum(vwap, 10) / 10
    return rank(open - vwap_ma10) * (-1 * np.abs(rank(close - vwap)))

10日間相関(始値, 出来高) × -1

def alpha006(open, volume):
    return -1 * correlation(open, volume, 10)

IF 20日平均出来高 < 出来高 THEN
    60日間時系列ランク(|7日間価格変化|) × 価格変化の符号 × -1
ELSE
    -1

def alpha007(close, volume, adv20):
    price_delta = delta(close, 7)
    condition = adv20 < volume
    return np.where(condition, 
                   -1 * ts_rank(np.abs(price_delta), 60) * np.sign(price_delta),
                   -1)

momentum = (5日間始値合計 × 5日間リターン合計)
rank(momentum - 10日前のmomentum) × -1

def alpha008(open, returns):
    momentum = sum(open, 5) * sum(returns, 5)
    return -1 * rank(momentum - delay(momentum, 10))

IF 過去5日間の最小価格変化 > 0 THEN
    価格変化
ELIF 過去5日間の最大価格変化 < 0 THEN
    価格変化
ELSE
    -1 × 価格変化

def alpha009(close):
    price_delta = delta(close, 1)
    min_delta = ts_min(price_delta, 5)
    max_delta = ts_max(price_delta, 5)
    
    return np.where(min_delta > 0, price_delta,
                   np.where(max_delta < 0, price_delta, -1 * price_delta))

Alpha#9と同じロジックの結果をrank()する

def alpha010(close):
    price_delta = delta(close, 1)
    min_delta = ts_min(price_delta, 4)
    max_delta = ts_max(price_delta, 4)
    
    result = np.where(min_delta > 0, price_delta,
                     np.where(max_delta < 0, price_delta, -1 * price_delta))
    return rank(result)

vwap_diff = VWAP - 終値
extremes = rank(3日間最大値(vwap_diff)) + rank(3日間最小値(vwap_diff))
extremes × rank(3日間出来高変化)

def alpha011(close, vwap, volume):
    vwap_diff = vwap - close
    return (rank(ts_max(vwap_diff, 3)) + rank(ts_min(vwap_diff, 3))) * rank(delta(volume, 3))

sign(1日出来高変化) × (-1 × 1日価格変化)

def alpha012(close, volume):
    return np.sign(delta(volume, 1)) * (-1 * delta(close, 1))

rank(5日間共分散(rank(終値), rank(出来高))) × -1

def alpha013(close, volume):
    return -1 * rank(covariance(rank(close), rank(volume), 5))

(-1 × rank(3日間リターン変化)) × 10日間相関(始値, 出来高)

def alpha014(open, volume, returns):
    return (-1 * rank(delta(returns, 3))) * correlation(open, volume, 10)

3日間合計(rank(3日間相関(rank(高値), rank(出来高)))) × -1

def alpha015(high, volume):
    corr = correlation(rank(high), rank(volume), 3)
    return -1 * sum(rank(corr), 3)

rank(5日間共分散(rank(高値), rank(出来高))) × -1

def alpha016(high, volume):
    return -1 * rank(covariance(rank(high), rank(volume), 5))

price_trend = -1 × rank(10日間時系列ランク(終値))
price_acceleration = rank(価格変化の変化)
volume_ratio = rank(5日間時系列ランク(出来高/20日平均出来高))
price_trend × price_acceleration × volume_ratio

def alpha017(close, volume, adv20):
    price_trend = -1 * rank(ts_rank(close, 10))
    price_acceleration = rank(delta(delta(close, 1), 1))
    volume_ratio = rank(ts_rank(volume / adv20, 5))
    return price_trend * price_acceleration * volume_ratio

intraday_volatility = 5日間標準偏差(|終値 - 始値|)
directional_move = 終値 - 始値
correlation_term = 10日間相関(終値, 始値)
rank(intraday_volatility + directional_move + correlation_term) × -1

def alpha018(open, close):
    intraday_vol = stddev(np.abs(close - open), 5)
    directional = close - open
    corr = correlation(close, open, 10)
    return -1 * rank(intraday_vol + directional + corr)

direction = -1 × sign((終値 - 7日前終値) + 7日間価格変化)
long_term_return = 1 + rank(1 + 250日間リターン合計)
direction × long_term_return

def alpha019(close, returns):
    price_change = close - delay(close, 7)
    delta_7d = delta(close, 7)
    direction = -1 * np.sign(price_change + delta_7d)
    long_term = 1 + rank(1 + sum(returns, 250))
    return direction * long_term

gap_high = -1 × rank(始値 - 前日高値)
gap_close = rank(始値 - 前日終値)
gap_low = rank(始値 - 前日安値)
gap_high × gap_close × gap_low

def alpha020(open, high, low, close):
    gap_high = -1 * rank(open - delay(high, 1))
    gap_close = rank(open - delay(close, 1))
    gap_low = rank(open - delay(low, 1))
    return gap_high * gap_close * gap_low

ma8 = 8日間平均(終値)
std8 = 8日間標準偏差(終値)
ma2 = 2日間平均(終値)

IF (ma8 + std8) < ma2 THEN
    -1
ELIF ma2 < (ma8 - std8) THEN
    1
ELIF 出来高 >= 20日平均出来高 THEN
    1
ELSE
    -1

def alpha021(close, volume, adv20):
    ma8 = sum(close, 8) / 8
    std8 = stddev(close, 8)
    ma2 = sum(close, 2) / 2
    
    upper_band = ma8 + std8
    lower_band = ma8 - std8
    
    return np.where(upper_band < ma2, -1,
                   np.where(ma2 < lower_band, 1,
                           np.where(volume >= adv20, 1, -1)))

correlation_change = 5日間変化(5日間相関(高値, 出来高))
volatility_rank = rank(20日間標準偏差(終値))
-1 × correlation_change × volatility_rank

def alpha022(high, close, volume):
    corr = correlation(high, volume, 5)
    corr_change = delta(corr, 5)
    vol_rank = rank(stddev(close, 20))
    return -1 * corr_change * vol_rank

IF 20日間平均(高値) < 高値 THEN
    -1 × 2日間価格変化
ELSE
    0

def alpha023(high):
    ma20_high = sum(high, 20) / 20
    condition = ma20_high < high
    return np.where(condition, -1 * delta(high, 2), 0)

trend = 100日間価格変化率
IF trend <= 0.05 THEN
    -1 × (終値 - 100日間最小値)
ELSE
    -1 × 3日間価格変化

def alpha024(close):
    ma100 = sum(close, 100) / 100
    trend = delta(ma100, 100) / delay(close, 100)
    min100 = ts_min(close, 100)
    
    return np.where(trend <= 0.05,
                   -1 * (close - min100),
                   -1 * delta(close, 3))

rank((-1 × リターン) × 20日平均出来高 × VWAP × (高値 - 終値))

def alpha025(high, close, vwap, returns, adv20):
    return rank((-1 * returns) * adv20 * vwap * (high - close))

correlation = 5日間相関(5日時系列ランク(出来高), 5日時系列ランク(高値))
-1 × 3日間最大値(correlation)

def alpha026(high, volume):
    vol_rank = ts_rank(volume, 5)
    high_rank = ts_rank(high, 5)
    corr = correlation(vol_rank, high_rank, 5)
    return -1 * ts_max(corr, 3)

avg_corr = 2日間平均(6日間相関(rank(出来高), rank(VWAP)))
IF rank(avg_corr) > 0.5 THEN -1 ELSE 1

def alpha027(volume, vwap):
    corr = correlation(rank(volume), rank(vwap), 6)
    avg_corr = sum(corr, 2) / 2
    return np.where(rank(avg_corr) > 0.5, -1, 1)

liquidity_corr = 5日間相関(20日平均出来高, 安値)
mid_price = (高値 + 安値) / 2
scale((liquidity_corr + mid_price) - 終値)

def alpha028(high, low, close, adv20):
    liquidity_corr = correlation(adv20, low, 5)
    mid_price = (high + low) / 2
    return scale(liquidity_corr + mid_price - close)

[複雑な数式のため、直接実装を参照]

def alpha029(close, returns):
    inner_rank = -1 * rank(delta(close - 1, 5))
    double_rank = rank(rank(inner_rank))
    ts_min_result = ts_min(double_rank, 2)
    scaled = scale(np.log(sum(ts_min_result, 1)))
    ranked_scaled = rank(rank(scaled))
    product_term = np.minimum(product(ranked_scaled, 1), 5)
    delay_term = ts_rank(delay(-1 * returns, 6), 5)
    return product_term + delay_term

sign1 = sign(終値 - 前日終値)
sign2 = sign(前日終値 - 2日前終値)
sign3 = sign(2日前終値 - 3日前終値)
consistency = 1 - rank(sign1 + sign2 + sign3)
(consistency × 5日間出来高) / 20日間出来高

def alpha030(close, volume):
    sign1 = np.sign(close - delay(close, 1))
    sign2 = np.sign(delay(close, 1) - delay(close, 2))
    sign3 = np.sign(delay(close, 2) - delay(close, 3))
    consistency = 1 - rank(sign1 + sign2 + sign3)
    return (consistency * sum(volume, 5)) / sum(volume, 20)

decay_term = rank(rank(rank(10日減衰線形(-1 × rank(rank(10日価格変化))))))
delta_term = rank(-1 × 3日価格変化)
correlation_term = sign(scale(12日相関(20日平均出来高, 安値)))
decay_term + delta_term + correlation_term

def alpha031(close, low, adv20):
    price_change = delta(close, 10)
    inner = -1 * rank(rank(price_change))
    decay = decay_linear(inner, 10)
    decay_ranked = rank(rank(rank(decay)))
    
    delta_term = rank(-1 * delta(close, 3))
    corr_term = np.sign(scale(correlation(adv20, low, 12)))
    
    return decay_ranked + delta_term + corr_term

mean_reversion = scale((7日平均価格 - 終値))
vwap_correlation = 20 × scale(230日相関(VWAP, 5日前終値))
mean_reversion + vwap_correlation

def alpha032(close, vwap):
    ma7 = sum(close, 7) / 7
    mean_reversion = scale(ma7 - close)
    vwap_corr = scale(correlation(vwap, delay(close, 5), 230))
    return mean_reversion + 20 * vwap_corr

rank(-1 × ((1 - 始値/終値)^1))

def alpha033(open, close):
    return rank(-1 * ((1 - open/close) ** 1))

vol_ratio = 1 - rank(2日標準偏差 / 5日標準偏差)
price_term = 1 - rank(1日価格変化)
rank(vol_ratio + price_term)

def alpha034(close, returns):
    vol_ratio = 1 - rank(stddev(returns, 2) / stddev(returns, 5))
    price_term = 1 - rank(delta(close, 1))
    return rank(vol_ratio + price_term)

volume_rank = 32日時系列ランク(出来高)
range_rank = 1 - 16日時系列ランク((終値 + 高値) - 安値)
return_rank = 1 - 32日時系列ランク(リターン)
volume_rank × range_rank × return_rank

def alpha035(high, low, close, volume, returns):
    vol_rank = ts_rank(volume, 32)
    range_rank = 1 - ts_rank((close + high) - low, 16)
    ret_rank = 1 - ts_rank(returns, 32)
    return vol_rank * range_rank * ret_rank

term1 = 2.21 × rank(15日相関(終値-始値, 前日出来高))
term2 = 0.7 × rank(始値 - 終値)
term3 = 0.73 × rank(5日時系列ランク(6日前の負リターン))
term4 = rank(|6日相関(VWAP, 20日平均出来高)|)
term5 = 0.6 × rank((200日平均価格 - 始値) × (終値 - 始値))
term1 + term2 + term3 + term4 + term5

def alpha036(open, close, volume, vwap, returns, adv20):
    term1 = 2.21 * rank(correlation(close - open, delay(volume, 1), 15))
    term2 = 0.7 * rank(open - close)
    term3 = 0.73 * rank(ts_rank(delay(-1 * returns, 6), 5))
    term4 = rank(np.abs(correlation(vwap, adv20, 6)))
    term5 = 0.6 * rank(((sum(close, 200) / 200) - open) * (close - open))
    return term1 + term2 + term3 + term4 + term5

correlation_term = rank(200日相関(前日(始値-終値), 終値))
gap_term = rank(始値 - 終値)
correlation_term + gap_term

def alpha037(open, close):
    prev_gap = delay(open - close, 1)
    corr_term = rank(correlation(prev_gap, close, 200))
    gap_term = rank(open - close)
    return corr_term + gap_term

trend = -1 × rank(10日時系列ランク(終値))
ratio = rank(終値 / 始値)
trend × ratio

def alpha038(open, close):
    trend = -1 * rank(ts_rank(close, 10))
    ratio = rank(close / open)
    return trend * ratio

volume_decay = 1 - rank(9日減衰線形(出来高/20日平均出来高))
price_term = -1 × rank(7日価格変化 × volume_decay)
momentum_term = 1 + rank(250日リターン合計)
price_term × momentum_term

def alpha039(close, volume, returns, adv20):
    vol_ratio = volume / adv20
    vol_decay = 1 - rank(decay_linear(vol_ratio, 9))
    price_change = delta(close, 7)
    price_term = -1 * rank(price_change * vol_decay)
    momentum = 1 + rank(sum(returns, 250))
    return price_term * momentum

volatility = -1 × rank(10日標準偏差(高値))
correlation = 10日相関(高値, 出来高)
volatility × correlation

def alpha040(high, volume):
    vol = -1 * rank(stddev(high, 10))
    corr = correlation(high, volume, 10)
    return vol * corr

geometric_mean = sqrt(高値 × 安値)
geometric_mean - VWAP

def alpha041(high, low, vwap):
    geometric_mean = np.sqrt(high * low)
    return geometric_mean - vwap

rank(VWAP - 終値) / rank(VWAP + 終値)

def alpha042(close, vwap):
    return rank(vwap - close) / rank(vwap + close)

volume_rank = 20日時系列ランク(出来高/20日平均出来高)
price_trend = 8日時系列ランク(-1 × 7日価格変化)
volume_rank × price_trend

def alpha043(close, volume, adv20):
    vol_ratio = volume / adv20
    vol_rank = ts_rank(vol_ratio, 20)
    price_change = -1 * delta(close, 7)
    price_rank = ts_rank(price_change, 8)
    return vol_rank * price_rank

-1 × 5日相関(高値, rank(出来高))

def alpha044(high, volume):
    return -1 * correlation(high, rank(volume), 5)

ma_rank = rank(20日平均(5日前終値))
pv_corr = 2日相関(終値, 出来高)
time_corr = rank(2日相関(5日合計価格, 20日合計価格))
-1 × (ma_rank × pv_corr × time_corr)

def alpha045(close, volume):
    delayed_close = delay(close, 5)
    ma20 = sum(delayed_close, 20) / 20
    ma_rank = rank(ma20)
    pv_corr = correlation(close, volume, 2)
    
    sum5 = sum(close, 5)
    sum20 = sum(close, 20)
    time_corr = rank(correlation(sum5, sum20, 2))
    
    return -1 * (ma_rank * pv_corr * time_corr)

trend1 = (20日前価格 - 10日前価格) / 10
trend2 = (10日前価格 - 現在価格) / 10
acceleration = trend1 - trend2

IF acceleration > 0.25 THEN
    -1
ELIF acceleration < 0 THEN
    1
ELSE
    -1 × 1日価格変化

def alpha046(close):
    close_20 = delay(close, 20)
    close_10 = delay(close, 10)
    
    trend1 = (close_20 - close_10) / 10
    trend2 = (close_10 - close) / 10
    acceleration = trend1 - trend2
    
    return np.where(acceleration > 0.25, -1,
                   np.where(acceleration < 0, 1,
                           -1 * delta(close, 1)))

inverse_price_vol = (rank(1/終値) × 出来高) / 20日平均出来高
high_strength = (高値 × rank(高値 - 終値)) / (5日平均高値)
vwap_change = rank(VWAP - 5日前VWAP)
inverse_price_vol × high_strength - vwap_change

def alpha047(close, high, volume, vwap, adv20):
    inverse_price = rank(1 / close) * volume / adv20
    high_strength = (high * rank(high - close)) / (sum(high, 5) / 5)
    vwap_change = rank(vwap - delay(vwap, 5))
    return inverse_price * high_strength - vwap_change

delta1 = 1日価格変化
delta2 = 1日前の1日価格変化
correlation_term = 250日相関(delta1, delta2) × delta1 / 終値
industry_neutral = 業種中立化(correlation_term)
industry_neutral / 250日合計((価格変化率)^2)

def alpha048(close, industry_class):
    delta1 = delta(close, 1)
    delta2 = delta(delay(close, 1), 1)
    corr_term = correlation(delta1, delta2, 250) * delta1 / close
    # 業種中立化は実装により異なる
    industry_neutral = indneutralize(corr_term, industry_class)
    denominator = sum((delta1 / delay(close, 1)) ** 2, 250)
    return industry_neutral / denominator

Alpha#46と同様だが、閾値が-0.1

def alpha049(close):
    close_20 = delay(close, 20)
    close_10 = delay(close, 10)
    
    trend1 = (close_20 - close_10) / 10
    trend2 = (close_10 - close) / 10
    acceleration = trend1 - trend2
    
    return np.where(acceleration < -0.1, 1,
                   -1 * delta(close, 1))

correlation = 5日相関(rank(出来高), rank(VWAP))
-1 × 5日最大値(rank(correlation))

def alpha050(volume, vwap):
    corr = correlation(rank(volume), rank(vwap), 5)
    return -1 * ts_max(rank(corr), 5)

Alpha#49と同様だが、閾値が-0.05

def alpha051(close):
    close_20 = delay(close, 20)
    close_10 = delay(close, 10)
    
    trend1 = (close_20 - close_10) / 10
    trend2 = (close_10 - close) / 10
    acceleration = trend1 - trend2
    
    return np.where(acceleration < -0.05, 1,
                   -1 * delta(close, 1))

low_change = -1 × 5日最小安値 + 5日前の5日最小安値
momentum = rank((240日リターン - 20日リターン) / 220)
volume_rank = 5日時系列ランク(出来高)
low_change × momentum × volume_rank

def alpha052(low, volume, returns):
    min_low = ts_min(low, 5)
    low_change = -1 * min_low + delay(min_low, 5)
    
    ret_240 = sum(returns, 240)
    ret_20 = sum(returns, 20)
    momentum = rank((ret_240 - ret_20) / 220)
    
    vol_rank = ts_rank(volume, 5)
    return low_change * momentum * vol_rank

price_position = ((終値 - 安値) - (高値 - 終値)) / (終値 - 安値)
-1 × 9日変化(price_position)

def alpha053(high, low, close):
    numerator = (close - low) - (high - close)
    denominator = close - low
    price_position = numerator / denominator
    return -1 * delta(price_position, 9)

numerator = -1 × (安値 - 終値) × (始値^5)
denominator = (安値 - 高値) × (終値^5)
numerator / denominator

def alpha054(open, high, low, close):
    numerator = -1 * (low - close) * (open ** 5)
    denominator = (low - high) * (close ** 5)
    return numerator / denominator

relative_position = (終値 - 12日最小安値) / (12日最大高値 - 12日最小安値)
-1 × 6日相関(rank(relative_position), rank(出来高))

def alpha055(high, low, close, volume):
    min_low = ts_min(low, 12)
    max_high = ts_max(high, 12)
    relative_position = (close - min_low) / (max_high - min_low)
    return -1 * correlation(rank(relative_position), rank(volume), 6)

return_ratio = (10日リターン) / (2日リターンの3日合計)
cap_weighted = リターン × 時価総額
0 - rank(return_ratio) × rank(cap_weighted)

def alpha056(returns, cap):
    ret_10 = sum(returns, 10)
    ret_2_3 = sum(sum(returns, 2), 3)
    return_ratio = ret_10 / ret_2_3
    cap_weighted = returns * cap
    return 0 - rank(return_ratio) * rank(cap_weighted)

price_diff = 終値 - VWAP
time_to_max = 2日減衰線形(rank(30日最高値が発生した日))
0 - (price_diff / time_to_max)

def alpha057(close, vwap):
    price_diff = close - vwap
    argmax = ts_argmax(close, 30)
    time_decay = decay_linear(rank(argmax), 2)
    return 0 - (price_diff / time_decay)

neutral_vwap = セクター中立化(VWAP)
corr = 3.92795日相関(neutral_vwap, 出来高)
decay = 7.89291日減衰線形(corr)
-1 × 5.50322日時系列ランク(decay)

def alpha058(vwap, volume, sector_class):
    neutral_vwap = indneutralize(vwap, sector_class)
    corr = correlation(neutral_vwap, volume, 3.92795)
    decay = decay_linear(corr, 7.89291)
    return -1 * ts_rank(decay, 5.50322)

weighted_vwap = 0.728317 × VWAP + 0.271683 × VWAP
neutral_vwap = 業種中立化(weighted_vwap)
corr = 4.25197日相関(neutral_vwap, 出来高)
decay = 16.2289日減衰線形(corr)
-1 × 8.19648日時系列ランク(decay)

def alpha059(vwap, volume, industry_class):
    weighted_vwap = 0.728317 * vwap + (1 - 0.728317) * vwap
    neutral_vwap = indneutralize(weighted_vwap, industry_class)
    corr = correlation(neutral_vwap, volume, 4.25197)
    decay = decay_linear(corr, 16.2289)
    return -1 * ts_rank(decay, 8.19648)

price_position = ((終値 - 安値) - (高値 - 終値)) / (高値 - 安値)
volume_weighted = rank(price_position × 出来高)
max_timing = rank(10日最高値タイミング)
0 - (2 × scale(volume_weighted) - scale(max_timing))

def alpha060(high, low, close, volume):
    price_position = ((close - low) - (high - close)) / (high - low)
    vol_weighted = rank(price_position * volume)
    max_timing = rank(ts_argmax(close, 10))
    return 0 - (2 * scale(vol_weighted) - scale(max_timing))

vwap_position = rank(VWAP - 16.1219日最小VWAP)
liquidity_corr = rank(17.9282日相関(VWAP, 180日平均出来高))
vwap_position < liquidity_corr の真偽値

def alpha061(vwap, adv180):
    vwap_position = rank(vwap - ts_min(vwap, 16.1219))
    liquidity_corr = rank(correlation(vwap, adv180, 17.9282))
    return (vwap_position < liquidity_corr).astype(float)

liquidity_corr = rank(9.91009日相関(VWAP, 22.4101日合計(20日平均出来高)))
price_level = (rank(始値) + rank(始値)) < (rank(中値) + rank(高値))
(liquidity_corr < price_level) × -1

def alpha062(open, high, low, vwap, adv20):
    sum_adv = sum(adv20, 22.4101)
    liquidity_corr = rank(correlation(vwap, sum_adv, 9.91009))
    
    mid_price = (high + low) / 2
    price_level = (rank(open) + rank(open)) < (rank(mid_price) + rank(high))
    
    return (liquidity_corr < rank(price_level)) * -1

neutral_delta = 8.22237日減衰線形(2.25164日変化(業種中立化(終値)))
weighted_price = 0.318108 × VWAP + 0.681892 × 始値
liquidity_corr = 13.557日相関(weighted_price, 37.2467日合計(180日平均出来高))
decay_corr = 12.2883日減衰線形(liquidity_corr)
(rank(neutral_delta) - rank(decay_corr)) × -1

def alpha063(open, close, vwap, adv180, industry_class):
    neutral_close = indneutralize(close, industry_class)
    neutral_delta = decay_linear(delta(neutral_close, 2.25164), 8.22237)
    
    weighted_price = 0.318108 * vwap + (1 - 0.318108) * open
    sum_adv = sum(adv180, 37.2467)
    liquidity_corr = correlation(weighted_price, sum_adv, 13.557)
    decay_corr = decay_linear(liquidity_corr, 12.2883)
    
    return (rank(neutral_delta) - rank(decay_corr)) * -1

weighted_low = 0.178404 × 始値 + 0.821596 × 安値
liquidity_corr = rank(16.6208日相関(12.7054日合計(weighted_low), 12.7054日合計(120日平均出来高)))
weighted_mid = 0.178404 × 中値 + 0.821596 × VWAP
price_delta = rank(3.69741日変化(weighted_mid))
(liquidity_corr < price_delta) × -1

def alpha064(open, high, low, vwap, adv120):
    weighted_low = 0.178404 * open + (1 - 0.178404) * low
    sum_weighted = sum(weighted_low, 12.7054)
    sum_adv = sum(adv120, 12.7054)
    liquidity_corr = rank(correlation(sum_weighted, sum_adv, 16.6208))
    
    mid_price = (high + low) / 2
    weighted_mid = 0.178404 * mid_price + (1 - 0.178404) * vwap
    price_delta = rank(delta(weighted_mid, 3.69741))
    
    return (liquidity_corr < price_delta) * -1

weighted_price = 0.00817205 × 始値 + 0.99182795 × VWAP
liquidity_corr = rank(6.40374日相関(weighted_price, 8.6911日合計(60日平均出来高)))
open_position = rank(始値 - 13.635日最小始値)
(liquidity_corr < open_position) × -1

def alpha065(open, vwap, adv60):
    weighted_price = 0.00817205 * open + (1 - 0.00817205) * vwap
    sum_adv = sum(adv60, 8.6911)
    liquidity_corr = rank(correlation(weighted_price, sum_adv, 6.40374))
    
    min_open = ts_min(open, 13.635)
    open_position = rank(open - min_open)
    
    return (liquidity_corr < open_position) * -1

vwap_decay = rank(7.23052日減衰線形(3.51013日VWAP変化))
weighted_low = 0.96633 × 安値 + 0.03367 × 安値
price_ratio = (weighted_low - VWAP) / (始値 - 中値)
ratio_decay = 6.72611日時系列ランク(11.4157日減衰線形(price_ratio))
(vwap_decay + ratio_decay) × -1

def alpha066(open, high, low, vwap):
    vwap_change = delta(vwap, 3.51013)
    vwap_decay = rank(decay_linear(vwap_change, 7.23052))
    
    weighted_low = 0.96633 * low + (1 - 0.96633) * low
    mid_price = (high + low) / 2
    price_ratio = (weighted_low - vwap) / (open - mid_price)
    ratio_decay = ts_rank(decay_linear(price_ratio, 11.4157), 6.72611)
    
    return (vwap_decay + ratio_decay) * -1

high_position = rank(高値 - 2.14593日最小高値)
neutral_vwap = セクター中立化(VWAP)
neutral_adv = サブ業種中立化(20日平均出来高)
correlation_rank = rank(6.02936日相関(neutral_vwap, neutral_adv))
high_position ^ correlation_rank × -1

def alpha067(high, vwap, adv20, sector_class, subindustry_class):
    min_high = ts_min(high, 2.14593)
    high_position = rank(high - min_high)
    
    neutral_vwap = indneutralize(vwap, sector_class)
    neutral_adv = indneutralize(adv20, subindustry_class)
    corr_rank = rank(correlation(neutral_vwap, neutral_adv, 6.02936))
    
    return (high_position ** corr_rank) * -1

high_liquidity = 13.9333日時系列ランク(8.91644日相関(rank(高値), rank(15日平均出来高)))
weighted_price = 0.518371 × 終値 + 0.481629 × 安値
price_delta = rank(1.06157日変化(weighted_price))
(high_liquidity < price_delta) × -1

def alpha068(high, low, close, adv15):
    high_rank = rank(high)
    adv_rank = rank(adv15)
    corr = correlation(high_rank, adv_rank, 8.91644)
    high_liquidity = ts_rank(corr, 13.9333)
    
    weighted_price = 0.518371 * close + (1 - 0.518371) * low
    price_delta = rank(delta(weighted_price, 1.06157))
    
    return (high_liquidity < price_delta) * -1

neutral_vwap = 業種中立化(VWAP)
vwap_max = rank(4.79344日最大値(2.72412日変化(neutral_vwap)))
weighted_price = 0.490655 × 終値 + 0.509345 × VWAP
price_corr = 9.0615日時系列ランク(4.92416日相関(weighted_price, 20日平均出来高))
vwap_max ^ price_corr × -1

def alpha069(close, vwap, adv20, industry_class):
    neutral_vwap = indneutralize(vwap, industry_class)
    vwap_change = delta(neutral_vwap, 2.72412)
    vwap_max = rank(ts_max(vwap_change, 4.79344))
    
    weighted_price = 0.490655 * close + (1 - 0.490655) * vwap
    price_corr = ts_rank(correlation(weighted_price, adv20, 4.92416), 9.0615)
    
    return (vwap_max ** price_corr) * -1

vwap_change = rank(1.29456日VWAP変化)
neutral_close = 業種中立化(終値)
close_corr = 17.9171日時系列ランク(17.8256日相関(neutral_close, 50日平均出来高))
vwap_change ^ close_corr × -1

def alpha070(close, vwap, adv50, industry_class):
    vwap_change = rank(delta(vwap, 1.29456))
    neutral_close = indneutralize(close, industry_class)
    corr = correlation(neutral_close, adv50, 17.8256)
    close_corr = ts_rank(corr, 17.9171)
    return (vwap_change ** close_corr) * -1

close_rank = 3.43976日時系列ランク(終値)
adv_rank = 12.0647日時系列ランク(180日平均出来高)
corr = 18.0175日相関(close_rank, adv_rank)
term1 = 15.6948日時系列ランク(4.20501日減衰線形(corr))

price_position = rank((安値 + 始値) - (VWAP + VWAP)) ^ 2
term2 = 4.4388日時系列ランク(16.4662日減衰線形(price_position))

max(term1, term2)

def alpha071(open, low, close, vwap, adv180):
    close_rank = ts_rank(close, 3.43976)
    adv_rank = ts_rank(adv180, 12.0647)
    corr = correlation(close_rank, adv_rank, 18.0175)
    term1 = ts_rank(decay_linear(corr, 4.20501), 15.6948)
    
    price_position = rank((low + open) - 2 * vwap) ** 2
    term2 = ts_rank(decay_linear(price_position, 16.4662), 4.4388)
    
    return np.maximum(term1, term2)

mid_corr = rank(10.1519日減衰線形(8.93345日相関(中値, 40日平均出来高)))
vwap_rank = 3.72469日時系列ランク(VWAP)
vol_rank = 18.5188日時系列ランク(出来高)
vwap_vol_corr = rank(2.95011日減衰線形(6.86671日相関(vwap_rank, vol_rank)))
mid_corr / vwap_vol_corr

def alpha072(high, low, vwap, volume, adv40):
    mid_price = (high + low) / 2
    mid_corr = correlation(mid_price, adv40, 8.93345)
    mid_decay = rank(decay_linear(mid_corr, 10.1519))
    
    vwap_rank = ts_rank(vwap, 3.72469)
    vol_rank = ts_rank(volume, 18.5188)
    vwap_vol_corr = correlation(vwap_rank, vol_rank, 6.86671)
    vwap_decay = rank(decay_linear(vwap_vol_corr, 2.95011))
    
    return mid_decay / vwap_decay

vwap_decay = rank(2.91864日減衰線形(4.72775日VWAP変化))
weighted_price = 0.147155 × 始値 + 0.852845 × 安値
price_change_rate = 2.03608日変化(weighted_price) / weighted_price × -1
price_decay = 16.7411日時系列ランク(3.33829日減衰線形(price_change_rate))
max(vwap_decay, price_decay) × -1

def alpha073(open, low, vwap):
    vwap_change = delta(vwap, 4.72775)
    vwap_decay = rank(decay_linear(vwap_change, 2.91864))
    
    weighted_price = 0.147155 * open + (1 - 0.147155) * low
    price_change = delta(weighted_price, 2.03608)
    price_rate = (price_change / weighted_price) * -1
    price_decay = ts_rank(decay_linear(price_rate, 3.33829), 16.7411)
    
    return np.maximum(vwap_decay, price_decay) * -1

close_corr = rank(15.1365日相関(終値, 37.4843日合計(30日平均出来高)))
weighted_high = 0.0261661 × 高値 + 0.9738339 × VWAP
high_vol_corr = rank(11.4791日相関(rank(weighted_high), rank(出来高)))
(close_corr < high_vol_corr) × -1

def alpha074(high, close, volume, vwap, adv30):
    sum_adv = sum(adv30, 37.4843)
    close_corr = rank(correlation(close, sum_adv, 15.1365))
    
    weighted_high = 0.0261661 * high + (1 - 0.0261661) * vwap
    high_rank = rank(weighted_high)
    vol_rank = rank(volume)
    high_vol_corr = rank(correlation(high_rank, vol_rank, 11.4791))
    
    return (close_corr < high_vol_corr) * -1

vwap_vol_corr = rank(4.24304日相関(VWAP, 出来高))
low_adv_corr = rank(12.4413日相関(rank(安値), rank(50日平均出来高)))
vwap_vol_corr < low_adv_corr

def alpha075(low, vwap, volume, adv50):
    vwap_vol_corr = rank(correlation(vwap, volume, 4.24304))
    low_rank = rank(low)
    adv_rank = rank(adv50)
    low_adv_corr = rank(correlation(low_rank, adv_rank, 12.4413))
    return (vwap_vol_corr < low_adv_corr).astype(float)

vwap_decay = rank(11.8259日減衰線形(1.24383日VWAP変化))
neutral_low = セクター中立化(安値)
low_corr = 19.569日時系列ランク(8.14941日相関(neutral_low, 81日平均出来高))
corr_decay = 19.383日時系列ランク(17.1543日減衰線形(low_corr))
max(vwap_decay, corr_decay) × -1

def alpha076(low, vwap, adv81, sector_class):
    vwap_change = delta(vwap, 1.24383)
    vwap_decay = rank(decay_linear(vwap_change, 11.8259))
    
    neutral_low = indneutralize(low, sector_class)
    low_corr = ts_rank(correlation(neutral_low, adv81, 8.14941), 19.569)
    corr_decay = ts_rank(decay_linear(low_corr, 17.1543), 19.383)
    
    return np.maximum(vwap_decay, corr_decay) * -1

price_position = ((中値 + 高値) - (VWAP + 高値))
position_decay = rank(20.0451日減衰線形(price_position))
mid_corr = rank(5.64125日減衰線形(3.1614日相関(中値, 40日平均出来高)))
min(position_decay, mid_corr)

def alpha077(high, low, vwap, adv40):
    mid_price = (high + low) / 2
    price_position = (mid_price + high) - (vwap + high)
    position_decay = rank(decay_linear(price_position, 20.0451))
    
    mid_corr = correlation(mid_price, adv40, 3.1614)
    corr_decay = rank(decay_linear(mid_corr, 5.64125))
    
    return np.minimum(position_decay, corr_decay)

weighted_low = 0.352233 × 安値 + 0.647767 × VWAP
low_corr = rank(6.83313日相関(19.7428日合計(weighted_low), 19.7428日合計(40日平均出来高)))
vwap_vol_corr = rank(5.77492日相関(rank(VWAP), rank(出来高)))
low_corr ^ vwap_vol_corr

def alpha078(low, vwap, volume, adv40):
    weighted_low = 0.352233 * low + (1 - 0.352233) * vwap
    sum_weighted = sum(weighted_low, 19.7428)
    sum_adv = sum(adv40, 19.7428)
    low_corr = rank(correlation(sum_weighted, sum_adv, 6.83313))
    
    vwap_rank = rank(vwap)
    vol_rank = rank(volume)
    vwap_vol_corr = rank(correlation(vwap_rank, vol_rank, 5.77492))
    
    return low_corr ** vwap_vol_corr

weighted_price = 0.60733 × 終値 + 0.39267 × 始値
neutral_price = セクター中立化(weighted_price)
price_delta = rank(1.23438日変化(neutral_price))
vwap_rank = 3.60973日時系列ランク(VWAP)
adv_rank = 9.18637日時系列ランク(150日平均出来高)
vwap_corr = rank(14.6644日相関(vwap_rank, adv_rank))
price_delta < vwap_corr

def alpha079(open, close, vwap, adv150, sector_class):
    weighted_price = 0.60733 * close + (1 - 0.60733) * open
    neutral_price = indneutralize(weighted_price, sector_class)
    price_delta = rank(delta(neutral_price, 1.23438))
    
    vwap_rank = ts_rank(vwap, 3.60973)
    adv_rank = ts_rank(adv150, 9.18637)
    vwap_corr = rank(correlation(vwap_rank, adv_rank, 14.6644))
    
    return (price_delta < vwap_corr).astype(float)

weighted_open = 0.868128 × 始値 + 0.131872 × 高値
neutral_open = 業種中立化(weighted_open)
price_sign = rank(sign(4.04545日変化(neutral_open)))
high_corr = 5.53756日時系列ランク(5.11456日相関(高値, 10日平均出来高))
price_sign ^ high_corr × -1

def alpha080(open, high, adv10, industry_class):
    weighted_open = 0.868128 * open + (1 - 0.868128) * high
    neutral_open = indneutralize(weighted_open, industry_class)
    price_change = delta(neutral_open, 4.04545)
    price_sign = rank(np.sign(price_change))
    
    high_corr = ts_rank(correlation(high, adv10, 5.11456), 5.53756)
    
    return (price_sign ** high_corr) * -1

vwap_adv_corr = rank(8.47743日相関(VWAP, 49.6054日合計(10日平均出来高))) ^ 4
log_product = rank(log(14.9655日積(rank(vwap_adv_corr))))
vwap_vol_corr = rank(5.07914日相関(rank(VWAP), rank(出来高)))
(log_product < vwap_vol_corr) × -1

def alpha081(vwap, volume, adv10):
    sum_adv = sum(adv10, 49.6054)
    vwap_adv_corr = rank(correlation(vwap, sum_adv, 8.47743)) ** 4
    product_term = product(rank(vwap_adv_corr), 14.9655)
    log_product = rank(np.log(product_term))
    
    vwap_rank = rank(vwap)
    vol_rank = rank(volume)
    vwap_vol_corr = rank(correlation(vwap_rank, vol_rank, 5.07914))
    
    return (log_product < vwap_vol_corr) * -1

open_decay = rank(14.8717日減衰線形(1.46063日始値変化))
neutral_vol = セクター中立化(出来高)
weighted_open = 0.634196 × 始値 + 0.365804 × 始値
vol_corr = 6.92131日減衰線形(17.4842日相関(neutral_vol, weighted_open))
corr_rank = 13.4283日時系列ランク(vol_corr)
min(open_decay, corr_rank) × -1

def alpha082(open, volume, sector_class):
    open_change = delta(open, 1.46063)
    open_decay = rank(decay_linear(open_change, 14.8717))
    
    neutral_vol = indneutralize(volume, sector_class)
    weighted_open = 0.634196 * open + (1 - 0.634196) * open
    vol_corr = correlation(neutral_vol, weighted_open, 17.4842)
    vol_decay = decay_linear(vol_corr, 6.92131)
    corr_rank = ts_rank(vol_decay, 13.4283)
    
    return np.minimum(open_decay, corr_rank) * -1

price_range = (高値 - 安値) / (5日平均終値)
delayed_range = rank(2日前price_range)
vol_rank = rank(rank(出来高))
current_position = price_range / (VWAP - 終値)
(delayed_range × vol_rank) / current_position

def alpha083(high, low, close, volume, vwap):
    avg_close = sum(close, 5) / 5
    price_range = (high - low) / avg_close
    delayed_range = rank(delay(price_range, 2))
    vol_rank = rank(rank(volume))
    current_position = price_range / (vwap - close)
    return (delayed_range * vol_rank) / current_position

vwap_position = 20.7127日時系列ランク(VWAP - 15.3217日最大VWAP)
price_change = 4.96796日価格変化
signedpower(vwap_position, price_change)

def alpha084(close, vwap):
    max_vwap = ts_max(vwap, 15.3217)
    vwap_position = ts_rank(vwap - max_vwap, 20.7127)
    price_change = delta(close, 4.96796)
    return signedpower(vwap_position, price_change)

weighted_price = 0.876703 × 高値 + 0.123297 × 終値
price_corr = rank(9.61331日相関(weighted_price, 30日平均出来高))
mid_rank = 3.70596日時系列ランク(中値)
vol_rank = 10.1595日時系列ランク(出来高)
mid_vol_corr = rank(7.11408日相関(mid_rank, vol_rank))
price_corr ^ mid_vol_corr

def alpha085(high, low, close, volume, adv30):
    weighted_price = 0.876703 * high + (1 - 0.876703) * close
    price_corr = rank(correlation(weighted_price, adv30, 9.61331))
    
    mid_price = (high + low) / 2
    mid_rank = ts_rank(mid_price, 3.70596)
    vol_rank = ts_rank(volume, 10.1595)
    mid_vol_corr = rank(correlation(mid_rank, vol_rank, 7.11408))
    
    return price_corr ** mid_vol_corr

close_corr = 20.4195日時系列ランク(6.00049日相関(終値, 14.7444日合計(20日平均出来高)))
price_position = rank((始値 + 終値) - (VWAP + 始値))
(close_corr < price_position) × -1

def alpha086(open, close, vwap, adv20):
    sum_adv = sum(adv20, 14.7444)
    close_corr = ts_rank(correlation(close, sum_adv, 6.00049), 20.4195)
    price_position = rank((open + close) - (vwap + open))
    return (close_corr < price_position) * -1

weighted_price = 0.369701 × 終値 + 0.630299 × VWAP
price_decay = rank(2.65461日減衰線形(1.91233日変化(weighted_price)))
neutral_adv = 業種中立化(81日平均出来高)
adv_corr = |13.4132日相関(neutral_adv, 終値)|
corr_decay = 14.4535日時系列ランク(4.89768日減衰線形(adv_corr))
max(price_decay, corr_decay) × -1

def alpha087(close, vwap, adv81, industry_class):
    weighted_price = 0.369701 * close + (1 - 0.369701) * vwap
    price_change = delta(weighted_price, 1.91233)
    price_decay = rank(decay_linear(price_change, 2.65461))
    
    neutral_adv = indneutralize(adv81, industry_class)
    adv_corr = np.abs(correlation(neutral_adv, close, 13.4132))
    corr_decay = ts_rank(decay_linear(adv_corr, 4.89768), 14.4535)
    
    return np.maximum(price_decay, corr_decay) * -1

price_diff = (rank(始値) + rank(安値)) - (rank(高値) + rank(終値))
diff_decay = rank(8.06882日減衰線形(price_diff))
close_rank = 8.44728日時系列ランク(終値)
adv_rank = 20.6966日時系列ランク(60日平均出来高)
corr = 8.01266日相関(close_rank, adv_rank)
corr_decay = 2.61957日時系列ランク(6.65053日減衰線形(corr))
min(diff_decay, corr_decay)

def alpha088(open, high, low, close, adv60):
    price_diff = (rank(open) + rank(low)) - (rank(high) + rank(close))
    diff_decay = rank(decay_linear(price_diff, 8.06882))
    
    close_rank = ts_rank(close, 8.44728)
    adv_rank = ts_rank(adv60, 20.6966)
    corr = correlation(close_rank, adv_rank, 8.01266)
    corr_decay = ts_rank(decay_linear(corr, 6.65053), 2.61957)
    
    return np.minimum(diff_decay, corr_decay)

weighted_low = 0.967285 × 安値 + 0.032715 × 安値
low_corr = 5.51607日減衰線形(6.94279日相関(weighted_low, 10日平均出来高))
corr_rank = 3.79744日時系列ランク(low_corr)
neutral_vwap = 業種中立化(VWAP)
vwap_decay = 10.1466日減衰線形(3.48158日変化(neutral_vwap))
vwap_rank = 15.3012日時系列ランク(vwap_decay)
corr_rank - vwap_rank

def alpha089(low, vwap, adv10, industry_class):
    weighted_low = 0.967285 * low + (1 - 0.967285) * low
    low_corr = correlation(weighted_low, adv10, 6.94279)
    low_decay = decay_linear(low_corr, 5.51607)
    corr_rank = ts_rank(low_decay, 3.79744)
    
    neutral_vwap = indneutralize(vwap, industry_class)
    vwap_change = delta(neutral_vwap, 3.48158)
    vwap_decay = decay_linear(vwap_change, 10.1466)
    vwap_rank = ts_rank(vwap_decay, 15.3012)
    
    return corr_rank - vwap_rank

price_position = rank(終値 - 4.66719日最大終値)
neutral_adv = サブ業種中立化(40日平均出来高)
adv_corr = 3.21856日時系列ランク(5.38375日相関(neutral_adv, 安値))
price_position ^ adv_corr × -1

def alpha090(close, low, adv40, subindustry_class):
    max_close = ts_max(close, 4.66719)
    price_position = rank(close - max_close)
    
    neutral_adv = indneutralize(adv40, subindustry_class)
    adv_corr = ts_rank(correlation(neutral_adv, low, 5.38375), 3.21856)
    
    return (price_position ** adv_corr) * -1

neutral_close = 業種中立化(終値)
close_vol_corr = 9.74928日相関(neutral_close, 出来高)
inner_decay = 16.398日減衰線形(close_vol_corr)
outer_decay = 3.83219日減衰線形(inner_decay)
term1 = 4.8667日時系列ランク(outer_decay)

vwap_adv_corr = 4.01303日相関(VWAP, 30日平均出来高)
term2 = rank(2.6809日減衰線形(vwap_adv_corr))

(term1 - term2) × -1

def alpha091(close, volume, vwap, adv30, industry_class):
    neutral_close = indneutralize(close, industry_class)
    close_vol_corr = correlation(neutral_close, volume, 9.74928)
    inner_decay = decay_linear(close_vol_corr, 16.398)
    outer_decay = decay_linear(inner_decay, 3.83219)
    term1 = ts_rank(outer_decay, 4.8667)
    
    vwap_adv_corr = correlation(vwap, adv30, 4.01303)
    term2 = rank(decay_linear(vwap_adv_corr, 2.6809))
    
    return (term1 - term2) * -1

condition = ((中値 + 終値) < (安値 + 始値))
cond_decay = 18.8683日時系列ランク(14.7221日減衰線形(condition))
low_adv_corr = 7.58555日相関(rank(安値), rank(30日平均出来高))
corr_decay = 6.80584日時系列ランク(6.94024日減衰線形(low_adv_corr))
min(cond_decay, corr_decay)

def alpha092(open, high, low, close, adv30):
    mid_price = (high + low) / 2
    condition = ((mid_price + close) < (low + open)).astype(float)
    cond_decay = ts_rank(decay_linear(condition, 14.7221), 18.8683)
    
    low_rank = rank(low)
    adv_rank = rank(adv30)
    low_adv_corr = correlation(low_rank, adv_rank, 7.58555)
    corr_decay = ts_rank(decay_linear(low_adv_corr, 6.94024), 6.80584)
    
    return np.minimum(cond_decay, corr_decay)

neutral_vwap = 業種中立化(VWAP)
vwap_corr = 19.848日減衰線形(17.4193日相関(neutral_vwap, 81日平均出来高))
corr_rank = 7.54455日時系列ランク(vwap_corr)

weighted_price = 0.524434 × 終値 + 0.475566 × VWAP
price_decay = rank(16.2664日減衰線形(2.77377日変化(weighted_price)))

corr_rank / price_decay

def alpha093(close, vwap, adv81, industry_class):
    neutral_vwap = indneutralize(vwap, industry_class)
    vwap_corr = correlation(neutral_vwap, adv81, 17.4193)
    vwap_decay = decay_linear(vwap_corr, 19.848)
    corr_rank = ts_rank(vwap_decay, 7.54455)
    
    weighted_price = 0.524434 * close + (1 - 0.524434) * vwap
    price_change = delta(weighted_price, 2.77377)
    price_decay = rank(decay_linear(price_change, 16.2664))
    
    return corr_rank / price_decay

vwap_position = rank(VWAP - 11.5783日最小VWAP)
vwap_rank = 19.6462日時系列ランク(VWAP)
adv_rank = 4.02992日時系列ランク(60日平均出来高)
vwap_corr = 2.70756日時系列ランク(18.0926日相関(vwap_rank, adv_rank))
vwap_position ^ vwap_corr × -1

def alpha094(vwap, adv60):
    min_vwap = ts_min(vwap, 11.5783)
    vwap_position = rank(vwap - min_vwap)
    
    vwap_rank = ts_rank(vwap, 19.6462)
    adv_rank = ts_rank(adv60, 4.02992)
    vwap_corr = ts_rank(correlation(vwap_rank, adv_rank, 18.0926), 2.70756)
    
    return (vwap_position ** vwap_corr) * -1

open_position = rank(始値 - 12.4105日最小始値)
mid_sum = 19.1351日合計(中値)
adv_sum = 19.1351日合計(40日平均出来高)
mid_corr = rank(12.8742日相関(mid_sum, adv_sum)) ^ 5
corr_rank = 11.7584日時系列ランク(mid_corr)
open_position < corr_rank

def alpha095(open, high, low, adv40):
    min_open = ts_min(open, 12.4105)
    open_position = rank(open - min_open)
    
    mid_price = (high + low) / 2
    mid_sum = sum(mid_price, 19.1351)
    adv_sum = sum(adv40, 19.1351)
    mid_corr = rank(correlation(mid_sum, adv_sum, 12.8742)) ** 5
    corr_rank = ts_rank(mid_corr, 11.7584)
    
    return (open_position < corr_rank).astype(float)

vwap_vol_corr = 3.83878日相関(rank(VWAP), rank(出来高))
term1 = 8.38151日時系列ランク(4.16783日減衰線形(vwap_vol_corr))

close_rank = 7.45404日時系列ランク(終値)
adv_rank = 4.13242日時系列ランク(60日平均出来高)
close_adv_corr = 3.65459日相関(close_rank, adv_rank)
argmax = 12.6556日時系列ArgMax(close_adv_corr)
term2 = 13.4143日時系列ランク(14.0365日減衰線形(argmax))

max(term1, term2) × -1

def alpha096(close, volume, vwap, adv60):
    vwap_rank = rank(vwap)
    vol_rank = rank(volume)
    vwap_vol_corr = correlation(vwap_rank, vol_rank, 3.83878)
    vwap_decay = decay_linear(vwap_vol_corr, 4.16783)
    term1 = ts_rank(vwap_decay, 8.38151)
    
    close_rank = ts_rank(close, 7.45404)
    adv_rank = ts_rank(adv60, 4.13242)
    close_adv_corr = correlation(close_rank, adv_rank, 3.65459)
    argmax = ts_argmax(close_adv_corr, 12.6556)
    argmax_decay = decay_linear(argmax, 14.0365)
    term2 = ts_rank(argmax_decay, 13.4143)
    
    return np.maximum(term1, term2) * -1

weighted_price = 0.721001 × 安値 + 0.278999 × VWAP
neutral_price = 業種中立化(weighted_price)
price_decay = rank(20.4523日減衰線形(3.3705日変化(neutral_price)))

low_rank = 7.87871日時系列ランク(安値)
adv_rank = 17.255日時系列ランク(60日平均出来高)
low_adv_corr = 18.5925日時系列ランク(4.97547日相関(low_rank, adv_rank))
corr_decay = 6.71659日時系列ランク(15.7152日減衰線形(low_adv_corr))

(price_decay - corr_decay) × -1

def alpha097(low, vwap, adv60, industry_class):
    weighted_price = 0.721001 * low + (1 - 0.721001) * vwap
    neutral_price = indneutralize(weighted_price, industry_class)
    price_change = delta(neutral_price, 3.3705)
    price_decay = rank(decay_linear(price_change, 20.4523))
    
    low_rank = ts_rank(low, 7.87871)
    adv_rank = ts_rank(adv60, 17.255)
    low_adv_corr = ts_rank(correlation(low_rank, adv_rank, 4.97547), 18.5925)
    corr_decay = ts_rank(decay_linear(low_adv_corr, 15.7152), 6.71659)
    
    return (price_decay - corr_decay) * -1

vwap_corr = rank(7.18088日減衰線形(4.58418日相関(VWAP, 26.4719日合計(5日平均出来高))))

open_adv_corr = 20.8187日相関(rank(始値), rank(15日平均出来高))
argmin = 8.62571日時系列ArgMin(open_adv_corr)
argmin_rank = 6.95668日時系列ランク(argmin)
open_decay = rank(8.07206日減衰線形(argmin_rank))

vwap_corr - open_decay

def alpha098(open, vwap, adv5, adv15):
    sum_adv5 = sum(adv5, 26.4719)
    vwap_corr = correlation(vwap, sum_adv5, 4.58418)
    vwap_decay = decay_linear(vwap_corr, 7.18088)
    vwap_rank = rank(vwap_decay)
    
    open_rank = rank(open)
    adv15_rank = rank(adv15)
    open_adv_corr = correlation(open_rank, adv15_rank, 20.8187)
    argmin = ts_argmin(open_adv_corr, 8.62571)
    argmin_rank = ts_rank(argmin, 6.95668)
    open_decay = rank(decay_linear(argmin_rank, 8.07206))
    
    return vwap_rank - open_decay

mid_sum = 19.8975日合計(中値)
adv_sum = 19.8975日合計(60日平均出来高)
mid_corr = rank(8.8136日相関(mid_sum, adv_sum))
low_vol_corr = rank(6.28259日相関(安値, 出来高))
(mid_corr < low_vol_corr) × -1

def alpha099(high, low, volume, adv60):
    mid_price = (high + low) / 2
    mid_sum = sum(mid_price, 19.8975)
    adv_sum = sum(adv60, 19.8975)
    mid_corr = rank(correlation(mid_sum, adv_sum, 8.8136))
    
    low_vol_corr = rank(correlation(low, volume, 6.28259))
    
    return (mid_corr < low_vol_corr) * -1

price_position = ((終値 - 安値) - (高値 - 終値)) / (高値 - 安値) × 出来高
position_neutral = サブ業種中立化(サブ業種中立化(rank(price_position)))
scaled_position = 1.5 × scale(position_neutral)

close_adv_corr = 5日相関(終値, rank(20日平均出来高))
argmin_close = rank(30日最小終値タイミング)
corr_diff = close_adv_corr - argmin_close
scaled_corr = scale(サブ業種中立化(corr_diff))

volume_ratio = 出来高 / 20日平均出来高
0 - (scaled_position - scaled_corr) × volume_ratio

def alpha100(high, low, close, volume, adv20, subindustry_class):
    price_position = ((close - low) - (high - close)) / (high - low) * volume
    position_rank = rank(price_position)
    position_neutral1 = indneutralize(position_rank, subindustry_class)
    position_neutral2 = indneutralize(position_neutral1, subindustry_class)
    scaled_position = 1.5 * scale(position_neutral2)
    
    close_adv_corr = correlation(close, rank(adv20), 5)
    argmin_close = rank(ts_argmin(close, 30))
    corr_diff = close_adv_corr - argmin_close
    corr_neutral = indneutralize(corr_diff, subindustry_class)
    scaled_corr = scale(corr_neutral)
    
    volume_ratio = volume / adv20
    return 0 - (scaled_position - scaled_corr) * volume_ratio

(終値 - 始値) / ((高値 - 安値) + 0.001)

def alpha101(open, high, low, close):
    return (close - open) / ((high - low) + 0.001)