From ed741c16b8811f8a102e16974747e7a6712707cf Mon Sep 17 00:00:00 2001 From: jackyu66git Date: Fri, 28 Aug 2026 23:09:38 +0800 Subject: [PATCH] =?UTF-8?q?research:=20=E4=B8=80=E7=B1=BB=E7=BA=BF?= =?UTF-8?q?=E9=87=8D=E5=BC=80=E2=80=94=E2=80=94=E7=97=85=E6=A0=B9=E6=98=AF?= =?UTF-8?q?=E9=80=89=E6=A0=B7=C3=97=E6=AD=A2=E6=8D=9F=E7=9A=84=E4=BA=A4?= =?UTF-8?q?=E4=BA=92=EF=BC=8C=E4=B8=8D=E6=98=AF=E6=B2=A1=E6=9C=BA=E4=BC=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 用户问「修改 B1/B2 的识别规则呢」，查下来推翻了 §3.399 的关闭结论。 step65 先量机会本身：直接取 seg_list（不经过检测器），线段中位幅度 11.4 ATR， 扣掉 2.9 ATR 确认成本还剩 8.5，是止损的 4.26 倍，93% 的线段装得下。 五币四级别一致。**滞后不是瓶颈**，与原先预期相反。 但这与 §3.397 矛盾（空间在却拿不到），step66 给出解答：之前六次进攻每次只动 一半。完美选样配 2ATR 止损是 0.70/0.83，无选样配结构止损是 0.36， **两个一起是 2.29(5m)/4.11(15m)**，胜率 36%→63% / 44%→70%。是交互不是叠加。 机制来自 MFE/MAE：真底那批逆向行程中位仅 2.24 ATR，2 ATR 止损打掉了 51~58% 的好单；非真底那批逆向行程中位 4.76，放宽只是亏更多。固定 2 ATR 同时做错两件事。 ⚠️ 上界含两个未来函数（线段端点选样、sure_time 入场），是靶子不是策略。 顺带证伪一个我自己的猜测：step58 首轮用 r_scale=True 把 3.9 ATR 止损对应的 runner 目标推到 15.6 ATR（比整段行情还长）。加 --abs-targets 改绝对目标重跑， PF 仍是 0.36，与 r_scale 版完全相同。首轮结论正确，只是理由错了。 Co-authored-by: Cursor --- research/HANDOFF.md | 66 +++++++++++- research/step58_struct_stop.py | 10 +- research/step65_room.py | 180 +++++++++++++++++++++++++++++++++ research/step66_ceiling.py | 152 ++++++++++++++++++++++++++++ 4 files changed, 401 insertions(+), 7 deletions(-) create mode 100644 research/step65_room.py create mode 100644 research/step66_ceiling.py diff --git a/research/HANDOFF.md b/research/HANDOFF.md index eab74b5..c483e63 100644 --- a/research/HANDOFF.md +++ b/research/HANDOFF.md @@ -1438,6 +1438,57 @@ step56 的实时版把滞后压到 ≤1 根但无质量过滤（PF 0.40），ste 同时把止损位推远到 4.87 ATR。用户的悖论方向对，但不是「继承错误」， 是「多等的那两笔把信息也等没了」。 +### 3.3992 ⭐ 一类线重开：病根是选样×止损的交互，不是没机会（step65/58/66） + +用户问「那如果修改 B1/B2 的识别规则呢」。这个问题**推翻了 §3.399 的关闭结论**， +下面三步是重开的依据。 + +**step65：先量机会本身装不装得下确认成本（不经过检测器，直接取 `seg_list`）** + +| 级别 | 线段中位幅度 | 扣 2.9 ATR 确认成本后 | 剩余 > 2ATR 止损 | 剩余/止损 | +|---|---|---|---|---| +| 5m | 11.4 ATR | 8.5 | **93%** | **4.26x** | +| 15m | 10.9 | 8.0 | 93% | 3.99 | +| 1h | 11.5 | 8.6 | 95% | 4.30 | +| 4h | 12.4 | 9.5 | 96% | 4.74 | + +五币四级别一致（10.5~13.7）。**滞后不是瓶颈**——这与我原先的预期相反。 +但它与 §3.397 直接矛盾（空间在，却拿不到），矛盾的解答就是下面这条。 + +**step58 复测：先排除一个伪解释。** 首轮结构止损用了 `r_scale=True`， +3.9 ATR 的止损把 runner 目标推到 15.6 ATR，比 11.4 ATR 的整段行情还长。 +改成绝对 3/8 ATR 目标重跑，PF 仍是 0.36（与 r_scale 版**完全相同**）。 +**我预判的这个修正不成立**，首轮结论正确只是理由错了。 + +**step66：把两个杠杆同时拧（三者首次组合），天花板一次性打开** + +| 5m | 固定 2ATR | 结构+1.0 | +|---|---|---| +| 落在真线段端点（28.7%） | PF **0.70** / 胜率 36% | PF **2.29** / 胜率 63% | +| 没落在（71.3%） | 0.08 | 0.14 | + +15m：真底那批 **0.83 → 4.11**，胜率 44% → 70%。 + +**这是交互效应，不是叠加**——前三次进攻各自只动了一半，所以全部失败： + +| 只做完美选样（step60） | 只放宽止损（step58） | **两个一起（step66）** | +|---|---|---| +| 0.70 / 0.83 | 0.36 | **2.29 / 4.11** | + +MFE/MAE 给出机制：真底那批**逆向行程中位 2.24 ATR（5m）/ 2.08（15m）**， +即 2 ATR 止损**打掉了 51~58% 的好单**；而非真底那批逆向行程中位 4.76/4.93， +放宽只是亏更多。**固定 2 ATR 同时做错两件事：杀掉对的单，又留不住错的单。** + +⚠️ **这个 2.29/4.11 里有两个未来函数，不是策略，是上界**： +(a) 选样用了线段端点；(b) 入场仍在 `sure_time`，而 §3.396 证明实盘还要再晚 15 根。 +它证明的是**失败原因可修（选样精度 + 止损位），而非这个级别没得做**。 + +**由此产生的两个待跑实验：** +1. **实时过滤器 + 结构止损**（唯一值得跑的组合）。step62 的 `ext_run` 实时可算、 + 已把精度做到 47.9%，但当时配 2 ATR 止损所以只到 0.54。天花板说这个配错了。 +2. **超时从 48 根放宽**。线段中位时长 **113 根**，48 根超时在行情走完 42% 时就平仓； + 真底那批 MFE 中位仅 2.37 ATR，很可能就是被截断的（而非行情本身小）。 + ### 3.4 alpha 的来源（step32 消融） 逐条拆掉 `fast_bsp3` 的条件后发现：**alpha 完全来自缠论中枢的上下文定位， @@ -2649,11 +2700,16 @@ API 限流风险隔离三个好处。 §3.396 证明 `sure_time` 对一类是后视产物（PF 2.35 → 0.92）。B4 用的是 同一个 `sure_time` 字段，**在这个回放出结果前，所有 B4 的历史 PF 都待定**。 若 B4 也栽，整条线要重估；若过了，B4 是目前唯一活着的信号 -- [x] **一二类买卖点全线关闭**（step55~62 一类、step64 二类，见 §3.393~3.3991）。 - 一类是**信号指反**（t = −17~−22，有信息但方向错，错在滞后）， - 二类是**信号消失**（两个方向 t 都贴零，且入场离结构止损位 4.87 ATR）。 - 六次独立进攻全部止步 PF 1.0 以下，**含用未来函数选样也只到 0.83**。 - **不要重开**，除非能从机制上解决「等笔确认」带来的滞后 +- [ ] ⭐ **一类线已重开，跑「实时过滤器 + 结构止损」**（§3.3992）。 + §3.399 的关闭结论**已被 step66 推翻**：之前六次进攻每次只动一半， + 完美选样配 2ATR 止损是 0.70，无选样配结构止损是 0.36，**两个一起是 2.29/4.11**。 + 要跑的是 step62 的 `ext_run` 实时过滤器（精度 28.7% → 47.9%）配结构止损， + 看能兑现多少上界。注意上界含两个未来函数，兑现后必须再过因果回放 +- [ ] **一类超时从 48 根放宽**（§3.3992）。线段中位时长 113 根， + 48 根在行情走完 42% 时平仓，真底那批 MFE 中位仅 2.37 ATR 疑似被截断 +- [x] **二类关闭**（step64，§3.3991）。与一类不同，二类是**信号消失**而非信号指反： + 两个方向 t 都贴零，且入场离结构止损位 4.87 ATR（一类 2.90）， + §3.3992 的结构止损解法对它不适用 - [x] **step39**：1m 时点重建 + 窗口扫描 → **2000 根窗口饱和，计算 0.20s， 假阳性 0%，1m 回测口径可信** - [ ] **对齐 step23 与 step42 的 1m 数字**（3.91bp vs 11.06bp）。差距可能来自 diff --git a/research/step58_struct_stop.py b/research/step58_struct_stop.py index fe4f01b..b3e6010 100644 --- a/research/step58_struct_stop.py +++ b/research/step58_struct_stop.py @@ -117,6 +117,12 @@ def main() -> None: ap = argparse.ArgumentParser() ap.add_argument("--tf", default="5m") ap.add_argument("--rows", type=int, default=200_000) + # step65 发现线段中位幅度只有 11.4 ATR，而 r_scale 会把 3.9 ATR 的结构止损 + # 对应的 runner 目标推到 15.6 ATR —— 比整段行情还长，永远打不到。 + # 本脚本首轮全程用了 r_scale=True，等于「放宽止损」和「目标够不着」同时生效， + # 两个效应互相抵消，那轮的结论无效。绝对目标才是与 11.4 ATR 相容的口径。 + ap.add_argument("--abs-targets", action="store_true", + help="目标位用绝对 ATR（3/8）而非按止损等比放大") args = ap.parse_args() d = pd.read_feather(SRC) @@ -149,7 +155,7 @@ def main() -> None: df = fetch_ohlcv(f"{sym}/USDT:USDT", args.tf, args.rows) cache[(sym, args.tf)] = TF_DF(df, 1, args.tf).dataframe - print("目标随止损等比放大，恒定 1.5R 减半 / 4R 收尾，与实盘的 2/3/8 同构。") + print(f"目标位口径：{'绝对 3/8 ATR（装得进 11.4 ATR 的线段）' if args.abs_targets else '随止损等比放大（恒定 1.5R/4R）'}") for flip in (False, True): for label, margin in [("固定2ATR", None), ("结构+0.25", 0.25), ("结构+0.5", 0.5), ("结构+1.0", 1.0), @@ -166,7 +172,7 @@ def main() -> None: # 入场价另一侧同样宽度处，否则两组比的不是同一个东西 sl = (np.full(len(x), 2.0) if margin is None else (x.to_ext.values + margin)) - res = simulate(cdf, t, sl) + res = simulate(cdf, t, sl, r_scale=not args.abs_targets) ok = res.g.notna().values gs.append(res.g[ok]) rs.append(res.r[ok]) diff --git a/research/step65_room.py b/research/step65_room.py new file mode 100644 index 0000000..54c5c1a --- /dev/null +++ b/research/step65_room.py @@ -0,0 +1,180 @@ +"""改识别规则之前，先量机会本身装不装得下确认成本。 + +用户问：改 B1/B2 的识别规则行不行？ + +「改识别规则」有两种含义，第一种已经被测过上限： + (a) 换规则**挑**出更好的 B1 —— step60 用未来函数只留极值落在真线段底 ±2 根内 + 的信号，这是任何识别规则的理论最好情况，PF 仅 0.70~0.83。这一类改法封死。 + +但 0.83 这个上限本身是**结果**，背后是一个从没直接测过的量： + + 一段线段从真底走到真顶，一共有几个 ATR？而等笔确认要花掉 2.9 个。 + +这决定了 (b) 类改法（改**入场时点/构造**，而非改选样）有没有空间： + + 线段幅度 4 ATR -> 进场吃掉 2.9，剩 1.1 去扛 2 ATR 止损，**任何规则都救不活** + 线段幅度 12 ATR -> 2.9 只是小费，值得继续改规则 + +注意这测的是**市场**，不是我们的检测器：标准答案直接取 `seg_list` 的真实端点， +完全不经过 `find_all_bsp`。所以结论对「换任何一套识别规则」都成立。 + +而且这个比值大概率**随级别变化**（ATR 与线段幅度未必同比例缩放），所以跑 +5m/15m/1h/4h。真正的产出不是「改不改规则」，而是**「在哪个级别上改才有意义」**。 + +预算恒等式（每根线段一行）： + 可捕获 = 线段幅度 − 确认成本 需要 > 止损 才有正期望的可能 +""" +from __future__ import annotations + +import argparse +import sys +import warnings +from concurrent.futures import ProcessPoolExecutor, as_completed +from pathlib import Path + +import numpy as np +import pandas as pd + +warnings.filterwarnings("ignore") +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +sys.path.insert(0, str(HERE.parent)) + +OUT = HERE / "out" / "step65_room.feather" +SL_ATR = 2.0 + + +def collect(sym: str, tf: str, rows: int) -> pd.DataFrame | None: + from chanlun import TF_DF + from chanlun.core.ChanEnum import Chan_SEG_DIR + from lib.data import fetch_ohlcv + + try: + df = fetch_ohlcv(f"{sym}/USDT:USDT", tf, rows) + if df is None or len(df) < 3_000: + return None + chan = TF_DF(df, 1, tf, lean=False) + cdf = chan.dataframe + segs = [s for s in (getattr(chan, "seg_list", []) or []) + if s.end_time is not None and s.start_time is not None] + if len(segs) < 20: + return None + + dser = pd.to_datetime(cdf["date"]) + if dser.dt.tz is not None: + dser = dser.dt.tz_localize(None) + didx = pd.DatetimeIndex(dser) + n = len(cdf) + atr = cdf["atr"].to_numpy(float) + hi, lo = cdf["high"].to_numpy(float), cdf["low"].to_numpy(float) + + def to_i(ts) -> int: + t = pd.Timestamp(ts) + return int(didx.searchsorted(t.tz_localize(None) if t.tz else t)) + + rec = [] + for sg in segs: + i0, i1 = to_i(sg.start_time), to_i(sg.end_time) + if not (0 <= i0 < i1 < n) or i1 - i0 < 2: + continue + a = atr[i0] + if not np.isfinite(a) or a <= 0: + continue + up = sg.dir != Chan_SEG_DIR.DOWN + # 从线段起点（上一段的真实反转点）到终点的幅度 + span = ((hi[i0:i1 + 1].max() - lo[i0]) if up + else (hi[i0] - lo[i0:i1 + 1].min())) + rec.append({ + "sym": sym, "tf": tf, "dir": 1 if up else -1, + "bars": i1 - i0, + "span_atr": span / a, + "atr_pct": a / float(cdf["close"].to_numpy(float)[i0]), + }) + return pd.DataFrame(rec) if rec else None + except Exception as e: # noqa: BLE001 + print(f" {sym} {tf} 失败: {type(e).__name__}: {e}", flush=True) + return None + + +TFO = {"5m": 0, "15m": 1, "1h": 2, "4h": 3} + + +def report(d: pd.DataFrame, cost: float) -> None: + print("\n" + "=" * 96) + print(f"【一】线段幅度 vs 确认成本（成本按一类实测的 {cost} ATR 计）") + print("=" * 96) + rows = [] + for tf, x in sorted(d.groupby("tf"), key=lambda kv: TFO.get(kv[0], 9)): + q = x.span_atr.quantile([.25, .5, .75]).values + room = x.span_atr - cost + rows.append({ + "级别": tf, "线段数": len(x), + "幅度Q1": round(q[0], 1), "幅度中位": round(q[1], 1), + "幅度Q3": round(q[2], 1), + "确认后剩余(中位)": round(q[1] - cost, 1), + f"剩余>止损{SL_ATR}": f"{(room > SL_ATR).mean()*100:.0f}%", + "剩余/止损": round((q[1] - cost) / SL_ATR, 2), + "中位时长(根)": int(x.bars.median()), + }) + print(pd.DataFrame(rows).to_string(index=False)) + print(f""" + 「剩余/止损」是这张表的结论行：真底进场、扣掉确认成本后，还剩几倍止损的空间。 + < 1 机会装不下确认成本，**换任何识别规则都没用** + 1~2 勉强打平，要求选样精度极高（step60 实测最好 30%） + > 2 有空间，值得改规则/改入场构造""") + + print("\n【二】把确认成本当变量：多低才够用") + rows = [] + for tf, x in sorted(d.groupby("tf"), key=lambda kv: TFO.get(kv[0], 9)): + r = {"级别": tf} + for c in (0.0, 1.0, 2.0, 2.9): + r[f"成本{c}"] = round((x.span_atr.median() - c) / SL_ATR, 2) + rows.append(r) + print(pd.DataFrame(rows).to_string(index=False)) + print("\n 成本 0 = 完美实时（在真底那根就进）。若连成本 0 那列都 < 2，" + "\n 说明**不是滞后的问题，是这个级别的线段本身就太小**。") + + print("\n【三】逐币（中位幅度 ATR），看结论是否普适") + print(d.pivot_table(index="sym", columns="tf", values="span_atr", + aggfunc="median").round(1) + .reindex(columns=[t for t in TFO if t in set(d.tf)]) + .to_string()) + + +def main() -> None: + ap = argparse.ArgumentParser() + ap.add_argument("--symbols", default="BTC,ETH,SOL,LINK,DOGE") + ap.add_argument("--tfs", default="5m,15m,1h,4h") + ap.add_argument("--rows", type=int, default=200_000) + ap.add_argument("--cost", type=float, default=2.9) + ap.add_argument("--workers", type=int, default=2) + ap.add_argument("--reuse", action="store_true") + args = ap.parse_args() + + if args.reuse and OUT.exists(): + report(pd.read_feather(OUT), args.cost) + return + syms = [s.strip() for s in args.symbols.split(",")] + tfs = [t.strip() for t in args.tfs.split(",")] + parts = [] + with ProcessPoolExecutor(max_workers=args.workers) as ex: + fut = {ex.submit(collect, s, t, args.rows): (s, t) + for s in syms for t in tfs} + for i, f in enumerate(as_completed(fut), 1): + r = f.result() + s, t = fut[f] + print(f" [{i}/{len(fut)}] {s} {t} " + f"{0 if r is None else len(r)}", flush=True) + if r is not None: + parts.append(r) + if not parts: + print("无结果") + return + d = pd.concat(parts, ignore_index=True) + OUT.parent.mkdir(exist_ok=True) + d.to_feather(OUT) + report(d, args.cost) + + +if __name__ == "__main__": + main() diff --git a/research/step66_ceiling.py b/research/step66_ceiling.py new file mode 100644 index 0000000..506de2e --- /dev/null +++ b/research/step66_ceiling.py @@ -0,0 +1,152 @@ +"""改识别规则到底有没有用：把天花板一次性测到顶。 + +用户问「改 B1/B2 的识别规则呢」。step65 让这个问题变得可判定，但也制造了一个 +必须解释的矛盾： + + 线段中位 11.4 ATR，进场花掉 2.9，剩 8.5 —— 是 2 ATR 止损的 4.26 倍。 + 可 step60 用未来函数选出真底的那批 B1，PF 仍只有 0.70~0.83。 + +空间明明在，就是拿不到。两种解释对用户的问题给出**相反**的答案： + + 选样问题：只有 30% 的 B1 落在真线段底，那 8.5 ATR 只存在于这 30% 里， + 其余 70% 是趋势中途，后面根本没有行情 -> **改识别规则有用** + 路径问题：就算落在真底，11.4 ATR 是净幅度，路上的回撤照样打掉止损 + -> **改识别规则没用** + +区分只需要一个从没跑过的组合：**未来函数选样 + 结构止损 + 绝对目标**。 +三样单独都失败过（step60 的 0.83 / step58 的 0.36 / 本轮 abs 的 0.36）， +组合起来没试过。它测的不是某条规则，是**所有识别规则的上界**： + + 上界 < 1.0 -> 路径问题，一类线彻底关闭，别再改规则 + 上界 > 1.5 -> 选样问题，改识别规则有用，且这里就是要够到的目标 + +同时量 MFE 做交叉验证：真底那批到底跑没跑出 8.5 ATR。 + 跑出来了却还是亏 -> 铁证是止损/路径 + 根本没跑出来 -> 说明 11.4 ATR 那个测量传导不到这批信号上，step65 要重解释 +""" +from __future__ import annotations + +import argparse +import sys +import warnings +from pathlib import Path + +import numpy as np +import pandas as pd + +warnings.filterwarnings("ignore") +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +sys.path.insert(0, str(HERE.parent)) + +SRC = HERE / "out" / "step64_b2.feather" +MAXB = 48 + + +def mfe_mae(cdf: pd.DataFrame, idx: np.ndarray, dirs: np.ndarray, + atr: np.ndarray) -> tuple[np.ndarray, np.ndarray]: + """入场后 MAXB 根内最远的顺向/逆向行程（ATR）。""" + hi, lo = cdf["high"].to_numpy(float), cdf["low"].to_numpy(float) + op = cdf["open"].to_numpy(float) + n = len(cdf) + fe = np.full(len(idx), np.nan) + ae = np.full(len(idx), np.nan) + for k, (i, d, a) in enumerate(zip(idx, dirs, atr)): + e = int(i) + 1 + if e >= n or not np.isfinite(a) or a <= 0: + continue + j = min(e + MAXB, n) + px = op[e] + if d == 1: + fe[k] = (hi[e:j].max() - px) / a + ae[k] = (px - lo[e:j].min()) / a + else: + fe[k] = (px - lo[e:j].min()) / a + ae[k] = (hi[e:j].max() - px) / a + return fe, ae + + +def main() -> None: + ap = argparse.ArgumentParser() + ap.add_argument("--tf", default="5m") + ap.add_argument("--rows", type=int, default=200_000) + args = ap.parse_args() + + from chanlun import TF_DF + from lib.data import fetch_ohlcv + from step58_struct_stop import simulate, stats + + d = pd.read_feather(SRC) + d = d[(d.tf == args.tf) & d.type.isin(["B1", "S1"])].copy() + d["to_ext"] = (d.entry_px - d.own_ext) * d.dir / d.atr_at_entry + print(f"[识别规则天花板] {args.tf} · 一类 {len(d)} 笔 · " + f"其中落在真线段端点 {d.hit.sum()} 笔 ({d.hit.mean()*100:.1f}%)\n") + + cache = {} + for sym in sorted(d.sym.unique()): + df = fetch_ohlcv(f"{sym}/USDT:USDT", args.tf, args.rows) + cache[sym] = TF_DF(df, 1, args.tf).dataframe + + print("=" * 96) + print("【一】MFE 交叉验证：真底那批到底跑没跑出 step65 说的 8.5 ATR") + print("=" * 96) + rows = [] + for k, g in d.groupby(d.hit): + fe, ae = [], [] + for sym, x in g.groupby("sym"): + f_, a_ = mfe_mae(cache[sym], x.i_sure.values, x.dir.values, + x.atr_at_entry.values) + fe.append(f_) + ae.append(a_) + fe, ae = np.concatenate(fe), np.concatenate(ae) + ok = np.isfinite(fe) + rows.append({ + "落在真线段端点": "是" if k else "否", "笔数": int(ok.sum()), + "MFE中位": round(float(np.median(fe[ok])), 2), + "MFE≥3ATR": f"{(fe[ok] >= 3).mean()*100:.0f}%", + "MFE≥8ATR": f"{(fe[ok] >= 8).mean()*100:.0f}%", + "MAE中位": round(float(np.median(ae[ok])), 2), + "MAE≥2ATR(会被现止损打掉)": f"{(ae[ok] >= 2).mean()*100:.0f}%", + }) + print(pd.DataFrame(rows).to_string(index=False)) + print(""" + 判读：若「是」那行 MFE 中位远低于 8.5，说明 step65 的线段幅度传导不到 + 信号上（进场时行情已经走掉了大半）；若 MFE 够大而 MAE 也大，则是路径问题。""") + + print("\n" + "=" * 96) + print("【二】天花板：未来函数选样 + 结构止损 + 绝对目标（三者首次组合）") + print("=" * 96) + rows = [] + for k, g in d.groupby(d.hit): + for label, margin in [("固定2ATR", None), ("结构+0.5", 0.5), + ("结构+1.0", 1.0), ("结构+1.5", 1.5)]: + gs, rs, cs, ap_, sl_ = [], [], [], [], [] + for sym, x in g.groupby("sym"): + x = x.reset_index(drop=True) + t = pd.DataFrame({"entry_idx": x.i_sure.values, + "direction": x.dir.values, + "atr_at_entry": x.atr_at_entry.values}) + sl = (np.full(len(x), 2.0) if margin is None + else (x.to_ext.values + margin)) + res = simulate(cache[sym], t, sl, r_scale=False) + ok = res.g.notna().values + gs.append(res.g[ok]) + rs.append(res.r[ok]) + cs.append(res.c[ok]) + ap_.append((x.atr_at_entry.values / x.entry_px.values)[ok]) + sl_.append(sl[ok]) + rows.append({ + "落在真线段端点": "是" if k else "否", "止损": label, + **stats(pd.concat(gs, ignore_index=True), + pd.concat(rs, ignore_index=True), + pd.concat(cs, ignore_index=True), + np.concatenate(ap_), np.concatenate(sl_))}) + print(pd.DataFrame(rows).to_string(index=False)) + print(""" + 「是」那几行就是**任何识别规则的上界**（因为选样已经用了未来函数）： + < 1.0 路径问题，一类线关闭，改规则无解 + > 1.5 选样问题，改识别规则有用，且这就是要够到的目标""") + + +if __name__ == "__main__": + main()