第 27 篇：从零写一个正确的回测引擎

btc = D.load_binance_klines(glob.glob("data/binance/spot/BTCUSDT/1d/*.zip"))
close = btc["close"]
signal = ((I.sma(close, 50) > I.sma(close, 200)) & (close >= close.rolling(20).max())).fillna(False)
# ← 这一行
returns = signal * close.pct_change()
equity = (1 + returns.fillna(0)).cumprod()
print(f"{len(btc)} 根日线，{btc.index[0].date()} 到 {btc.index[-1].date()}，持仓 {signal.mean():.1%} 的日子")
print(f"年化 {equity.iloc[-1] ** (365 / len(equity)) - 1:.2%}")
print(f"最大回撤 {(equity / equity.cummax() - 1).min():.2%}")
print(f"期末是本金的 {equity.iloc[-1]:,.1f} 倍")
held = returns[signal]
print(f"持仓的 {len(held)} 根 K 线里，上涨的有 {(held > 0).mean():.2%}")

3302 根日线，2017-08-17 到 2026-08-31，持仓 6.8% 的日子
年化 132.69%
最大回撤 0.00%
期末是本金的 2,080.0 倍
持仓的 226 根 K 线里，上涨的有 100.00%

 推迟根数     年化    最大回撤  持仓根里上涨的比例
    0 1.3269  0.0000     1.0000
    1 0.1426 -0.2257     0.5000
    2 0.1799 -0.1637     0.5487
    3 0.1390 -0.1782     0.5221

推迟一根就从 132.69% 塌到 14.26%，而推迟两根、三根都在同一个量级——
真策略赚的是「信号之后价格接着走」，推迟一根只会温和地变差；
这里塌掉的那一截，是**信号当根自己的涨幅**，而那一根正是算出信号的原料。

     这一根上的数          什么时候知道 能用来下这一根的单吗
   开盘价 open          这一根刚开始          能
   最高价 high           这一根结束         不能
    最低价 low           这一根结束         不能
  收盘价 close           这一根结束         不能
均线、ATR、RSI… 这一根结束（它们都用到收盘价）         不能

所以那条时钟规矩只有一句话：**第 i 根收盘时算出来的东西，最早只能在第 i+1 根上成交。**

returns = signal * close.pct_change()

def vectorized(close: pd.Series, position: pd.Series, lag: int = 1, fee_rate: float = 0.0) -> pd.Series:
    """向量化回测：仓位乘以收益，一行就算完。

    `position` 是**收盘时算出来的目标仓位**（0 到 1）。`lag=1` 表示它最早在下一根生效——
    这是本模块的时钟规矩。写 `lag=0` 就是声称「今天收盘才算得出来的仓位，今天一整天都拿着」，
    也就是第 27 篇决策点里那一行错误代码。

    手续费按仓位变化收：仓位从 0 变 1 收一次，从 1 变 0 再收一次。
    """
    if lag < 0:
        raise ValueError("lag 不能是负数（那是明目张胆地用未来）")
    held = position.reindex(close.index).fillna(0.0).shift(lag).fillna(0.0)
    turnover = held.diff().abs().fillna(held.abs())
    return (held * close.pct_change().fillna(0.0) - turnover * fee_rate).rename("收益")

lag=0：年化  132.69%  最大回撤    0.00%  期末   2,080.03 倍
lag=1：年化   14.26%  最大回撤  -22.57%  期末       3.34 倍

leave = I.cross_below(I.sma(close, 50), I.sma(close, 200)).fillna(False)
state = pd.Series(np.nan, index=btc.index)
state[signal] = 1.0                                       # 信号成立：目标仓位 1
state[leave] = 0.0                                        # 死叉：目标仓位 0
position = state.ffill().fillna(0.0)                      # 中间的日子沿用上一个状态
vector = (1 + BT.vectorized(close, position, lag=1)).cumprod()
event = BT.run(btc, BT.Plan(entry=signal, exit=leave, fill="close", stop="none", sizing="full"), EQUITY)
event_curve = event["资金曲线"] / EQUITY
print(f"向量化：终值 {vector.iloc[-1]:.6f} 倍，在场 {(position.shift(1) > 0).mean():.2%}")
print(f"事件驱动：终值 {event_curve.iloc[-1]:.6f} 倍，{len(event['交易'])} 笔交易，记账误差 {event['记账误差']:.1e}")
print(f"两条曲线的最大差额：{(event_curve - vector.reindex(event_curve.index)).abs().max():.3e}")

向量化：终值 5.219386 倍，在场 46.03%
事件驱动：终值 5.219386 倍，8 笔交易，记账误差 0.0e+00
两条曲线的最大差额：2.487e-14

class Account:
    """一个自洽的账本：任何时刻 **现金 + 持仓数量 × 价格 = 权益**。

    `rules.run` 只算收益率，永远「买得起」。真实账户不是：手续费从现金里扣，
    扣完之后能买的数量就少了一点点，这一点点会随着交易次数复利。
    """
    cash: float
    shares: float = 0.0
    fees: float = 0.0

    def equity(self, price: float) -> float:
        return self.cash + self.shares * price

    def affordable(self, price: float, fee_rate: float = 0.0) -> float:
        """现金最多买得起多少（把手续费也算进去）。"""
        return self.cash / (price * (1 + fee_rate))

    def buy(self, price: float, shares: float, fee_rate: float = 0.0) -> float:
        cost = shares * price
        fee = cost * fee_rate
        if cost + fee > self.cash + 1e-9:
            raise ValueError(f"现金不够：要 {cost + fee:.2f}，只有 {self.cash:.2f}")
        self.cash -= cost + fee
        self.shares += shares
        self.fees += fee
        return fee

开局：现金 100,000.00，持仓 0.0，权益 100,000.00
以 100 买入（单边费率 0.1%）：现金 0.000000，持仓 999.0010 股，权益 99,900.10，已付手续费 99.90
以 110 全部卖出：现金 109,780.22，权益 109,780.22，手续费合计 209.79
价格涨了 10%，账户只涨了 9.7802%——差的就是两次手续费
买超过现金会直接报错：现金不够：要 2000.00，只有 1000.00

    for i in range(first, len(c)):
        # 第 1 步：成交上一根挂出的单
        if pending and account.shares == 0:
            price = o[i] if plan.fill == "next_open" else c[i - 1]
            level = (price * (1 - plan.stop_percent) if plan.stop == "percent"
                     else price - plan.k * atr[i - 1] if plan.stop == "chandelier" else -np.inf)
            if level < price:
                distance = 1 - level / price
                want = (account.equity(price) if plan.sizing == "full"
                        else account.equity(price) * min(1.0, plan.risk_per_trade / max(distance, 1e-9)))
                shares = min(want / price, account.affordable(price, plan.fee_rate))
                if shares > 0:
                    account.buy(price, shares, plan.fee_rate)
                    entry_price, entry_i, risk = price, i, price - level
                    highest, stop_price = price, level
            pending = False

        # 第 2 步：出场
        if account.shares > 0:
            stop_price = stop_level(i, stop_price)
            target = entry_price + plan.target_r * risk if plan.target_r is not None else np.inf
            price = reason = None
            if leave[i - 1] and i > entry_i:                      # 昨天收盘的出场信号，今天成交
                price, reason = (o[i] if plan.fill == "next_open" else c[i - 1]), "出场信号"
            elif plan.trigger == "close":
                if c[i] <= stop_price:
                    price, reason = c[i], "止损"
                elif c[i] >= target:
                    price, reason = c[i], "止盈"
            else:
                bar = {"low": l[i], "high": h[i]}
                touched = first_touch(bar, stop_price, target, plan.path, rng)
                if touched == "止损":
                    price, reason = min(o[i], stop_price), "止损"
                elif touched == "止盈":
                    price, reason = max(o[i], target), "止盈"
            if reason is not None:
                shares = account.shares
                account.sell(price, shares, plan.fee_rate)
                trades.append({"买入日": df.index[entry_i], "买入价": entry_price, "数量": shares,
                               "卖出日": df.index[i], "卖出价": price, "原因": reason,
                               "收益": price / entry_price - 1, "根数": i - entry_i})
            else:
                highest = max(highest, h[i])

        # 第 3 步：估值
        value = account.equity(c[i])
        error = max(error, abs(account.cash + account.shares * c[i] - value))
        curve.append(value)
        cash_path.append(account.cash)
        share_path.append(account.shares)

        # 第 4 步：用这一根收盘的信息下单，最早下一根成交
        if account.shares == 0 and not pending and signal[i]:
            pending = True

        value = account.equity(c[i])
        error = max(error, abs(account.cash + account.shares * c[i] - value))

 标的       仓位  rules.run 交易数  backtest.run 交易数  rules.run 终值  backtest.run 终值  两条曲线最大差额  记账误差
SPY       满仓             39                39      1.336100         1.336100  0.000000   0.0
SPY 每笔风险 10%             39                39      1.336100         1.336100  0.000000   0.0
BTC       满仓             30                30      4.629012         4.629012  0.000000   0.0
BTC 每笔风险 10%             30                30      5.791251         5.818177  0.113952   0.0

挑一笔仓位没顶到满仓的：2021-02-04 以 37,620.26 买入，持有 21 根，涨了 25.13%
  按计划，这笔的仓位占权益 39.69%（= min(1, 10% ÷ 止损距离)）
  出场前一根，数量一股没动，但仓位占权益变成了 46.49%——是价格涨上去的
  `rules.run` 里这个比例始终是 39.69%：它每根 K 线都把仓位调回目标比例

九年下来的差额：rules.run 终值 5.7913 倍，backtest.run 5.8182 倍，差 0.46%
两个引擎都能自圆其说，但只有一个对得上真实账户：**你不会每天把仓位调回 39%。**

def first_touch(bar, stop: float, target: float, path: str = "pessimistic",
                rng: np.random.Generator | None = None) -> str:
    """一根 K 线上，止损和止盈谁先到（做多的口径）。

    只碰到一个，答案是确定的。**两个都碰到，K 线上就看不出顺序了**——
    开盘、最高、最低、收盘四个数里没有时间。这时按 `path` 给出的假设回答：

    - `"pessimistic"`：算止损先到（回测该用的默认值：宁可低估自己）
    - `"optimistic"`：算止盈先到（回测最常见、也最贵的那个错误）
    - `"coin"`：抛硬币（需要 `rng`；它比前两个都接近真相，但每跑一次结果都不一样）

    ⚠️ 换成更细的 K 线能把「两个都碰到」的比例压下去，但压不到 0：
    只要还是 K 线，就还有这一根内部。
    """
    if path not in PATHS:
        raise ValueError(f"path 只能是 {PATHS} 之一，收到 {path!r}")
    hit_stop, hit_target = bar["low"] <= stop, bar["high"] >= target
    if not hit_stop and not hit_target:
        return "都没碰到"
    if hit_stop and not hit_target:
        return "止损"
    if hit_target and not hit_stop:
        return "止盈"
    if path == "pessimistic":
        return "止损"
    if path == "optimistic":
        return "止盈"
    if rng is None:
        raise ValueError('path="coin" 要给一个 numpy 的随机数发生器，好让结果可复现')
    return "止盈" if rng.random() < 0.5 else "止损"

括号宽度 ±0.25 ATR ±0.5 ATR ±1.0 ATR
K 线                             
日线      32.00%    6.86%    0.73%
4 小时     4.33%    0.79%    0.06%
1 小时     0.79%    0.09%    0.00%
1 分钟     0.00%    0.00%    0.00%
⚠️ K 线越细，这件事越少，但压不到 0：只要还是 K 线，就还有这一根内部

--- 日线，括号 ±0.25 ATR ---
     同一根里听谁的   笔数  同一根     胜率    合计 R   期末是本金的几倍  比真相多算的 R
   乐观：总是止盈先到 3281 1050 0.6522   999.0 18513.8581    1144.0
   悲观：总是止损先到 3281 1050 0.3322 -1101.0     0.0000    -956.0
         抛硬币 3281 1050 0.4852   -97.0     0.3217      48.0
真相：用 1 分钟线判定 3281 1050 0.4779  -145.0     0.1991       0.0

--- 日线，括号 ±0.5 ATR ---
     同一根里听谁的   笔数  同一根     胜率   合计 R  期末是本金的几倍  比真相多算的 R
   乐观：总是止盈先到 3281  225 0.5300  197.0    6.0861     200.0
   悲观：总是止损先到 3281  225 0.4614 -253.0    0.0676    -250.0
         抛硬币 3281  225 0.4919  -53.0    0.4995     -50.0
真相：用 1 分钟线判定 3281  225 0.4995   -3.0    0.8236       0.0

--- 日线，括号 ±1.0 ATR ---
     同一根里听谁的   笔数  同一根     胜率  合计 R  期末是本金的几倍  比真相多算的 R
   乐观：总是止盈先到 3266   24 0.5288 188.0    5.5664      14.0
   悲观：总是止损先到 3266   24 0.5214 140.0    3.4444     -34.0
         抛硬币 3266   24 0.5257 168.0    4.5574      -6.0
真相：用 1 分钟线判定 3266   24 0.5266 174.0    4.8392       0.0

限价挂在开盘价下方 2%，日线判定「成交」的 1392 天（占全部 42.2%）：
              天数  分钟数中位  只有1分钟的比例  不超过5分钟  成交额占比中位
穿过多少                                              
≤0.05%（擦一下）   24    1.0    0.7083  0.9583   0.0058
0.05%–0.2%    90    3.0    0.2333  0.7000   0.0118
0.2%–1%      357   37.0    0.0280  0.1457   0.0614
1%–3%        495  341.0    0.0000  0.0040   0.3178
大于 3%        426  751.0    0.0000  0.0000   0.6605

def limit_filled(bar, level: float, side: str = "buy", through: float = 0.0) -> bool:
    """限价单在这根 K 线上算不算成交。

    `through=0` 就是回测默认的「碰到就成交」。真实的限价单要排队，**碰到不等于轮到你**：
    价格只是擦了一下限价就掉头，那一分钟的成交量可能根本轮不到你的单子。
    `through=0.001` 表示「价格要穿过限价 0.1% 才算我成交」，用来量这个假设值多少钱。
    """
    if side not in ("buy", "sell"):
        raise ValueError(f"side 只能是 buy 或 sell，收到 {side!r}")
    return bool(bar["low"] <= level * (1 - through) if side == "buy"
                else bar["high"] >= level * (1 + through))

`limit_filled` 里的 through 参数就是用来量这个假设的：
  要求价格穿过限价 0.00% 才算成交：1392 天成交（原来 1392 天），少了 0 天
  要求价格穿过限价 0.05% 才算成交：1368 天成交（原来 1392 天），少了 24 天
  要求价格穿过限价 0.20% 才算成交：1278 天成交（原来 1392 天），少了 114 天

 单边费率  交易数     年化        期末账户      手续费合计  手续费占期末账户
0.00%   30 0.2160 581817.7139     0.0000    0.0000
0.02%   30 0.2147 576191.1709  4322.0701    0.0075
0.05%   30 0.2127 567851.8334 10709.4060    0.0189
0.10%   30 0.2094 554216.6887 21103.8915    0.0381
0.20%   30 0.2029 527937.3030 40980.5204    0.0776
⚠️ 真实的费率、滑点、买卖价差是第 28 篇的事，这里只是把口子留出来

"""talab.backtest：回测引擎。第 27 篇。

回测是一台飞行模拟器：它要在地面上把飞行重演一遍，重演得越像，你在上面练出来的东西才越有用。
模拟器最容易出的毛病不是「不够精细」，是**它偷偷告诉了你未来**——提前三秒提示下沉气流，
你当然飞得又稳又好，但那不是飞行。

所以这个模块的第一条规矩不是关于收益的，是关于时钟的：

> **第 i 根 K 线收盘时算出来的东西，最早只能在第 i+1 根上成交。**

围绕这条规矩，模块分四部分：

1. **向量化**：`vectorized` 和 `lag_test`——一行代码就能写完的回测，以及怎么检查它有没有偷看。
2. **盘中路径**：`first_touch`——同一根 K 线里止损和止盈都被碰到，先算哪个？
   K 线只有四个数，这件事**从数据上无法判断**，所以它是一个假设，必须显式写出来。
3. **记账**：`Account`——现金、持仓、权益三个数必须时时自洽，手续费从现金里扣。
   `rules.run`（第 21 篇）只算收益率，算不出「这笔钱够不够买」。
4. **事件驱动**：`Plan` 和 `run`——一根一根推进，每一根上按固定顺序做四件事。

⚠️ 这个模块只负责**把重演做对**。偏差（幸存者、数据窥探、复权）和真实成本是第 28 篇，
怎么评价跑出来的结果是第 29 篇。`fee_rate` 这个口子留在这里，数字由第 28 篇填。
"""
from __future__ import annotations

from dataclasses import dataclass, field

import numpy as np
import pandas as pd

PATHS = ("pessimistic", "optimistic", "coin")
FILLS = ("next_open", "close")
STOPS = ("none", "chandelier", "percent")
SIZINGS = ("full", "risk")

def lag_test(close: pd.Series, position: pd.Series, lags=(0, 1, 2, 3),
             periods_per_year: int = 365) -> pd.DataFrame:
    """把仓位依次往后推一根，看结果掉得有多快——查「有没有偷看未来」的通用体检。

    一条真策略的收益来自「信号之后价格继续走」，推迟一根只会让它**温和地**变差。
    推迟一根就塌掉，说明原来那个版本赚的是**信号当根自己的涨幅**，
    而那一根的涨幅正是算出信号的原料。
    """
    rows = []
    for lag in lags:
        returns = vectorized(close, position, lag)
        equity = (1 + returns).cumprod()
        in_market = vectorized(close, position, lag) != 0
        rows.append({"推迟根数": lag,
                     "年化": equity.iloc[-1] ** (periods_per_year / len(returns)) - 1,
                     "最大回撤": float((equity / equity.cummax() - 1).min()),
                     "持仓根里上涨的比例": float((returns[in_market] > 0).mean()) if in_market.any() else np.nan})
    return pd.DataFrame(rows)

class Plan:
    """一次回测的全部设定。前五项和第 21 篇的 `Rule` 一一对应，后面几项是这一篇新加的。"""
    entry: pd.Series                       # 收盘时成立的入场信号
    exit: pd.Series                        # 收盘时成立的出场信号
    fill: str = "next_open"                # 下一根开盘成交，还是当根收盘成交
    stop: str = "chandelier"               # none / chandelier / percent
    k: float = 3.0                         # chandelier：最高价往下几个 ATR
    stop_percent: float = 0.10
    trigger: str = "close"                 # 止损用收盘价还是盘中最低价触发（第 20 篇）
    target_r: float | None = None          # 止盈目标，按 R 算（第 23 篇）
    path: str = "pessimistic"              # 同一根里止损和止盈都碰到时听谁的
    sizing: str = "full"                   # full / risk（第 26 篇）
    risk_per_trade: float = 0.10
    fee_rate: float = 0.0                  # 单边费率，数字留给第 28 篇
    atr_period: int = 14
    seed: int = 27                         # path="coin" 时的随机种子

    def __post_init__(self):
        for name, value, allowed in [("fill", self.fill, FILLS), ("stop", self.stop, STOPS),
                                     ("path", self.path, PATHS), ("sizing", self.sizing, SIZINGS)]:
            if value not in allowed:
                raise ValueError(f"{name} 只能是 {allowed} 之一，收到 {value!r}")
        if self.target_r is not None and self.trigger == "close" and self.path != "pessimistic":
            raise ValueError("收盘价触发时一根 K 线只有一个收盘价，不存在先后问题，path 没有意义")
        if self.sizing == "risk" and self.stop == "none":
            raise ValueError('没有止损就算不出每笔的风险，sizing="risk" 需要一个止损')

    def describe(self) -> pd.Series:
        return pd.Series({
            "入场方式": {"close": "当根收盘价", "next_open": "下一根开盘价"}[self.fill],
            "初始止损": {"none": "没有", "chandelier": f"{self.k} 倍 ATR 吊灯",
                         "percent": f"进场价下方 {self.stop_percent:.0%}"}[self.stop],
            "止损触发": {"close": "收盘价", "extreme": "盘中最低价"}[self.trigger],
            "止盈目标": "不设" if self.target_r is None else f"{self.target_r} 个 R",
            "同一根里的顺序": {"pessimistic": "算止损先到", "optimistic": "算止盈先到",
                               "coin": "抛硬币"}[self.path],
            "仓位": "满仓" if self.sizing == "full" else f"每笔风险 {self.risk_per_trade:.0%}",
            "单边费率": f"{self.fee_rate:.4%}",
        })

        if self.target_r is not None and self.trigger == "close" and self.path != "pessimistic":
            raise ValueError("收盘价触发时一根 K 线只有一个收盘价，不存在先后问题，path 没有意义")

def run(df: pd.DataFrame, plan: Plan, equity: float = 100_000.0) -> dict:
    """事件驱动回测：一根一根推进，每一根上按**固定顺序**做四件事。

    1. **成交**：用上一根收盘时挂出的订单，在这一根上成交（开盘市价单）
    2. **出场**：检查止损、止盈；两个都碰到时按 `plan.path` 决定顺序
    3. **估值**：按这一根的收盘价给账户估值，记下权益
    4. **下单**：用截至这一根的数据算信号，挂出**下一根**的订单

    第 4 步必须排在第 3 步后面，这就是那条时钟规矩。把 3 和 4 调个个儿，
    或者把第 4 步算出来的信号拿到第 2 步去用，回测立刻变成印钞机。

    返回一个字典：资金曲线、现金、持仓数量、交易表、以及**记账误差**——
    每一根上「现金 + 持仓市值」和权益的最大差额，正常应该是 0。
    """
    from talab import indicators as I

    o, h, l, c = (df[x].to_numpy(float) for x in ["open", "high", "low", "close"])
    atr = (I.atr(df["high"], df["low"], df["close"], plan.atr_period).to_numpy()
           if plan.stop == "chandelier" else np.full(len(c), np.nan))
    signal = plan.entry.reindex(df.index).fillna(False).to_numpy(bool)
    leave = plan.exit.reindex(df.index).fillna(False).to_numpy(bool)
    rng = np.random.default_rng(plan.seed)
    account = Account(cash=float(equity))
    first = int(np.argmax(~np.isnan(atr))) + 1 if plan.stop == "chandelier" else 1

    curve, cash_path, share_path, trades, error = [], [], [], [], 0.0
    pending = False                                   # 上一根收盘挂出的买单还在不在
    entry_price = stop_price = risk = highest = np.nan
    entry_i = -1

    def stop_level(i: int, previous: float) -> float:
        if plan.stop == "none":
            return -np.inf
        if plan.stop == "percent":
            return entry_price * (1 - plan.stop_percent)
        return max(previous, highest - plan.k * atr[i - 1])   # 吊灯只上移

    if account.shares > 0:                            # 最后一根还拿着：记成「未平仓」，按收盘价估值
        trades.append({"买入日": df.index[entry_i], "买入价": entry_price, "数量": account.shares,
                       "卖出日": df.index[-1], "卖出价": c[-1], "原因": "未平仓",
                       "收益": c[-1] / entry_price - 1, "根数": len(c) - 1 - entry_i})
    index = df.index[first:]
    table = pd.DataFrame(trades, columns=["买入日", "买入价", "数量", "卖出日", "卖出价", "原因", "收益", "根数"])
    return {"资金曲线": pd.Series(curve, index=index, name="权益"),
            "现金": pd.Series(cash_path, index=index, name="现金"),
            "持仓数量": pd.Series(share_path, index=index, name="持仓"),
            "交易": table, "手续费合计": account.fees, "记账误差": error}

def reconcile(curves: dict[str, pd.Series]) -> pd.DataFrame:
    """把几条资金曲线摆在一起对账：终值、年化、最大回撤，以及和第一条的最大差额。

    两个引擎在同样的设定下跑出不同的曲线，一定有一个写错了。**对账是回测唯一能做的自检。**
    """
    names = list(curves)
    base = curves[names[0]] / curves[names[0]].iloc[0]
    rows = []
    for name in names:
        series = curves[name] / curves[name].iloc[0]
        aligned = series.reindex(base.index)
        rows.append({"名字": name, "终值（本金的几倍）": float(series.iloc[-1]),
                     "最大回撤": float((series / series.cummax() - 1).min()),
                     f"和「{names[0]}」的最大差额": float((aligned - base).abs().max())})
    return pd.DataFrame(rows)

def test_vectorized_lag_is_the_whole_point():
    """「今天涨了」这个信号，lag=0 时每一根都押中，lag=1 时什么也押不中。"""
    close = series([100, 110, 100, 110, 100, 110, 100])
    up = (close.pct_change() > 0).astype(float)
    assert BT.vectorized(close, up, lag=0).sum() == pytest.approx(up.mul(close.pct_change()).sum())
    assert (BT.vectorized(close, up, lag=0) >= 0).all()          # 偷看未来：一根都不亏
    assert BT.vectorized(close, up, lag=1).min() < 0             # 老老实实：会亏

def test_lag_test_tells_a_peeking_signal_from_a_real_one():
    """偷看未来的信号推迟一根就塌，真信号只是温和变差。"""
    rng = np.random.default_rng(27)
    close = series(100 * np.exp(np.cumsum(rng.standard_normal(800) * 0.01)))
    peeking = (close.pct_change() > 0).astype(float)             # 用当根自己的涨跌当信号
    honest = (close.pct_change().shift(1) > 0).astype(float)     # 用上一根的涨跌当信号
    a = BT.lag_test(close, peeking, lags=(0, 1))
    b = BT.lag_test(close, honest, lags=(0, 1))
    assert a["年化"].iloc[0] > 10 * max(a["年化"].iloc[1], 0.01)  # 塌掉一个数量级
    assert a["持仓根里上涨的比例"].iloc[0] == pytest.approx(1.0)
    assert abs(b["年化"].iloc[0] - b["年化"].iloc[1]) < abs(a["年化"].iloc[0] - a["年化"].iloc[1])

def test_run_never_trades_on_the_signal_bar_itself():
    """价格只在第 5 根跳了一下，信号也在第 5 根：正确的引擎一分钱也赚不到。"""
    df = bars([100, 100, 100, 100, 100, 200, 200, 200])
    entry = flags(8, [5])                                         # 跳的那一根收盘才成立
    result = BT.run(df, BT.Plan(entry=entry, exit=flags(8), stop="none"), 1_000.0)
    assert result["资金曲线"].iloc[-1] == pytest.approx(1_000.0)   # 第 6 根开盘买入，价格已经是 200
    assert result["交易"]["买入价"].iloc[0] == pytest.approx(200.0)

def test_run_books_every_bar_exactly():
    df = random_walk()
    entry = (df["close"] >= df["close"].rolling(20).max()).fillna(False)
    exit_ = (df["close"] <= df["close"].rolling(20).min()).fillna(False)
    result = BT.run(df, BT.Plan(entry=entry, exit=exit_, stop="percent", stop_percent=0.10), 100_000.0)
    assert result["记账误差"] == pytest.approx(0.0, abs=1e-9)
    rebuilt = result["现金"] + result["持仓数量"] * df["close"].reindex(result["现金"].index)
    assert (rebuilt - result["资金曲线"]).abs().max() == pytest.approx(0.0, abs=1e-9)

def test_run_agrees_with_the_post21_engine_when_fully_invested():
    """满仓、不收费时，第 27 篇的引擎和第 21 篇的 `rules.run` 必须给出同一条资金曲线。"""
    df = random_walk()
    entry = (df["close"] >= df["close"].rolling(20).max()).fillna(False)
    exit_ = I.cross_below(I.sma(df["close"], 10), I.sma(df["close"], 30)).fillna(False)
    settings = dict(fill="next_open", stop="chandelier", k=3.0, trigger="close")
    old, _, trades = R.run(df, R.Rule(entry=entry, exit=exit_, sizing="full", **settings))
    new = BT.run(df, BT.Plan(entry=entry, exit=exit_, sizing="full", **settings), 1.0)
    assert len(new["交易"]) == len(trades)
    assert ((new["资金曲线"] - (1 + old).cumprod()).abs().max()) < 1e-12

def test_vectorized_and_event_driven_agree_when_there_is_no_stop():
    """没有止损时，仓位就是当根数据的函数，两种写法必须一致。"""
    df = random_walk()
    entry = (df["close"] >= df["close"].rolling(20).max()).fillna(False)
    exit_ = (df["close"] <= df["close"].rolling(20).min()).fillna(False)
    state = pd.Series(np.nan, index=df.index)
    state[entry], state[exit_] = 1.0, 0.0
    vector = (1 + BT.vectorized(df["close"], state.ffill().fillna(0.0), lag=1)).cumprod()
    event = BT.run(df, BT.Plan(entry=entry, exit=exit_, fill="close", stop="none"), 1.0)["资金曲线"]
    assert (event - vector.reindex(event.index)).abs().max() < 1e-12

def test_run_with_a_coin_path_is_reproducible():
    df = random_walk()
    entry = (df["close"] >= df["close"].rolling(20).max()).fillna(False)
    plan = dict(entry=entry, exit=flags(len(df)), stop="percent", stop_percent=0.005,
                trigger="extreme", target_r=1.0, path="coin")
    first = BT.run(df, BT.Plan(seed=27, **plan), 1.0)["资金曲线"]
    again = BT.run(df, BT.Plan(seed=27, **plan), 1.0)["资金曲线"]
    other = BT.run(df, BT.Plan(seed=99, **plan), 1.0)["资金曲线"]
    assert (first - again).abs().max() == 0.0                     # 同一个种子，同一条曲线
    assert (first - other).abs().max() > 0.0                      # 换个种子就不一样了

265 passed in 0.88s

233 passed, 32 skipped in 1.06s

returns = signal * close.pct_change()

returns = signal.shift(1) * close.pct_change()

错的那一行是：returns = signal * close.pct_change()
改对只要一个 .shift(1)：returns = signal.shift(1) * close.pct_change()
                     版本     年化    最大回撤      期末倍数
         错：signal * ret 1.3269  0.0000 2080.0294
对：signal.shift(1) * ret 0.1426 -0.2257    3.3396

入场方式             下一根开盘价
初始止损       3.0 倍 ATR 吊灯
止损触发                收盘价
止盈目标                 不设
同一根里的顺序           算止损先到
仓位             每笔风险 10%
单边费率            0.0000%

                  名字  终值（本金的几倍）      最大回撤  和「第 21 篇的 rules.run」的最大差额
   第 21 篇的 rules.run   5.791251 -0.323122                   0.000000
第 27 篇的 backtest.run   5.818177 -0.323209                   0.113952
       加上 0.05% 单边费率   5.678518 -0.327600                   0.121473
第 21 篇的 rules.run：年化 21.53%，最大回撤 -32.31%
第 27 篇的 backtest.run：年化 21.60%，最大回撤 -32.32%
加上 0.05% 单边费率：年化 21.27%，最大回撤 -32.76%

记账误差 0.0e+00；最后一根上 现金 581,817.71 + 持仓 0.000000 × 78,581.29 = 581,817.71