第 12 篇：移动平均线

                收盘   SMA50  SMA200
date                              
2025-06-26  611.87  577.88  581.04
2025-06-27  614.91  579.43  581.38
2025-06-30  617.85  581.27  581.73
2025-07-01  617.65  583.10  582.04
4 月最低收盘：2025-04-08 496.48，到决策点涨了 24.4%，相隔 57 个交易日
上一次死叉：2025-04-14 收盘 539.12，到决策点涨了 14.6%
决策点之前的最高收盘：617.85（2025-06-30），更早的高点 612.93（2025-02-19）
收盘价第一次站上 50 日均线：2025-05-01
收盘价第一次站上 200 日均线：2025-05-12
决策点的乖离率（相对 200 日均线）：+6.1%，在 SPY 全部历史里的分位 48%

def backtest_next_open(df, signal):
    """收盘时算出 signal（1 持有、0 空仓），下一根开盘成交。返回每根 K 线的收益率。"""
    held = signal.shift(1).fillna(0.0)                      # 这一根是否持有
    before = held.shift(1).fillna(0.0)                      # 上一根是否持有
    o, close, prev = df["open"], df["close"], df["close"].shift(1)
    r = np.select([(held == 1) & (before == 1), (held == 1) & (before == 0), (held == 0) & (before == 1)],
                  [close / prev - 1, close / o - 1, o / prev - 1], 0.0)
    return pd.Series(r, index=df.index).fillna(0.0)


def annual(r, n):
    return (1 + r).prod() ** (n / len(r)) - 1


for name, df in markets.items():
    start = I.sma(df["close"], 200).first_valid_index()       # 和后面的主线策略用同一个起点
    d = df.loc[start:]
    for n in [5, 20]:
        signal = (df["close"] > I.sma(df["close"], n)).astype(float).loc[start:]
        right = backtest_next_open(d, signal)
        same_day = (signal * d["close"].pct_change()).fillna(0.0)          # 错误 1：当天收盘才知道的信号，吃了当天的收益
        centered = df["close"].rolling(n, center=True).mean()               # 错误 2：居中的均线，用到了后面 n / 2 天
        rising = (centered.diff() > 0).astype(float).loc[start:]
        peek = (rising.shift(1) * d["close"].pct_change()).fillna(0.0)
        print(f"{name} 收盘价在 {n} 日均线上方就持有：正确 {annual(right, periods_per_year[name]):.1%}，"
              f"当天信号 {annual(same_day, periods_per_year[name]):.1%}，"
              f"居中均线向上就持有 {annual(peek, periods_per_year[name]):.1%}，"
              f"买入 {int((signal.diff() == 1).sum())} 次（年化收益）")

SPY 收盘价在 5 日均线上方就持有：正确 4.4%，当天信号 116.6%，居中均线向上就持有 66.4%，买入 300 次（年化收益）
SPY 收盘价在 20 日均线上方就持有：正确 6.8%，当天信号 50.5%，居中均线向上就持有 37.5%，买入 115 次（年化收益）
AAPL 收盘价在 5 日均线上方就持有：正确 2.3%，当天信号 281.2%，居中均线向上就持有 143.3%，买入 292 次（年化收益）
AAPL 收盘价在 20 日均线上方就持有：正确 26.7%，当天信号 110.7%，居中均线向上就持有 70.0%，买入 96 次（年化收益）
BTC 收盘价在 5 日均线上方就持有：正确 24.1%，当天信号 2042.7%，居中均线向上就持有 632.4%，买入 417 次（年化收益）
BTC 收盘价在 20 日均线上方就持有：正确 31.4%，当天信号 450.0%，居中均线向上就持有 210.0%，买入 177 次（年化收益）

x = pd.Series([10.0, 11, 12, 11, 13, 16])
print(pd.DataFrame({"价格": x, "SMA3": I.sma(x, 3), "WMA3": I.wma(x, 3), "EMA3": I.ema(x, 3)}).round(4).to_string())

     价格     SMA3     WMA3  EMA3
0  10.0      NaN      NaN   NaN
1  11.0      NaN      NaN   NaN
2  12.0  11.0000  11.3333  11.0
3  11.0  11.3333  11.3333  11.0
4  13.0  12.0000  12.1667  12.0
5  16.0  13.3333  14.1667  14.0

ours = I.ema(c, 50)
pandas_style = c.ewm(span=50, adjust=False).mean()
diff = (ours - pandas_style).abs()
print(f"第 50 根（第一个值）：talab {ours.iloc[49]:.2f}，pandas {pandas_style.iloc[49]:.2f}，相差 {diff.iloc[49]:.2f}")
for k in [100, 200, 400]:
    print(f"第 {k} 根：相差 {diff.iloc[k - 1]:.4f}")
print(f"相差第一次小于 0.01：第 {int(np.argmax((diff < 0.01).to_numpy())) + 1} 根")

第 50 根（第一个值）：talab 214.88，pandas 215.44，相差 0.55
第 100 根：相差 0.0746
第 200 根：相差 0.0014
第 400 根：相差 0.0000
相差第一次小于 0.01：第 151 根

rows = []
for n in [20, 50, 200]:
    alpha = 2 / (n + 1)
    rows.append({"n": n, "SMA": I.average_lag(np.ones(n)), "EMA": I.average_lag((1 - alpha) ** np.arange(5000)),
                 "WMA": I.average_lag(np.arange(n, 0, -1))})
print(pd.DataFrame(rows).round(2).to_string(index=False))
ramp = pd.Series(np.arange(300, dtype=float))
for name, f in [("SMA", I.sma), ("EMA", I.ema), ("WMA", I.wma)]:
    lag = (ramp - f(ramp, 30)).dropna()
    print(f"斜坡上的 {name}30：价格减均线 最小 {lag.min():.4f}，最大 {lag.max():.4f}")

  n  SMA  EMA   WMA
 20  9.5  9.5  6.33
 50 24.5 24.5 16.33
200 99.5 99.5 66.33
斜坡上的 SMA30：价格减均线 最小 14.5000，最大 14.5000
斜坡上的 EMA30：价格减均线 最小 14.5000，最大 14.5000
斜坡上的 WMA30：价格减均线 最小 9.6667，最大 9.6667

def weight_median(weights):
    """权重从最新往前累加，第一次达到一半的位置。"""
    w = np.asarray(weights, dtype=float)
    return int(np.searchsorted(np.cumsum(w) / w.sum(), 0.5 - 1e-9))          # 减一点点，避免浮点误差让 0.5 被算成不到一半


rows = []
for name, df in markets.items():
    log_price = np.log(df["close"])
    for n in [20, 50, 200]:
        alpha = 2 / (n + 1)
        for kind, ma, weights in [("SMA", I.sma(log_price, n), np.ones(n)),
                                  ("EMA", I.ema(log_price, n), (1 - alpha) ** np.arange(5000)),
                                  ("WMA", I.wma(log_price, n), np.arange(n, 0, -1))]:
            error = {k: ((ma - log_price.shift(k)) ** 2).iloc[400:].mean() for k in range(int(0.8 * n))}
            rows.append({"市场": name, "n": n, "均线": kind, "平均滞后": I.average_lag(weights),
                         "权重中位数": weight_median(weights), "最贴合的平移": min(error, key=error.get)})
print(pd.DataFrame(rows).round(1).to_string(index=False))

  市场   n  均线  平均滞后  权重中位数  最贴合的平移
 SPY  20 SMA   9.5      9       9
 SPY  20 EMA   9.5      6       7
 SPY  20 WMA   6.3      5       6
 SPY  50 SMA  24.5     24      24
 SPY  50 EMA  24.5     17      15
 SPY  50 WMA  16.3     14      14
 SPY 200 SMA  99.5     99      99
 SPY 200 EMA  99.5     69      79
 SPY 200 WMA  66.3     58      55
AAPL  20 SMA   9.5      9      10
AAPL  20 EMA   9.5      6       7
AAPL  20 WMA   6.3      5       6
AAPL  50 SMA  24.5     24      25
AAPL  50 EMA  24.5     17      18
AAPL  50 WMA  16.3     14      15
AAPL 200 SMA  99.5     99      99
AAPL 200 EMA  99.5     69      75
AAPL 200 WMA  66.3     58      57
 BTC  20 SMA   9.5      9       9
 BTC  20 EMA   9.5      6       7
 BTC  20 WMA   6.3      5       6
 BTC  50 SMA  24.5     24      24
 BTC  50 EMA  24.5     17      18
 BTC  50 WMA  16.3     14      15
 BTC 200 SMA  99.5     99      99
 BTC 200 EMA  99.5     69      72
 BTC 200 WMA  66.3     58      60

rows = []
for name, df in markets.items():
    log_price = np.log(df["close"])
    step = log_price.diff().std()
    for lag in [9.5, 24.5]:
        n_even, n_wma = int(2 * lag + 1), int(round(3 * lag + 1))          # 平均滞后相同的周期
        a = 2 / (n_even + 1)
        for kind, ma, n, theory in [("SMA", I.sma(log_price, n_even), n_even, 1 / np.sqrt(n_even)),
                                    ("EMA", I.ema(log_price, n_even), n_even, np.sqrt(a / (2 - a))),
                                    ("WMA", I.wma(log_price, n_wma), n_wma,
                                     np.sqrt(2 * (2 * n_wma + 1) / (3 * n_wma * (n_wma + 1))))]:
            move = ma.diff().iloc[250:]
            turns = (np.sign(move) != np.sign(move.shift(1))).iloc[1:].sum()
            rows.append({"市场": name, "平均滞后": lag, "均线": f"{kind}{n}", "实测粗糙度": move.std() / step,
                         "随机游走理论": theory, "每年拐头次数": turns / (len(move) / periods_per_year[name])})
print(pd.DataFrame(rows).round(3).to_string(index=False))

  市场  平均滞后    均线  实测粗糙度  随机游走理论  每年拐头次数
 SPY   9.5 SMA20  0.211   0.224  19.496
 SPY   9.5 EMA20  0.209   0.224  28.408
 SPY   9.5 WMA30  0.195   0.209  19.273
 SPY  24.5 SMA50  0.119   0.141  10.027
 SPY  24.5 EMA50  0.122   0.141  16.599
 SPY  24.5 WMA74  0.111   0.134  11.809
AAPL   9.5 SMA20  0.216   0.224  20.378
AAPL   9.5 EMA20  0.217   0.224  26.392
AAPL   9.5 WMA30  0.203   0.209  18.262
AAPL  24.5 SMA50  0.135   0.141  13.140
AAPL  24.5 EMA50  0.133   0.141  16.035
AAPL  24.5 WMA74  0.127   0.134  12.249
 BTC   9.5 SMA20  0.215   0.224  38.031
 BTC   9.5 EMA20  0.213   0.224  39.466
 BTC   9.5 WMA30  0.201   0.209  31.094
 BTC  24.5 SMA50  0.143   0.141  22.603
 BTC  24.5 EMA50  0.142   0.141  23.440
 BTC  24.5 WMA74  0.136   0.134  17.461

i = c.index.get_loc(t)
for n in [20, 60, 120, 250]:
    print(f"{n} 个交易日后（{c.index[i + n].date()}）：{c.iloc[i + n] / c[t] - 1:+.2%}")
after = c.iloc[i:]
drawdown = after / after.cummax() - 1
print(f"之后最大回撤 {drawdown.min():.1%}（{drawdown.idxmin().date()}），{c.index[-1].date()} 收盘 {c.iloc[-1]:.2f}，"
      f"比决策点 {c.iloc[-1] / c[t] - 1:+.1%}")
f50, f200 = I.sma(c, 50), I.sma(c, 200)
print("决策点之后的交叉：", list(c.index[(I.cross_above(f50, f200) | I.cross_below(f50, f200)) & (c.index > t)].date))

20 个交易日后（2025-07-30）：+2.72%
60 个交易日后（2025-09-25）：+6.54%
120 个交易日后（2025-12-19）：+10.19%
250 个交易日后（2026-07-01）：+20.74%
之后最大回撤 -9.1%（2026-03-30），2026-09-15 收盘 757.39，比决策点 +22.6%
决策点之后的交叉： []

def rebuild(log_returns):
    return pd.Series(np.exp(np.cumsum(np.asarray(log_returns))))


def golden_gap(log_returns, horizon=20):
    """50 日均线在 200 日均线上方的日子，减去下方的日子：之后 horizon 天的平均对数收益。"""
    p = rebuild(log_returns)
    fast, slow = I.sma(p, 50), I.sma(p, 200)
    later = np.log(p.shift(-horizon) / p)
    return later[fast > slow].mean() - later[fast < slow].mean()


def stack_gap(log_returns, horizon=20):
    """多头排列（收盘 > 20 日 > 50 日 > 200 日均线）的日子，减去其余有 200 日均线的日子。"""
    p = rebuild(log_returns)
    m20, m50, m200 = I.sma(p, 20), I.sma(p, 50), I.sma(p, 200)
    stacked = (p > m20) & (m20 > m50) & (m50 > m200)
    later = np.log(p.shift(-horizon) / p)
    return later[stacked].mean() - later[~stacked & m200.notna()].mean()


def bias_gap(log_returns, horizon=60):
    """相对 200 日均线的乖离率最高 20% 的日子，减去最低 20% 的日子。"""
    p = rebuild(log_returns)
    rank = I.bias(p, I.sma(p, 200)).rank(pct=True)
    later = np.log(p.shift(-horizon) / p)
    return later[rank > 0.8].mean() - later[rank <= 0.2].mean()


for name, df in markets.items():
    close = df["close"]
    fast, slow = I.sma(close, 50), I.sma(close, 200)
    events = close.index[I.cross_above(fast, slow) | I.cross_below(fast, slow)]
    lasted = np.diff(np.r_[[close.index.get_loc(e) for e in events], len(close) - 1])
    stacked = (close > I.sma(close, 20)) & (I.sma(close, 20) > fast) & (fast > slow)
    print(f"{name}：金叉 {int(I.cross_above(fast, slow).sum())} 次，死叉 {int(I.cross_below(fast, slow).sum())} 次，"
          f"每次交叉之后维持的天数 {lasted.tolist()}")
    print(f"   50 日在 200 日上方的时间 {(fast > slow)[slow.notna()].mean():.1%}，多头排列的时间 {stacked[slow.notna()].mean():.1%}")
    log_returns = np.log(close).diff().dropna().reset_index(drop=True)
    for label, stat in [("50 日在上方减下方，之后 20 天", golden_gap), ("多头排列减其余，之后 20 天", stack_gap),
                        ("乖离率最高 20% 减最低 20%，之后 60 天", bias_gap)]:
        res = St.shuffle_test(log_returns, stat, n=1000, seed=0)
        print(f"   {label}：{res['实际值']:+.2%}，打乱后 95% 范围 {res['打乱后 2.5% 分位']:+.2%} ~ "
              f"{res['打乱后 97.5% 分位']:+.2%}，打乱后不小于实际的比例 {res['比例']:.1%}")

SPY：金叉 4 次，死叉 4 次，每次交叉之后维持的天数 [77, 251, 70, 423, 224, 550, 53, 302]
   50 日在 200 日上方的时间 81.7%，多头排列的时间 47.7%
   50 日在上方减下方，之后 20 天：-0.79%，打乱后 95% 范围 -2.10% ~ +1.66%，打乱后不小于实际的比例 45.3%
   多头排列减其余，之后 20 天：-0.86%，打乱后 95% 范围 -1.62% ~ +1.50%，打乱后不小于实际的比例 29.7%
   乖离率最高 20% 减最低 20%，之后 60 天：-1.75%，打乱后 95% 范围 -8.61% ~ +5.76%，打乱后不小于实际的比例 65.4%
AAPL：金叉 5 次，死叉 5 次，每次交叉之后维持的天数 [91, 777, 78, 9, 113, 246, 63, 203, 110, 251]
   50 日在 200 日上方的时间 80.3%，多头排列的时间 37.0%
   50 日在上方减下方，之后 20 天：-2.17%，打乱后 95% 范围 -3.63% ~ +2.90%，打乱后不小于实际的比例 22.0%
   多头排列减其余，之后 20 天：-0.72%，打乱后 95% 范围 -2.56% ~ +2.29%，打乱后不小于实际的比例 55.9%
   乖离率最高 20% 减最低 20%，之后 60 天：-8.29%，打乱后 95% 范围 -13.56% ~ +9.75%，打乱后不小于实际的比例 18.8%
BTC：金叉 8 次，死叉 9 次，每次交叉之后维持的天数 [389, 185, 115, 36, 57, 394, 88, 121, 389, 217, 48, 285, 79, 161, 45, 178, 288]
   50 日在 200 日上方的时间 51.7%，多头排列的时间 20.3%
   50 日在上方减下方，之后 20 天：+1.52%，打乱后 95% 范围 -5.40% ~ +4.59%，打乱后不小于实际的比例 56.9%
   多头排列减其余，之后 20 天：+4.08%，打乱后 95% 范围 -5.14% ~ +4.45%，打乱后不小于实际的比例 8.9%
   乖离率最高 20% 减最低 20%，之后 60 天：+0.37%，打乱后 95% 范围 -23.41% ~ +17.42%，打乱后不小于实际的比例 96.4%

fasts, slows = [5, 10, 20, 50, 100], [20, 50, 100, 150, 200, 250]
for name, df in markets.items():
    start = df.index[250]                                     # 所有组合用同一个起点：最长的 250 日均线算出来之后
    d = df.loc[start:]
    hold = summary(d["close"].pct_change().fillna(0.0), periods_per_year[name])
    grid = pd.DataFrame(index=pd.Index(fasts, name="快"), columns=pd.Index(slows, name="慢"), dtype=float)
    for fast in fasts:
        for slow in slows:
            if fast < slow:
                s = mainline_v0(df, fast, slow).loc[start:]
                grid.loc[fast, slow] = summary(backtest_next_open(d, s), periods_per_year[name])["年化"]
    values = grid.stack()
    print(f"{name}（{start.date()} 起）：买入持有年化 {hold['年化']:.1%}；30 组参数年化收益（%）：")
    print((grid * 100).round(1).to_string())
    print(f"   50/200 排第 {int(values.rank(ascending=False)[(50, 200)])} 名；超过买入持有的组合 {int((values > hold['年化']).sum())} 组；"
          f"最好 {int(values.idxmax()[0])}/{int(values.idxmax()[1])} {values.max():.1%}，"
          f"最差 {int(values.idxmin()[0])}/{int(values.idxmin()[1])} {values.min():.1%}")

SPY（2017-09-13 起）：买入持有年化 13.1%；30 组参数年化收益（%）：
慢     20   50   100   150   200  250
快                                   
5    10.7  5.7  7.2  10.3  11.4  9.1
10    5.5  6.4  9.5   7.3  10.4  9.6
20    NaN  7.8  7.5   8.4   9.2  6.9
50    NaN  NaN  4.9   6.5   8.4  9.6
100   NaN  NaN  NaN   8.5   9.3  9.5
   50/200 排第 14 名；超过买入持有的组合 0 组；最好 5/200 11.4%，最差 50/100 4.9%
AAPL（2017-09-13 起）：买入持有年化 27.6%；30 组参数年化收益（%）：
慢     20    50    100   150   200   250
快                                      
5    21.7  16.3  15.1  14.0  19.7  19.8
10   18.5  16.4  13.5  15.0  21.8  18.6
20    NaN  14.1  14.8  15.7  18.7  18.0
50    NaN   NaN  17.5  14.0  14.6  14.2
100   NaN   NaN   NaN  15.7  15.8  17.8
   50/200 排第 19 名；超过买入持有的组合 0 组；最好 10/200 21.8%，最差 10/100 13.5%
BTC（2018-04-24 起）：买入持有年化 28.6%；30 组参数年化收益（%）：
慢     20    50    100   150   200   250
快                                      
5    28.7  41.7  51.3  48.9  32.2  32.5
10   26.3  38.2  32.0  31.3  33.8  31.2
20    NaN  31.2  30.5  29.7  26.6  27.1
50    NaN   NaN  25.1  23.6  27.0  22.3
100   NaN   NaN   NaN  28.1  25.5  28.4
   50/200 排第 18 名；超过买入持有的组合 14 组；最好 5/100 51.3%，最差 50/250 22.3%

def mainline_v0(df, fast=50, slow=200):
    """主线策略 v0：快均线在慢均线上方就持有，否则空仓。收盘时判断，下一根开盘成交。没有止损、没有仓位管理、没有成本。"""
    close = df["close"]
    signal = (I.sma(close, fast) > I.sma(close, slow)).astype(float)
    return signal.where(I.sma(close, slow).notna())


def summary(r, n, held=None):
    equity = (1 + r).cumprod()
    out = {"总收益": equity.iloc[-1] - 1, "年化": equity.iloc[-1] ** (n / len(r)) - 1,
           "年化波动": r.std() * np.sqrt(n), "最大回撤": (equity / equity.cummax() - 1).min()}
    if held is not None:
        out["在场时间"] = held.mean()
        out["买入次数"] = int((held.diff() == 1).sum() + (held.iloc[0] == 1))
    return out


results = {}
for name, df in markets.items():
    signal = mainline_v0(df)
    start = signal.first_valid_index()
    d, s = df.loc[start:], signal.loc[start:]
    held = s.shift(1).fillna(0.0)
    r = backtest_next_open(d, s)
    results[name] = r
    rows = {"买入持有": summary(d["close"].pct_change().fillna(0.0), periods_per_year[name]),
            "主线 v0": summary(r, periods_per_year[name], held),
            "主线 v0（未来函数：当天信号）": summary((s * d["close"].pct_change()).fillna(0.0), periods_per_year[name], s)}
    print(f"{name}：{start.date()} 至 {d.index[-1].date()}")
    print(pd.DataFrame(rows).T.to_string(float_format=lambda v: f"{v:.3f}"))
    buys, sells = d.index[held.diff() == 1], d.index[held.diff() == -1]
    print("   买入：", [b.date().isoformat() for b in buys], "卖出：", [e.date().isoformat() for e in sells])

SPY：2017-06-30 至 2026-09-15
                   总收益    年化  年化波动   最大回撤  在场时间  买入次数
买入持有             2.132 0.132 0.186 -0.341   NaN   NaN
主线 v0            1.122 0.085 0.157 -0.341 0.816 5.000
主线 v0（未来函数：当天信号） 1.119 0.085 0.156 -0.341 0.817 5.000
   买入： ['2017-07-03', '2019-04-02', '2020-07-10', '2023-02-03', '2025-07-02'] 卖出： ['2018-12-10', '2020-03-31', '2022-03-15', '2025-04-15']
AAPL：2017-06-30 至 2026-09-15
                   总收益    年化  年化波动   最大回撤  在场时间  买入次数
买入持有             8.925 0.284 0.300 -0.385   NaN   NaN
主线 v0            2.759 0.155 0.262 -0.459 0.803 6.000
主线 v0（未来函数：当天信号） 3.306 0.172 0.261 -0.443 0.803 6.000
   买入： ['2017-07-03', '2019-05-07', '2022-09-27', '2023-03-23', '2024-06-14', '2025-09-16'] 卖出： ['2018-12-24', '2022-06-06', '2022-10-10', '2024-03-15', '2025-04-08']
BTC：2018-03-04 至 2026-08-31
                   总收益    年化  年化波动   最大回撤  在场时间  买入次数
买入持有             5.824 0.253 0.624 -0.766   NaN   NaN
主线 v0            3.422 0.191 0.476 -0.667 0.517 9.000
主线 v0（未来函数：当天信号） 3.333 0.188 0.476 -0.673 0.517 9.000
   买入： ['2018-03-05', '2019-04-25', '2020-02-19', '2020-05-22', '2021-09-16', '2023-02-08', '2023-10-31', '2024-10-29', '2025-05-23'] 卖出： ['2018-04-01', '2019-10-27', '2020-03-26', '2021-06-20', '2022-01-15', '2023-09-13', '2024-08-11', '2025-04-08', '2025-11-17']

# 正文里所有代码的实际运行环境（Python 3.14.7）
pandas==3.0.5
numpy==2.5.3
matplotlib==3.11.2
exchange_calendars==4.13.2
pytest==9.1.1
TA-Lib==0.8.0

# ---------------------------------------------------------------------------
# 四、移动平均线（第 12 篇）
# ---------------------------------------------------------------------------
#
# 这一部分起，所有指标函数遵守同一套约定：
# 1. 输入一个 Series（通常是收盘价）和参数，返回一个和输入索引完全相同的 Series
# 2. 数据还不够算出第一个值的位置（预热期）返回 NaN，不补 0、不用更短的窗口凑
# 3. 第 k 个值只用到第 k 个及之前的输入：用前 k 个数据算出的结果，和用全部数据算出的前 k 个完全一样
# 4. 结果和 TA-Lib 的同名函数一致（有差异的地方在文档里写明）

def _check_period(n: int) -> None:
    if not isinstance(n, (int, np.integer)) or n < 1:
        raise ValueError(f"周期 n 必须是正整数，收到的是 {n!r}")


def sma(x: pd.Series, n: int) -> pd.Series:
    """简单移动平均：最近 n 个值的算术平均。前 n - 1 个为 NaN；窗口里有 NaN 时结果也是 NaN。"""
    _check_period(n)
    return x.rolling(n).mean()


def wma(x: pd.Series, n: int) -> pd.Series:
    """加权移动平均：最近一个值的权重是 n，往前依次是 n - 1、…、1，再除以权重之和 n(n + 1) / 2。"""
    _check_period(n)
    weights = np.arange(1, n + 1, dtype=float)
    return x.rolling(n).apply(lambda w: np.dot(w, weights), raw=True) / weights.sum()


def ema(x: pd.Series, n: int, alpha: float | None = None) -> pd.Series:
    """指数移动平均：新值 = 旧值 + alpha × (今天 - 旧值)，默认 alpha = 2 / (n + 1)。

    第一个值是前 n 个有效值的简单平均（和 TA-Lib 一样），出现在第 n 个有效值的位置，之前为 NaN。
    开头的 NaN 会被跳过，所以可以直接对另一个指标的结果（开头有预热期）再求 EMA。
    alpha = 1 / n 时就是第 8 篇 structure.wilder_smooth 的 Wilder 平滑。
    ⚠️ pandas 的 x.ewm(span=n, adjust=False).mean() 用第一个值做初始值，前面一段和这里不同。
    """
    _check_period(n)
    a = 2 / (n + 1) if alpha is None else alpha
    v = x.to_numpy(dtype=float)
    out = np.full(len(v), np.nan)
    valid = np.flatnonzero(~np.isnan(v))
    if len(valid) >= n:
        start = valid[0] + n - 1
        out[start] = v[valid[0]:start + 1].mean()
        for i in range(start + 1, len(v)):
            out[i] = out[i - 1] + a * (v[i] - out[i - 1])
    return pd.Series(out, index=x.index)


def average_lag(weights) -> float:
    """一组权重的平均滞后：每个值「过去了几根」按权重加权平均。weights[0] 是最新的一根（滞后 0）。

    SMA 是 (n - 1) / 2；WMA 是 (n - 1) / 3；EMA 是 (1 - alpha) / alpha，alpha = 2 / (n + 1) 时正好也是 (n - 1) / 2。
    """
    w = np.asarray(weights, dtype=float)
    return float(np.dot(np.arange(len(w)), w) / w.sum())


def cross_above(a: pd.Series, b: pd.Series) -> pd.Series:
    """a 从不高于 b 变成高于 b 的那一根为 True（上穿）。前一根或这一根有 NaN 时为 False。"""
    return (a > b) & (a.shift(1) <= b.shift(1))


def cross_below(a: pd.Series, b: pd.Series) -> pd.Series:
    """a 从不低于 b 变成低于 b 的那一根为 True（下穿）。"""
    return (a < b) & (a.shift(1) >= b.shift(1))


def bias(close: pd.Series, ma: pd.Series) -> pd.Series:
    """乖离率：收盘价偏离均线的比例，close / ma - 1。"""
    return close / ma - 1

def test_moving_averages_by_hand():
    x = hourly([2, 4, 6, 8, 4])
    assert I.sma(x, 3).iloc[2:].tolist() == pytest.approx([4, 6, 6])
    # 权重 1、2、3：(2 + 8 + 18) / 6，(4 + 12 + 24) / 6，(6 + 16 + 12) / 6
    assert I.wma(x, 3).iloc[2:].tolist() == pytest.approx([28 / 6, 40 / 6, 34 / 6])
    # alpha = 2 / 4 = 0.5；第一个值是前 3 个的平均 4，然后 4 + 0.5 × (8 - 4) = 6，6 + 0.5 × (4 - 6) = 5
    assert I.ema(x, 3).iloc[2:].tolist() == pytest.approx([4, 6, 5])
    for f in (I.sma, I.wma, I.ema):
        assert f(x, 3).iloc[:2].isna().all()                        # 预热期是 NaN，不是 0


def test_average_lag_formulas():
    n = 20
    assert I.average_lag(np.ones(n)) == pytest.approx((n - 1) / 2)
    assert I.average_lag(np.arange(n, 0, -1)) == pytest.approx((n - 1) / 3)
    alpha = 2 / (n + 1)
    assert I.average_lag((1 - alpha) ** np.arange(2000)) == pytest.approx((n - 1) / 2)


def test_moving_averages_lag_exactly_on_a_ramp():
    ramp = hourly(np.arange(300))
    n = 30
    assert (ramp - I.sma(ramp, n)).dropna().to_numpy() == pytest.approx((n - 1) / 2)
    assert (ramp - I.wma(ramp, n)).dropna().to_numpy() == pytest.approx((n - 1) / 3)
    assert (ramp - I.ema(ramp, n)).dropna().to_numpy() == pytest.approx((n - 1) / 2)


def test_ema_skips_leading_nan_and_matches_wilder_smooth():
    x = hourly([np.nan, np.nan, 1, 2, 3, 4])
    assert I.ema(x, 2).iloc[3:].tolist() == pytest.approx([1.5, 2.5, 3.5])
    rng = np.random.default_rng(12)
    y = hourly(100 + np.cumsum(rng.normal(0, 1, 200)))
    pd.testing.assert_series_equal(I.ema(y, 14, alpha=1 / 14), X.wilder_smooth(y, 14))


def test_cross_and_bias_by_hand():
    a = hourly([1, 2, 3, 2, 2, 1])
    b = hourly([2, 2, 2, 2, 2, 2])
    # 2 → 3 是从「等于」变成「高于」，算上穿；3 → 2 → 1 是从「高于」到「等于」再到「低于」，在最后一根算下穿
    assert I.cross_above(a, b).tolist() == [False, False, True, False, False, False]
    assert I.cross_below(a, b).tolist() == [False, False, False, False, False, True]
    assert I.bias(hourly([110, 90]), hourly([100, 100])).tolist() == pytest.approx([0.10, -0.10])


def test_period_must_be_a_positive_integer():
    for bad in (0, -3, 2.5):
        with pytest.raises(ValueError):
            I.sma(hourly([1, 2, 3]), bad)


@pytest.mark.parametrize("name", ["sma", "ema", "wma"])
def test_moving_averages_never_use_the_future(name):
    rng = np.random.default_rng(3)
    x = hourly(100 * np.exp(np.cumsum(rng.normal(0, 0.02, 400))))
    f = getattr(I, name)
    full = f(x, 50)
    for k in [60, 177, 399]:
        pd.testing.assert_series_equal(f(x.iloc[:k], 50), full.iloc[:k])


@pytest.mark.parametrize("name", ["SMA", "EMA", "WMA"])
@pytest.mark.parametrize("n", [1, 2, 9, 50, 200])
def test_moving_averages_match_talib(name, n):
    talib = pytest.importorskip("talib")
    rng = np.random.default_rng(n)
    x = hourly(50_000 * np.exp(np.cumsum(rng.normal(0, 0.03, 3000))))
    ours = getattr(I, name.lower())(x, n).to_numpy()
    theirs = getattr(talib, name)(x.to_numpy(), timeperiod=n)
    assert (np.isnan(ours) == np.isnan(theirs)).all()                 # 预热期一样长
    np.testing.assert_allclose(ours, theirs, rtol=1e-12, atol=1e-8)

pip install -r requirements.txt
pytest -q

........................................................................ [ 75%]
........................                                                 [100%]
96 passed in 0.46s

..................................sssssssssssssss....................... [ 75%]
........................                                                 [100%]
81 passed, 15 skipped in 0.53s