powerquant-cli 0.2.6__py3-none-any.whl

quant_core/app/factor/builtin/alpha101_recipe.py

@@ -0,0 +1,1095 @@
+"""静态 Python 配方，训练标签不属于特征集合。"""
+# Derived from vn.py fa5206fe63836f3f8cd1ebd7168fbd19a5e2ff09.
+# Copyright (c) 2015-present, Xiaoyou Chen. MIT; see app/factor/LICENSE.vnpy.
+
+from collections.abc import Callable
+
+from quant_core.app.factor.computation.operators.arithmetic_operator import (
+    abs,
+    log,
+    pow1,
+    pow2,
+    quesval,
+    quesval2,
+    sign,
+)
+from quant_core.app.factor.computation.operators.cross_section_operator import cs_rank, cs_scale
+from quant_core.app.factor.computation.operators.time_series_operator import (
+    ts_argmax,
+    ts_argmin,
+    ts_corr,
+    ts_cov,
+    ts_decay_linear,
+    ts_delay,
+    ts_delta,
+    ts_greater,
+    ts_less,
+    ts_max,
+    ts_mean,
+    ts_min,
+    ts_product,
+    ts_rank,
+    ts_std,
+    ts_sum,
+)
+from quant_core.app.factor.computation.panel_expression import PanelExpression
+
+UNSUPPORTED_ALPHA101 = (48, 56, 58, 59, 63, 67, 69, 70, 76, 79, 80, 82, 87, 89, 90, 91, 93, 97, 100)
+
+
+def alpha101_alpha1(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha1 特征。"""
+    close = fields["close"]
+    return (
+        cs_rank(
+            ts_argmax(
+                pow1(
+                    quesval(
+                        0,
+                        (close / ts_delay(close, 1) - 1),
+                        close,
+                        ts_std((close / ts_delay(close, 1) - 1), 20),
+                    ),
+                    2.0,
+                ),
+                5,
+            )
+        )
+        - 0.5
+    )
+
+
+def alpha101_alpha2(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha2 特征。"""
+    close = fields["close"]
+    open = fields["open"]
+    volume = fields["volume"]
+    return (-1) * ts_corr(cs_rank(ts_delta(log(volume), 2)), cs_rank((close - open) / open), 6)
+
+
+def alpha101_alpha3(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha3 特征。"""
+    open = fields["open"]
+    volume = fields["volume"]
+    return ts_corr(cs_rank(open), cs_rank(volume), 10) * -1
+
+
+def alpha101_alpha4(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha4 特征。"""
+    low = fields["low"]
+    return -1 * ts_rank(cs_rank(low), 9)
+
+
+def alpha101_alpha5(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha5 特征。"""
+    close = fields["close"]
+    open = fields["open"]
+    vwap = fields["vwap"]
+    return cs_rank(open - (ts_sum(vwap, 10) / 10)) * (-1 * abs(cs_rank(close - vwap)))
+
+
+def alpha101_alpha6(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha6 特征。"""
+    open = fields["open"]
+    volume = fields["volume"]
+    return (-1) * ts_corr(open, volume, 10)
+
+
+def alpha101_alpha7(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha7 特征。"""
+    close = fields["close"]
+    volume = fields["volume"]
+    return quesval2(
+        ts_mean(volume, 20),
+        volume,
+        (-1 * ts_rank(abs(close - ts_delay(close, 7)), 60)) * sign(ts_delta(close, 7)),
+        -1,
+    )
+
+
+def alpha101_alpha8(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha8 特征。"""
+    close = fields["close"]
+    open = fields["open"]
+    return -1 * cs_rank(
+        (ts_sum(open, 5) * ts_sum((close / ts_delay(close, 1) - 1), 5))
+        - ts_delay((ts_sum(open, 5) * ts_sum((close / ts_delay(close, 1) - 1), 5)), 10)
+    )
+
+
+def alpha101_alpha9(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha9 特征。"""
+    close = fields["close"]
+    return quesval(
+        0,
+        ts_min(ts_delta(close, 1), 5),
+        ts_delta(close, 1),
+        quesval(0, ts_max(ts_delta(close, 1), 5), (-1 * ts_delta(close, 1)), ts_delta(close, 1)),
+    )
+
+
+def alpha101_alpha10(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha10 特征。"""
+    close = fields["close"]
+    return cs_rank(
+        quesval(
+            0,
+            ts_min(ts_delta(close, 1), 4),
+            ts_delta(close, 1),
+            quesval(
+                0, ts_max(ts_delta(close, 1), 4), (-1 * ts_delta(close, 1)), ts_delta(close, 1)
+            ),
+        )
+    )
+
+
+def alpha101_alpha11(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha11 特征。"""
+    close = fields["close"]
+    volume = fields["volume"]
+    vwap = fields["vwap"]
+    return (cs_rank(ts_max(vwap - close, 3)) + cs_rank(ts_min(vwap - close, 3))) * cs_rank(
+        ts_delta(volume, 3)
+    )
+
+
+def alpha101_alpha12(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha12 特征。"""
+    close = fields["close"]
+    volume = fields["volume"]
+    return sign(ts_delta(volume, 1)) * (-1 * ts_delta(close, 1))
+
+
+def alpha101_alpha13(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha13 特征。"""
+    close = fields["close"]
+    volume = fields["volume"]
+    return -1 * cs_rank(ts_cov(cs_rank(close), cs_rank(volume), 5))
+
+
+def alpha101_alpha14(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha14 特征。"""
+    close = fields["close"]
+    open = fields["open"]
+    volume = fields["volume"]
+    return (
+        -1
+        * cs_rank((close / ts_delay(close, 1) - 1) - ts_delay((close / ts_delay(close, 1) - 1), 3))
+    ) * ts_corr(open, volume, 10)
+
+
+def alpha101_alpha15(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha15 特征。"""
+    high = fields["high"]
+    volume = fields["volume"]
+    return -1 * ts_sum(cs_rank(ts_corr(cs_rank(high), cs_rank(volume), 3)), 3)
+
+
+def alpha101_alpha16(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha16 特征。"""
+    high = fields["high"]
+    volume = fields["volume"]
+    return -1 * cs_rank(ts_cov(cs_rank(high), cs_rank(volume), 5))
+
+
+def alpha101_alpha17(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha17 特征。"""
+    close = fields["close"]
+    volume = fields["volume"]
+    return (
+        (-1 * cs_rank(ts_rank(close, 10)))
+        * cs_rank(close - 2 * ts_delay(close, 1) + ts_delay(close, 2))
+        * cs_rank(ts_rank(volume / ts_mean(volume, 20), 5))
+    )
+
+
+def alpha101_alpha18(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha18 特征。"""
+    close = fields["close"]
+    open = fields["open"]
+    return -1 * cs_rank((ts_std(abs(close - open), 5) + (close - open)) + ts_corr(close, open, 10))
+
+
+def alpha101_alpha19(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha19 特征。"""
+    close = fields["close"]
+    return (-1 * sign(ts_delta(close, 7) + (close - ts_delay(close, 7)))) * (
+        cs_rank(ts_sum((close / ts_delay(close, 1) - 1), 250) + 1) + 1
+    )
+
+
+def alpha101_alpha20(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha20 特征。"""
+    close = fields["close"]
+    high = fields["high"]
+    low = fields["low"]
+    open = fields["open"]
+    return (
+        (-1 * cs_rank(open - ts_delay(high, 1)))
+        * cs_rank(open - ts_delay(close, 1))
+        * cs_rank(open - ts_delay(low, 1))
+    )
+
+
+def alpha101_alpha21(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha21 特征。"""
+    close = fields["close"]
+    volume = fields["volume"]
+    return quesval2(
+        (ts_mean(close, 8) + ts_std(close, 8)),
+        ts_mean(close, 2),
+        -1,
+        quesval2(
+            ts_mean(close, 2),
+            (ts_mean(close, 8) - ts_std(close, 8)),
+            1,
+            quesval(1, (volume / ts_mean(volume, 20)), 1, -1),
+        ),
+    )
+
+
+def alpha101_alpha22(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha22 特征。"""
+    close = fields["close"]
+    high = fields["high"]
+    volume = fields["volume"]
+    return -1 * ts_delta(ts_corr(high, volume, 5), 5) * cs_rank(ts_std(close, 20))
+
+
+def alpha101_alpha23(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha23 特征。"""
+    high = fields["high"]
+    return quesval2(ts_mean(high, 20), high, -1 * ts_delta(high, 2), 0)
+
+
+def alpha101_alpha24(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha24 特征。"""
+    close = fields["close"]
+    return quesval(
+        0.05,
+        ts_delta(ts_sum(close, 100) / 100, 100) / ts_delay(close, 100),
+        (-1 * ts_delta(close, 3)),
+        (-1 * (close - ts_min(close, 100))),
+    )
+
+
+def alpha101_alpha25(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha25 特征。"""
+    close = fields["close"]
+    high = fields["high"]
+    volume = fields["volume"]
+    vwap = fields["vwap"]
+    return cs_rank(
+        (-1 * (close / ts_delay(close, 1) - 1)) * ts_mean(volume, 20) * vwap * (high - close)
+    )
+
+
+def alpha101_alpha26(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha26 特征。"""
+    high = fields["high"]
+    volume = fields["volume"]
+    return -1 * ts_max(ts_corr(ts_rank(volume, 5), ts_rank(high, 5), 5), 3)
+
+
+def alpha101_alpha27(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha27 特征。"""
+    volume = fields["volume"]
+    vwap = fields["vwap"]
+    return quesval(0.5, cs_rank(ts_mean(ts_corr(cs_rank(volume), cs_rank(vwap), 6), 2)), -1, 1)
+
+
+def alpha101_alpha28(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha28 特征。"""
+    close = fields["close"]
+    high = fields["high"]
+    low = fields["low"]
+    volume = fields["volume"]
+    return cs_scale(ts_corr(ts_mean(volume, 20), low, 5) + (high + low) / 2 - close)
+
+
+def alpha101_alpha29(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha29 特征。"""
+    close = fields["close"]
+    return ts_min(
+        ts_product(
+            cs_rank(
+                cs_rank(
+                    cs_scale(
+                        log(
+                            ts_sum(
+                                ts_min(cs_rank(cs_rank(-1 * cs_rank(ts_delta((close - 1), 5)))), 2),
+                                1,
+                            )
+                        )
+                    )
+                )
+            ),
+            1,
+        ),
+        5,
+    ) + ts_rank(ts_delay((-1 * (close / ts_delay(close, 1) - 1)), 6), 5)
+
+
+def alpha101_alpha30(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha30 特征。"""
+    close = fields["close"]
+    volume = fields["volume"]
+    return (
+        (
+            cs_rank(
+                sign(close - ts_delay(close, 1))
+                + sign(ts_delay(close, 1) - ts_delay(close, 2))
+                + sign(ts_delay(close, 2) - ts_delay(close, 3))
+            )
+            * -1
+            + 1
+        )
+        * ts_sum(volume, 5)
+    ) / ts_sum(volume, 20)
+
+
+def alpha101_alpha31(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha31 特征。"""
+    close = fields["close"]
+    low = fields["low"]
+    volume = fields["volume"]
+    return (
+        cs_rank(cs_rank(cs_rank(ts_decay_linear((-1) * cs_rank(cs_rank(ts_delta(close, 10))), 10))))
+        + cs_rank((-1) * ts_delta(close, 3))
+    ) + sign(cs_scale(ts_corr(ts_mean(volume, 20), low, 12)))
+
+
+def alpha101_alpha32(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha32 特征。"""
+    close = fields["close"]
+    vwap = fields["vwap"]
+    return cs_scale(ts_sum(close, 7) / 7 - close) + (
+        20 * cs_scale(ts_corr(vwap, ts_delay(close, 5), 230))
+    )
+
+
+def alpha101_alpha33(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha33 特征。"""
+    close = fields["close"]
+    open = fields["open"]
+    return cs_rank((-1) * (open / close * -1 + 1))
+
+
+def alpha101_alpha34(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha34 特征。"""
+    close = fields["close"]
+    return cs_rank(
+        (
+            cs_rank(
+                ts_std((close / ts_delay(close, 1) - 1), 2)
+                / ts_std((close / ts_delay(close, 1) - 1), 5)
+            )
+            * -1
+            + 1
+        )
+        + (cs_rank(ts_delta(close, 1)) * -1 + 1)
+    )
+
+
+def alpha101_alpha35(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha35 特征。"""
+    close = fields["close"]
+    high = fields["high"]
+    low = fields["low"]
+    volume = fields["volume"]
+    return (ts_rank(volume, 32) * (ts_rank((close + high - low), 16) * -1 + 1)) * (
+        ts_rank((close / ts_delay(close, 1) - 1), 32) * -1 + 1
+    )
+
+
+def alpha101_alpha36(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha36 特征。"""
+    close = fields["close"]
+    open = fields["open"]
+    volume = fields["volume"]
+    vwap = fields["vwap"]
+    return (
+        (
+            (
+                (2.21 * cs_rank(ts_corr((close - open), ts_delay(volume, 1), 15)))
+                + (0.7 * cs_rank((open - close)))
+            )
+            + (0.73 * cs_rank(ts_rank(ts_delay((-1) * (close / ts_delay(close, 1) - 1), 6), 5)))
+        )
+        + cs_rank(abs(ts_corr(vwap, ts_mean(volume, 20), 6)))
+    ) + (0.6 * cs_rank((ts_sum(close, 200) / 200 - open) * (close - open)))
+
+
+def alpha101_alpha37(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha37 特征。"""
+    close = fields["close"]
+    open = fields["open"]
+    return cs_rank(ts_corr(ts_delay((open - close), 1), close, 200)) + cs_rank(open - close)
+
+
+def alpha101_alpha38(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha38 特征。"""
+    close = fields["close"]
+    open = fields["open"]
+    return ((-1) * cs_rank(ts_rank(close, 10))) * cs_rank(close / open)
+
+
+def alpha101_alpha39(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha39 特征。"""
+    close = fields["close"]
+    volume = fields["volume"]
+    return (
+        (-1)
+        * cs_rank(
+            ts_delta(close, 7)
+            * (cs_rank(ts_decay_linear((volume / ts_mean(volume, 20)), 9)) * -1 + 1)
+        )
+    ) * (cs_rank(ts_sum((close / ts_delay(close, 1) - 1), 250)) + 1)
+
+
+def alpha101_alpha40(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha40 特征。"""
+    high = fields["high"]
+    volume = fields["volume"]
+    return ((-1) * cs_rank(ts_std(high, 10))) * ts_corr(high, volume, 10)
+
+
+def alpha101_alpha41(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha41 特征。"""
+    high = fields["high"]
+    low = fields["low"]
+    vwap = fields["vwap"]
+    return pow1((high * low), 0.5) - vwap
+
+
+def alpha101_alpha42(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha42 特征。"""
+    close = fields["close"]
+    vwap = fields["vwap"]
+    return cs_rank(vwap - close) / cs_rank(vwap + close)
+
+
+def alpha101_alpha43(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha43 特征。"""
+    close = fields["close"]
+    volume = fields["volume"]
+    return ts_rank((volume / ts_mean(volume, 20)), 20) * ts_rank((-1) * ts_delta(close, 7), 8)
+
+
+def alpha101_alpha44(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha44 特征。"""
+    high = fields["high"]
+    volume = fields["volume"]
+    return (-1) * ts_corr(high, cs_rank(volume), 5)
+
+
+def alpha101_alpha45(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha45 特征。"""
+    close = fields["close"]
+    volume = fields["volume"]
+    return (
+        (-1)
+        * cs_rank(ts_sum(ts_delay(close, 5), 20) / 20)
+        * ts_corr(close, volume, 2)
+        * cs_rank(ts_corr(ts_sum(close, 5), ts_sum(close, 20), 2))
+    )
+
+
+def alpha101_alpha46(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha46 特征。"""
+    close = fields["close"]
+    return quesval(
+        0.25,
+        ((ts_delay(close, 20) - ts_delay(close, 10)) / 10 - (ts_delay(close, 10) - close) / 10),
+        -1,
+        quesval(
+            0,
+            ((ts_delay(close, 20) - ts_delay(close, 10)) / 10 - (ts_delay(close, 10) - close) / 10),
+            (-1) * (close - ts_delay(close, 1)),
+            1,
+        ),
+    )
+
+
+def alpha101_alpha47(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha47 特征。"""
+    close = fields["close"]
+    high = fields["high"]
+    volume = fields["volume"]
+    vwap = fields["vwap"]
+    return (
+        (cs_rank(pow1(close, -1)) * volume / ts_mean(volume, 20))
+        * (high * cs_rank(high - close))
+        / (ts_sum(high, 5) / 5)
+    ) - cs_rank(vwap - ts_delay(vwap, 5))
+
+
+def alpha101_alpha49(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha49 特征。"""
+    close = fields["close"]
+    return quesval(
+        -0.1,
+        ((ts_delay(close, 20) - ts_delay(close, 10)) / 10 - (ts_delay(close, 10) - close) / 10),
+        (-1) * (close - ts_delay(close, 1)),
+        1,
+    )
+
+
+def alpha101_alpha50(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha50 特征。"""
+    volume = fields["volume"]
+    vwap = fields["vwap"]
+    return (-1) * ts_max(cs_rank(ts_corr(cs_rank(volume), cs_rank(vwap), 5)), 5)
+
+
+def alpha101_alpha51(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha51 特征。"""
+    close = fields["close"]
+    return quesval(
+        -0.05,
+        ((ts_delay(close, 20) - ts_delay(close, 10)) / 10 - (ts_delay(close, 10) - close) / 10),
+        (-1) * (close - ts_delay(close, 1)),
+        1,
+    )
+
+
+def alpha101_alpha52(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha52 特征。"""
+    close = fields["close"]
+    low = fields["low"]
+    volume = fields["volume"]
+    return (
+        (((-1) * ts_min(low, 5)) + ts_delay(ts_min(low, 5), 5))
+        * cs_rank(
+            (
+                ts_sum((close / ts_delay(close, 1) - 1), 240)
+                - ts_sum((close / ts_delay(close, 1) - 1), 20)
+            )
+            / 220
+        )
+        * ts_rank(volume, 5)
+    )
+
+
+def alpha101_alpha53(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha53 特征。"""
+    close = fields["close"]
+    high = fields["high"]
+    low = fields["low"]
+    return (-1) * ts_delta(((close - low) - (high - close)) / (close - low), 9)
+
+
+def alpha101_alpha54(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha54 特征。"""
+    close = fields["close"]
+    high = fields["high"]
+    low = fields["low"]
+    open = fields["open"]
+    return ((-1) * ((low - close) * pow1(open, 5))) / ((low - high) * pow1(close, 5))
+
+
+def alpha101_alpha55(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha55 特征。"""
+    close = fields["close"]
+    high = fields["high"]
+    low = fields["low"]
+    volume = fields["volume"]
+    return (-1) * ts_corr(
+        cs_rank((close - ts_min(low, 12)) / (ts_max(high, 12) - ts_min(low, 12))),
+        cs_rank(volume),
+        6,
+    )
+
+
+def alpha101_alpha57(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha57 特征。"""
+    close = fields["close"]
+    vwap = fields["vwap"]
+    return -1 * ((close - vwap) / ts_decay_linear(cs_rank(ts_argmax(close, 30)), 2))
+
+
+def alpha101_alpha60(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha60 特征。"""
+    close = fields["close"]
+    high = fields["high"]
+    low = fields["low"]
+    volume = fields["volume"]
+    return -1 * (
+        (2 * cs_scale(cs_rank((((close - low) - (high - close)) / (high - low)) * volume)))
+        - cs_scale(cs_rank(ts_argmax(close, 10)))
+    )
+
+
+def alpha101_alpha61(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha61 特征。"""
+    volume = fields["volume"]
+    vwap = fields["vwap"]
+    return quesval2(
+        cs_rank(vwap - ts_min(vwap, 16)), cs_rank(ts_corr(vwap, ts_mean(volume, 180), 18)), 1, 0
+    )
+
+
+def alpha101_alpha62(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha62 特征。"""
+    high = fields["high"]
+    low = fields["low"]
+    open = fields["open"]
+    volume = fields["volume"]
+    vwap = fields["vwap"]
+    return (
+        cs_rank(ts_corr(vwap, ts_sum(ts_mean(volume, 20), 22), 10))
+        < cs_rank((cs_rank(open) + cs_rank(open)) < (cs_rank((high + low) / 2) + cs_rank(high)))
+    ) * -1
+
+
+def alpha101_alpha64(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha64 特征。"""
+    high = fields["high"]
+    low = fields["low"]
+    open = fields["open"]
+    volume = fields["volume"]
+    vwap = fields["vwap"]
+    return (
+        cs_rank(
+            ts_corr(
+                ts_sum(((open * 0.178404) + (low * (1 - 0.178404))), 13),
+                ts_sum(ts_mean(volume, 120), 13),
+                17,
+            )
+        )
+        < cs_rank(ts_delta((((high + low) / 2 * 0.178404) + (vwap * (1 - 0.178404))), 4))
+    ) * -1
+
+
+def alpha101_alpha65(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha65 特征。"""
+    open = fields["open"]
+    volume = fields["volume"]
+    vwap = fields["vwap"]
+    return (
+        cs_rank(
+            ts_corr(
+                ((open * 0.00817205) + (vwap * (1 - 0.00817205))), ts_sum(ts_mean(volume, 60), 9), 6
+            )
+        )
+        < cs_rank(open - ts_min(open, 14))
+    ) * -1
+
+
+def alpha101_alpha66(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha66 特征。"""
+    high = fields["high"]
+    low = fields["low"]
+    open = fields["open"]
+    vwap = fields["vwap"]
+    return (
+        cs_rank(ts_decay_linear(ts_delta(vwap, 4), 7))
+        + ts_rank(
+            ts_decay_linear(
+                (((low * 0.96633) + (low * (1 - 0.96633))) - vwap) / (open - ((high + low) / 2)), 11
+            ),
+            7,
+        )
+    ) * -1
+
+
+def alpha101_alpha68(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha68 特征。"""
+    close = fields["close"]
+    high = fields["high"]
+    low = fields["low"]
+    volume = fields["volume"]
+    return (
+        ts_rank(ts_corr(cs_rank(high), cs_rank(ts_mean(volume, 15)), 9), 14)
+        < cs_rank(ts_delta((close * 0.518371 + low * (1 - 0.518371)), 1))
+    ) * -1
+
+
+def alpha101_alpha71(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha71 特征。"""
+    close = fields["close"]
+    low = fields["low"]
+    open = fields["open"]
+    volume = fields["volume"]
+    vwap = fields["vwap"]
+    return ts_greater(
+        ts_rank(
+            ts_decay_linear(ts_corr(ts_rank(close, 3), ts_rank(ts_mean(volume, 180), 12), 18), 4),
+            16,
+        ),
+        ts_rank(ts_decay_linear(pow1(cs_rank((low + open) - (vwap + vwap)), 2), 16), 4),
+    )
+
+
+def alpha101_alpha72(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha72 特征。"""
+    high = fields["high"]
+    low = fields["low"]
+    volume = fields["volume"]
+    vwap = fields["vwap"]
+    return cs_rank(
+        ts_decay_linear(ts_corr((high + low) / 2, ts_mean(volume, 40), 9), 10)
+    ) / cs_rank(ts_decay_linear(ts_corr(ts_rank(vwap, 4), ts_rank(volume, 19), 7), 3))
+
+
+def alpha101_alpha73(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha73 特征。"""
+    low = fields["low"]
+    open = fields["open"]
+    vwap = fields["vwap"]
+    return (
+        ts_greater(
+            cs_rank(ts_decay_linear(ts_delta(vwap, 5), 3)),
+            ts_rank(
+                ts_decay_linear(
+                    (
+                        ts_delta(open * 0.147155 + low * 0.852845, 2)
+                        / (open * 0.147155 + low * 0.852845)
+                    )
+                    * -1,
+                    3,
+                ),
+                17,
+            ),
+        )
+        * -1
+    )
+
+
+def alpha101_alpha74(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha74 特征。"""
+    close = fields["close"]
+    high = fields["high"]
+    volume = fields["volume"]
+    vwap = fields["vwap"]
+    return (
+        quesval2(
+            cs_rank(ts_corr(close, ts_sum(ts_mean(volume, 30), 37), 15)),
+            cs_rank(ts_corr(cs_rank(high * 0.0261661 + vwap * 0.9738339), cs_rank(volume), 11)),
+            1,
+            0,
+        )
+        * -1
+    )
+
+
+def alpha101_alpha75(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha75 特征。"""
+    low = fields["low"]
+    volume = fields["volume"]
+    vwap = fields["vwap"]
+    return quesval2(
+        cs_rank(ts_corr(vwap, volume, 4)),
+        cs_rank(ts_corr(cs_rank(low), cs_rank(ts_mean(volume, 50)), 12)),
+        1,
+        0,
+    )
+
+
+def alpha101_alpha77(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha77 特征。"""
+    high = fields["high"]
+    low = fields["low"]
+    volume = fields["volume"]
+    vwap = fields["vwap"]
+    return ts_less(
+        cs_rank(ts_decay_linear((((high + low) / 2 + high) - (vwap + high)), 20)),
+        cs_rank(ts_decay_linear(ts_corr((high + low) / 2, ts_mean(volume, 40), 3), 6)),
+    )
+
+
+def alpha101_alpha78(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha78 特征。"""
+    low = fields["low"]
+    volume = fields["volume"]
+    vwap = fields["vwap"]
+    return pow2(
+        cs_rank(
+            ts_corr(
+                ts_sum((low * 0.352233) + (vwap * (1 - 0.352233)), 20),
+                ts_sum(ts_mean(volume, 40), 20),
+                7,
+            )
+        ),
+        cs_rank(ts_corr(cs_rank(vwap), cs_rank(volume), 6)),
+    )
+
+
+def alpha101_alpha81(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha81 特征。"""
+    volume = fields["volume"]
+    vwap = fields["vwap"]
+    return (
+        quesval2(
+            cs_rank(
+                log(
+                    ts_product(
+                        cs_rank(
+                            pow1(cs_rank(ts_corr(vwap, ts_sum(ts_mean(volume, 10), 50), 8)), 4)
+                        ),
+                        15,
+                    )
+                )
+            ),
+            cs_rank(ts_corr(cs_rank(vwap), cs_rank(volume), 5)),
+            1,
+            0,
+        )
+        * -1
+    )
+
+
+def alpha101_alpha83(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha83 特征。"""
+    close = fields["close"]
+    high = fields["high"]
+    low = fields["low"]
+    volume = fields["volume"]
+    vwap = fields["vwap"]
+    return (
+        cs_rank(ts_delay((high - low) / (ts_sum(close, 5) / 5), 2)) * cs_rank(cs_rank(volume))
+    ) / (((high - low) / (ts_sum(close, 5) / 5)) / (vwap - close))
+
+
+def alpha101_alpha84(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha84 特征。"""
+    close = fields["close"]
+    vwap = fields["vwap"]
+    return pow2(ts_rank(vwap - ts_max(vwap, 15), 21), ts_delta(close, 5))
+
+
+def alpha101_alpha85(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha85 特征。"""
+    close = fields["close"]
+    high = fields["high"]
+    low = fields["low"]
+    volume = fields["volume"]
+    return pow2(
+        cs_rank(ts_corr(high * 0.876703 + close * 0.123297, ts_mean(volume, 30), 10)),
+        cs_rank(ts_corr(ts_rank((high + low) / 2, 4), ts_rank(volume, 10), 7)),
+    )
+
+
+def alpha101_alpha86(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha86 特征。"""
+    close = fields["close"]
+    open = fields["open"]
+    volume = fields["volume"]
+    vwap = fields["vwap"]
+    return (
+        quesval2(
+            ts_rank(ts_corr(close, ts_sum(ts_mean(volume, 20), 15), 6), 20),
+            cs_rank((open + close) - (vwap + open)),
+            1,
+            0,
+        )
+        * -1
+    )
+
+
+def alpha101_alpha88(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha88 特征。"""
+    close = fields["close"]
+    high = fields["high"]
+    low = fields["low"]
+    open = fields["open"]
+    volume = fields["volume"]
+    return ts_less(
+        cs_rank(
+            ts_decay_linear((cs_rank(open) + cs_rank(low)) - (cs_rank(high) + cs_rank(close)), 8)
+        ),
+        ts_rank(
+            ts_decay_linear(ts_corr(ts_rank(close, 8), ts_rank(ts_mean(volume, 60), 21), 8), 7), 3
+        ),
+    )
+
+
+def alpha101_alpha92(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha92 特征。"""
+    close = fields["close"]
+    high = fields["high"]
+    low = fields["low"]
+    open = fields["open"]
+    volume = fields["volume"]
+    return ts_less(
+        ts_rank(ts_decay_linear(quesval2(((high + low) / 2 + close), (low + open), 1, 0), 15), 19),
+        ts_rank(ts_decay_linear(ts_corr(cs_rank(low), cs_rank(ts_mean(volume, 30)), 8), 7), 7),
+    )
+
+
+def alpha101_alpha94(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha94 特征。"""
+    volume = fields["volume"]
+    vwap = fields["vwap"]
+    return (
+        pow2(
+            cs_rank(vwap - ts_min(vwap, 12)),
+            ts_rank(ts_corr(ts_rank(vwap, 20), ts_rank(ts_mean(volume, 60), 4), 18), 3),
+        )
+        * -1
+    )
+
+
+def alpha101_alpha95(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha95 特征。"""
+    high = fields["high"]
+    low = fields["low"]
+    open = fields["open"]
+    volume = fields["volume"]
+    return quesval2(
+        cs_rank(open - ts_min(open, 12)),
+        ts_rank(
+            pow1(
+                cs_rank(ts_corr(ts_sum((high + low) / 2, 19), ts_sum(ts_mean(volume, 40), 19), 13)),
+                5,
+            ),
+            12,
+        ),
+        1,
+        0,
+    )
+
+
+def alpha101_alpha96(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha96 特征。"""
+    close = fields["close"]
+    volume = fields["volume"]
+    vwap = fields["vwap"]
+    return (
+        ts_greater(
+            ts_rank(ts_decay_linear(ts_corr(cs_rank(vwap), cs_rank(volume), 4), 4), 8),
+            ts_rank(
+                ts_decay_linear(
+                    ts_argmax(ts_corr(ts_rank(close, 7), ts_rank(ts_mean(volume, 60), 4), 4), 13),
+                    14,
+                ),
+                13,
+            ),
+        )
+        * -1
+    )
+
+
+def alpha101_alpha98(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha98 特征。"""
+    open = fields["open"]
+    volume = fields["volume"]
+    vwap = fields["vwap"]
+    return cs_rank(ts_decay_linear(ts_corr(vwap, ts_sum(ts_mean(volume, 5), 26), 5), 7)) - cs_rank(
+        ts_decay_linear(
+            ts_rank(ts_argmin(ts_corr(cs_rank(open), cs_rank(ts_mean(volume, 15)), 21), 9), 7), 8
+        )
+    )
+
+
+def alpha101_alpha99(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha99 特征。"""
+    high = fields["high"]
+    low = fields["low"]
+    volume = fields["volume"]
+    return (
+        quesval2(
+            cs_rank(ts_corr(ts_sum((high + low) / 2, 20), ts_sum(ts_mean(volume, 60), 20), 9)),
+            cs_rank(ts_corr(low, volume, 6)),
+            1,
+            0,
+        )
+        * -1
+    )
+
+
+def alpha101_alpha101(fields: dict[str, PanelExpression]) -> PanelExpression:
+    """固定参考版本的 alpha101/alpha101 特征。"""
+    close = fields["close"]
+    high = fields["high"]
+    low = fields["low"]
+    open = fields["open"]
+    return (close - open) / ((high - low) + 0.001)
+
+
+ALPHA101_RECIPES: dict[
+    str, tuple[Callable[[dict[str, PanelExpression]], PanelExpression], int, tuple[str, ...]]
+] = {
+    "alpha101_alpha1": (alpha101_alpha1, 25, ("close",)),
+    "alpha101_alpha2": (alpha101_alpha2, 8, ("close", "open", "volume")),
+    "alpha101_alpha3": (alpha101_alpha3, 10, ("open", "volume")),
+    "alpha101_alpha4": (alpha101_alpha4, 9, ("low",)),
+    "alpha101_alpha5": (alpha101_alpha5, 10, ("close", "open", "vwap")),
+    "alpha101_alpha6": (alpha101_alpha6, 10, ("open", "volume")),
+    "alpha101_alpha7": (alpha101_alpha7, 67, ("close", "volume")),
+    "alpha101_alpha8": (alpha101_alpha8, 16, ("close", "open")),
+    "alpha101_alpha9": (alpha101_alpha9, 6, ("close",)),
+    "alpha101_alpha10": (alpha101_alpha10, 5, ("close",)),
+    "alpha101_alpha11": (alpha101_alpha11, 4, ("close", "volume", "vwap")),
+    "alpha101_alpha12": (alpha101_alpha12, 2, ("close", "volume")),
+    "alpha101_alpha13": (alpha101_alpha13, 5, ("close", "volume")),
+    "alpha101_alpha14": (alpha101_alpha14, 10, ("close", "open", "volume")),
+    "alpha101_alpha15": (alpha101_alpha15, 5, ("high", "volume")),
+    "alpha101_alpha16": (alpha101_alpha16, 5, ("high", "volume")),
+    "alpha101_alpha17": (alpha101_alpha17, 24, ("close", "volume")),
+    "alpha101_alpha18": (alpha101_alpha18, 10, ("close", "open")),
+    "alpha101_alpha19": (alpha101_alpha19, 251, ("close",)),
+    "alpha101_alpha20": (alpha101_alpha20, 2, ("close", "high", "low", "open")),
+    "alpha101_alpha21": (alpha101_alpha21, 20, ("close", "volume")),
+    "alpha101_alpha22": (alpha101_alpha22, 20, ("close", "high", "volume")),
+    "alpha101_alpha23": (alpha101_alpha23, 20, ("high",)),
+    "alpha101_alpha24": (alpha101_alpha24, 200, ("close",)),
+    "alpha101_alpha25": (alpha101_alpha25, 20, ("close", "high", "volume", "vwap")),
+    "alpha101_alpha26": (alpha101_alpha26, 11, ("high", "volume")),
+    "alpha101_alpha27": (alpha101_alpha27, 7, ("volume", "vwap")),
+    "alpha101_alpha28": (alpha101_alpha28, 24, ("close", "high", "low", "volume")),
+    "alpha101_alpha29": (alpha101_alpha29, 12, ("close",)),
+    "alpha101_alpha30": (alpha101_alpha30, 20, ("close", "volume")),
+    "alpha101_alpha31": (alpha101_alpha31, 31, ("close", "low", "volume")),
+    "alpha101_alpha32": (alpha101_alpha32, 235, ("close", "vwap")),
+    "alpha101_alpha33": (alpha101_alpha33, 1, ("close", "open")),
+    "alpha101_alpha34": (alpha101_alpha34, 6, ("close",)),
+    "alpha101_alpha35": (alpha101_alpha35, 33, ("close", "high", "low", "volume")),
+    "alpha101_alpha36": (alpha101_alpha36, 200, ("close", "open", "volume", "vwap")),
+    "alpha101_alpha37": (alpha101_alpha37, 201, ("close", "open")),
+    "alpha101_alpha38": (alpha101_alpha38, 10, ("close", "open")),
+    "alpha101_alpha39": (alpha101_alpha39, 251, ("close", "volume")),
+    "alpha101_alpha40": (alpha101_alpha40, 10, ("high", "volume")),
+    "alpha101_alpha41": (alpha101_alpha41, 1, ("high", "low", "vwap")),
+    "alpha101_alpha42": (alpha101_alpha42, 1, ("close", "vwap")),
+    "alpha101_alpha43": (alpha101_alpha43, 39, ("close", "volume")),
+    "alpha101_alpha44": (alpha101_alpha44, 5, ("high", "volume")),
+    "alpha101_alpha45": (alpha101_alpha45, 25, ("close", "volume")),
+    "alpha101_alpha46": (alpha101_alpha46, 21, ("close",)),
+    "alpha101_alpha47": (alpha101_alpha47, 20, ("close", "high", "volume", "vwap")),
+    "alpha101_alpha49": (alpha101_alpha49, 21, ("close",)),
+    "alpha101_alpha50": (alpha101_alpha50, 9, ("volume", "vwap")),
+    "alpha101_alpha51": (alpha101_alpha51, 21, ("close",)),
+    "alpha101_alpha52": (alpha101_alpha52, 241, ("close", "low", "volume")),
+    "alpha101_alpha53": (alpha101_alpha53, 10, ("close", "high", "low")),
+    "alpha101_alpha54": (alpha101_alpha54, 1, ("close", "high", "low", "open")),
+    "alpha101_alpha55": (alpha101_alpha55, 17, ("close", "high", "low", "volume")),
+    "alpha101_alpha57": (alpha101_alpha57, 31, ("close", "vwap")),
+    "alpha101_alpha60": (alpha101_alpha60, 10, ("close", "high", "low", "volume")),
+    "alpha101_alpha61": (alpha101_alpha61, 197, ("volume", "vwap")),
+    "alpha101_alpha62": (alpha101_alpha62, 50, ("high", "low", "open", "volume", "vwap")),
+    "alpha101_alpha64": (alpha101_alpha64, 148, ("high", "low", "open", "volume", "vwap")),
+    "alpha101_alpha65": (alpha101_alpha65, 73, ("open", "volume", "vwap")),
+    "alpha101_alpha66": (alpha101_alpha66, 17, ("high", "low", "open", "vwap")),
+    "alpha101_alpha68": (alpha101_alpha68, 36, ("close", "high", "low", "volume")),
+    "alpha101_alpha71": (alpha101_alpha71, 226, ("close", "low", "open", "volume", "vwap")),
+    "alpha101_alpha72": (alpha101_alpha72, 57, ("high", "low", "volume", "vwap")),
+    "alpha101_alpha73": (alpha101_alpha73, 21, ("low", "open", "vwap")),
+    "alpha101_alpha74": (alpha101_alpha74, 80, ("close", "high", "volume", "vwap")),
+    "alpha101_alpha75": (alpha101_alpha75, 61, ("low", "volume", "vwap")),
+    "alpha101_alpha77": (alpha101_alpha77, 47, ("high", "low", "volume", "vwap")),
+    "alpha101_alpha78": (alpha101_alpha78, 65, ("low", "volume", "vwap")),
+    "alpha101_alpha81": (alpha101_alpha81, 80, ("volume", "vwap")),
+    "alpha101_alpha83": (alpha101_alpha83, 7, ("close", "high", "low", "volume", "vwap")),
+    "alpha101_alpha84": (alpha101_alpha84, 35, ("close", "vwap")),
+    "alpha101_alpha85": (alpha101_alpha85, 39, ("close", "high", "low", "volume")),
+    "alpha101_alpha86": (alpha101_alpha86, 58, ("close", "open", "volume", "vwap")),
+    "alpha101_alpha88": (alpha101_alpha88, 95, ("close", "high", "low", "open", "volume")),
+    "alpha101_alpha92": (alpha101_alpha92, 49, ("close", "high", "low", "open", "volume")),
+    "alpha101_alpha94": (alpha101_alpha94, 82, ("volume", "vwap")),
+    "alpha101_alpha95": (alpha101_alpha95, 81, ("high", "low", "open", "volume")),
+    "alpha101_alpha96": (alpha101_alpha96, 103, ("close", "volume", "vwap")),
+    "alpha101_alpha98": (alpha101_alpha98, 56, ("open", "volume", "vwap")),
+    "alpha101_alpha99": (alpha101_alpha99, 87, ("high", "low", "volume")),
+    "alpha101_alpha101": (alpha101_alpha101, 1, ("close", "high", "low", "open")),
+}