diff --git a/README.md b/README.md index e01ef0c..355d51e 100644 --- a/README.md +++ b/README.md @@ -9,6 +9,8 @@ - [问题三搜索与总耗时改进方案（含七点覆盖证明和自建消融）](docs/algo-3.md) - [第三、四问系统性架构优化与运行提速方案（运行历史复核、最小命中集、联合信念）](docs/第三四问架构优化与运行提速方案.md) - [第三、四问图论与动态规划优化方案（定点实测、路由 gap、定向定位 DP、证书硬化）](docs/第三四问图论与动态规划优化方案.md) +- [1-4 问最优与基线实现对比框架](project/README.md)（`uv run python -m project.run`，结果在 `project/results/`） +- [最优与基线实现对比（论文口径说明）](docs/最优与基线实现对比.md) - [论文](docs/paper/main.tex) ## 项目结构 @@ -27,6 +29,8 @@ src/mcm26b/ ├── evaluation/ # 日志复算与统计（已完工） └── harness/ # 测试侧适配：评测机<->Transport 内存回环、故障注入、回放、场景 tests/ # pytest（含解耦守卫：运行时零导入 referee + 规则表不漂移） +project/ # 1-4 问"最优实现 / 基线实现"对比框架：逐问 optimal+baseline + # +独立参考，冻结基准集配对出数；见 project/README.md scripts/ # 采集、基准、可视化与校核脚本（含问题四批量仿真 benchmark_q4.py、 # 运行历史计时分解 analyze_run_timing.py、第四问覆盖证书 verify_q4_cover.py） output/ examples/ # 演练证据、算例与生成产物 diff --git a/docs/最优与基线实现对比.md b/docs/最优与基线实现对比.md new file mode 100644 index 0000000..908bcdd --- /dev/null +++ b/docs/最优与基线实现对比.md @@ -0,0 +1,131 @@ +# 问题一至四：最优实现与基线实现对比 + +本文件是四问"最优实现 / 基线实现"对比的**论文口径说明**。代码与可复现 +产物在仓库根目录 `project/`，运行 `uv run python -m project.run` 一次生成 +`project/results/summary.md` 与逐问 `q1.md … q4.md`。本文件只摘录设计与结论， +数字以后者为唯一来源。 + +## 1. 交付物与目录 + +```text +project/ +├── README.md 设计原则、各问对比设计、口径与边界 +├── common.py 方法描述 / 指标聚合 / 落盘 / 闭环装配 +├── run.py 统一入口（--question/--quick） +├── results/ 自动生成：q1.md/json … q4.md/json + summary.md +├── q1/ optimal.py baseline.py reference.py cases.py compare.py +├── q2/ optimal.py baseline.py reference.py region.py cases.py compare.py +├── q3/ optimal.py baseline.py compare.py +└── q4/ optimal.py baseline.py compare.py +``` + +角色边界： + +- **最优实现**：直接适配 `src/mcm26b` 中已由 pytest 固化的生产实现， + 不重写算法； +- **基线实现**：同题下更朴素、但能独立跑通的对照，不共享最优实现的关键步骤； +- **独立参考**：与分析算法正交的数值/枚举标准，用于判定谁对谁错。 + +第三、四问统一走 `LocalSimulator` 内存回环（与官方 HTTP 协议同一边界）， +真值只在评测机侧；有效性判定沿用项目口径： +**全清 ∧ 无缺席误判 ∧ 正常 `/exit` ∧ 零异常 ∧ 逐微秒计时复算一致**。 + +## 2. 四问方法设计对照 + +| 问 | 最优实现 | 基线实现 | 独立参考 | 主要指标 | +| --- | --- | --- | --- | --- | +| 1 | 半平面交 + 顶点对精确直径 + Welzl MEC + 覆盖反例 | 网格采样 + **包围盒对角线**代理直径/覆盖 | 大框半平面裁剪 + 暴力直径/MEC | 状态、直径误差、覆盖准确率、耗时 | +| 2 | 保证接收盘内最小最坏后验半径（生产选点器） | ① 垂直 1000 m 最大交会角；② 候选集 MEC 圆心 | 保证接收盘内 9×9 网格枚举 | 保证接收率、最坏后验半径、移动时间 | +| 3 | `bayes`：粒子滤波 + 信息增益 + 滚动 2-opt | `grid`：49 点网格 + 就近服务；`seven`：七点批量 | 冻结基准集 + 真值全清校验 | 全清率、虚拟时间及其分布 | +| 4 | `directional`：31 点定向覆盖 + 联合信念 + 后备清除 | 问题三策略直接搬用（`bayes` / `grid`） | 冻结基准集（core+boundary） | 全清率、**缺席误判**、虚拟时间 | + +## 3. 对比结果 + +### 3.1 问题一（40 个随机交会算例） + +| 指标 | 最优 | 基线 | +| --- | --- | --- | +| 状态判定准确率 | 100% | 100% | +| 直径平均绝对误差 | **0.000 m** | 4.583 m（最大 14.60 m） | +| 直径圆覆盖判定准确率 | **100%** | 52.5% | +| 平均耗时 | **0.11 ms** | 22.35 ms | + +固定示例进一步给出结构性反例（`examples/q1`，解析期望由 +`tests/test_geometry*.py` 固化）： + +- `normal`：直径 26.99 m，**直径圆不覆盖**定位区域（最优判否、基线判是）； +- `triangle`：直径 40.00 m 的等边三角形反例，最小包围圆半径 23.09 m > 20 m， + 直径圆不覆盖；基线因"包围盒中心 + 对角线"恒判覆盖； +- `poor`：近共线检测点 → 无界，最优/基线/参考一致判无界； +- `segment`：零误差退化线段，最优判线段 D=100 m 且覆盖成立，基线退化为点； +- `empty`：观测不相容 → 空集。 + +> 基线的两处结构性缺陷：直径用包围盒对角线在斜/细长区域系统性高估； +> 覆盖用包围盒中心圆则恒判"能覆盖"，恰好丢掉问题一要考的反例。 + +### 3.2 问题二（30 个随机首次示向度，初始 ρ 均值 681.5 m） + +| 方法 | 保证接收率 | 最坏后验均值 | 终值比 ρ'/ρ | 移动均值 | +| --- | --- | --- | --- | --- | +| 最优（保证盘内最小最坏后验） | 100% | **73.89 m** | 0.104 | 170.4 s | +| 基线① 垂直 1000 m 最大交会角 | **0%** | 80.11 m | 0.116 | 200.0 s | +| 基线② MEC 圆心 | 100% | 340.75 m | 0.500 | 136.3 s | +| 参考（保证盘内网格枚举） | 100% | 75.63 m | 0.106 | 170.3 s | + +> 基线①说明"只追交会角"会在本题失败：首次角域可延伸到 1500 m， +> 真源在远端时第二点距离超过 1000 m，测量直接 `no_signal`。 +> 基线②保证接收但后验几乎不收缩（≈0.5ρ）。最优在同等保证下把后验压到 0.10ρ， +> 且与网格参考几乎重合（生产采样质量足够）。 + +### 3.3 问题三（18 个冻结 core 场景，全向 10/13/16 源） + +| 方法 | 有效局 | 全清率 | 虚拟时间均值 | 中位 | 检测均值 | 请求均值 | 位移均值 | +| --- | --- | --- | --- | --- | --- | --- | --- | +| 最优 `bayes` | 18/18 | 100% | **3188.7 s** | 3111.3 s | 111.1 | 124.1 | 12338 m | +| 中间 `seven` | 18/18 | 100% | 5361.7 s | 5367.5 s | 100.8 | 113.8 | 23508 m | +| 基线 `grid` | 18/18 | 100% | 14935.7 s | 15275.1 s | 430.6 | 443.6 | 61550 m | + +配对变化：`bayes` 相对 `grid` 虚拟时间 **−78.4%**（18/18 场景更快）， +`seven` 相对 `grid` −63.7%。全部 54 局零异常、计时复算一致。 + +### 3.4 问题四（11 个冻结 core+boundary 场景，含朝外发射的边界定向源） + +| 方法 | 有效局 | 全清率 | 缺席误判 | 虚拟时间均值 | 后备清除均值 | +| --- | --- | --- | --- | --- | --- | +| 最优 `directional` | 11/11 | **100%** | **0** | 9069.9 s | 24.8 | +| 基线 `grid`（49 点全向） | 0/11 | 67% | 0 | 18179.2 s | 0 | +| 基线 `bayes`（七站全向缺席证明） | 0/11 | 77% | **24** | 3890.8 s | 0 | + +> 两条搬用基线的失效机理不同： +> `bayes` 用七站环的**全向**缺席证明，遇到背离圆心发射的边界定向源时 +> 会把真源直接判成 ABSENT（累计 24 次 **缺席误判**，属"快而错"，其虚拟时间 +> 不可与最优直接比较）；`grid` 的 49 点覆盖对定向源发现是完备的，但缺少 +> 定向观测推理与 ≤20 m 后备清除，定位停滞只能停在 DETECTED（"稳而不全"）。 +> 最优 `directional` 两种工况都是 11/11 全清、零误判，代价是多花时间与 +> 平均 24.8 次后备清除。 + +## 4. 结论 + +1. 问题一：生产几何内核对状态、直径、覆盖三项与独立参考**逐案一致**； + 朴素包围盒基线在覆盖判定上只有约 52% 准确率，且对固定反例全错。 +2. 问题二：只有在"保证接收"约束内优化后验才既安全又有效；最优相对保守 + 基线把最坏后验半径从 0.5ρ 降到 0.10ρ，且与网格参考几乎重合。 +3. 问题三：`bayes` 在相同全清率下把虚拟时间降到 `grid` 的约 1/5， + 且逐场景配对 18/18 更快，说明"负观测感知 + 信息增益选点 + 全局排序" + 三步都产生净收益。 +4. 问题四：定向源的难点不是"发现"而是"证明缺席"与"失去信号后的清除"； + 直接搬用第三问策略会得到 24 次缺席误判，不可接受。`directional` 的 + 联合信念 + 后备清除是 11/11 全清的关键。 + +写论文时建议按"基线为什么错 → 最优补了哪一步 → 独立参考如何判定"的三段式 +展开，并声明：随机分布是测试假设；基线时间快于最优的场景（如问题四 `bayes`） +不构成有效性优势，因为该局基线未完成全清任务。 + +## 5. 复现 + +```bash +uv run python -m project.run # 四问全部（约 3–4 分钟） +uv run python -m project.run --question 1 # 只跑问题一 +uv run python -m project.run --quick # 缩小算例/基准集规模 +uv run pytest tests/test_geometry.py tests/test_geometry_certificates.py -q # 几何回归 +``` diff --git a/project/README.md b/project/README.md new file mode 100644 index 0000000..a2fc676 --- /dev/null +++ b/project/README.md @@ -0,0 +1,124 @@ +# 1-4 问「最优实现 / 基线实现」对比框架 + +本目录**不是**比赛运行时代码，而是把四问的生产实现与独立基线放在同一口径下 +配对对比、生成可写进论文的"算法对比"证据。运行时代码仍只有 `src/mcm26b`， +`project/` 只依赖它和测试侧内存回环，不反向污染求解入口。 + +## 1. 设计原则 + +| 角色 | 含义 | 约束 | +| --- | --- | --- | +| **最优实现** | 复用 `src/mcm26b` 中已由测试固化的生产实现 | 不复制算法，只做 I/O 适配 | +| **基线实现** | 同题下更朴素、但能独立跑通的对照 | 不得共享最优实现的关键步骤 | +| **独立参考** | 与分析算法正交的数值/枚举标准 | 用于判定谁对谁错，而非自证 | + +- 第三、四问走 `LocalSimulator` 内存回环，与官方 HTTP 协议同一边界； + 真值只在评测机侧，策略端只看响应，因此"全清率/缺席误判"是可信的。 +- 闭环有效性判定沿用项目口径：**全清 ∧ 无缺席误判 ∧ 正常 `/exit` ∧ 零异常 + ∧ 逐微秒计时复算一致**，任何一项不满足该局记为无效，失败不静默丢样本。 +- 所有对比都按 `scene_id` 配对，汇总同时给均值、中位、最大与相对基线的 + 配对变化，避免"均值好看但逐局更差"。 + +## 2. 目录结构与职责 + +```text +project/ +├── README.md 本文件 +├── common.py 公共层：方法描述、指标聚合、结果落盘、闭环装配 +├── run.py 统一入口：一次跑完四问并生成 results/ +├── results/ 自动生成：q1.md/json … q4.md/json + summary.md +├── q1/ 问题一：交会定位区域直径与直径圆覆盖 +│ ├── optimal.py 最优：半平面交 + 顶点对精确直径 + Welzl MEC + 覆盖反例 +│ ├── baseline.py 基线：网格采样 + 轴对齐包围盒对角线代理 +│ ├── reference.py 参考：大框 Sutherland–Hodgman 半平面裁剪 + 精确直径/MEC +│ ├── cases.py 固定示例（examples/q1）+ 随机交会算例 +│ └── compare.py 同案配对：状态/直径/覆盖/耗时 +├── q2/ 问题二：第二检测点选择 +│ ├── optimal.py 最优：保证接收盘内最小最坏后验半径（生产选点器） +│ ├── baseline.py 基线：垂直 1000 m 最大交会角 / 候选集 MEC 圆心 +│ ├── reference.py 参考：保证接收盘内稠密网格枚举 +│ ├── region.py K1 = Ω ∩ 角域 ∩ B(s,1500) 统一构造 +│ ├── cases.py 随机首次示向度算例 +│ └── compare.py 统一评估器：保证接收、最坏后验、移动代价 +├── q3/ 问题三：全向源闭环 +│ ├── optimal.py 最优：bayes（粒子滤波 + 信息增益 + 滚动 2-opt） +│ ├── baseline.py 基线：grid（49 点网格）/ seven（七点批量） +│ └── compare.py 冻结基准集 core 配对对比 +└── q4/ 问题四：含定向源闭环 + ├── optimal.py 最优：directional（联合信念 + 后备清除 + 定向覆盖计划） + ├── baseline.py 基线：把问题三策略直接搬用（bayes / grid） + └── compare.py 冻结基准集 core+boundary 配对对比 +``` + +## 3. 各问对比设计 + +### 问题一（`q1/`） + +- **最优**：`mcm26b.geometry.localization.solve`，半平面交求凸多边形，顶点对 + 枚举直径，Welzl 最小包围圆，并输出直径圆覆盖判断、圆外顶点与最大超出距离。 +- **基线**：固定大框网格采样，直径取**包围盒对角线**、覆盖取"包围盒中心 + + 代理直径圆"。它在斜/细长区域上系统性高估直径，并对任意包围盒都几乎恒判覆盖。 +- **参考**：从 ±1e7 m 大框出发逐半平面 Sutherland–Hodgman 裁剪，独立实现 + 直径暴力枚举与 1/2/3 点支撑圆暴力最小包围圆。与最优实现共享 0 个内部步骤。 +- 指标：状态判定、直径绝对误差、直径圆覆盖准确率、运行耗时。 + +### 问题二（`q2/`） + +- 候选集 `K1 = Ω ∩ W(s,θ±δ_eff) ∩ B(s,1500)`，三个方法共用同一次构造。 +- **最优**：保证接收盘 `B(MEC 圆心, 1000−ρ)` 内环形采样，最小化"目标边界点 × + 读数区间端点"的最坏后验半径，移动时间同分决胜；保证接收严格，采样是启发式。 +- **基线**：① 垂直首次示向度 1000 m 的"90° 交会点"——忽略接收保证，真源在 + 角域远端时必然 `no_signal`；② 候选集 MEC 圆心——保证接收但交会角可能最差。 +- **参考**：保证接收盘内 9×9 网格枚举同一目标函数，检验生产采样接近网格最优。 +- 指标：保证接收率、最坏后验包围半径、收缩量、移动时间。 + +### 问题三（`q3/`） + +- **最优** `bayes`：网格粒子滤波幸存集 + 期望信息增益选点 + 滚动 2-opt 任务排序。 +- **基线** `grid`：49 点（700 m 步长）网格发现 + 就近服务；`seven`：七点解析 + 覆盖 + 同站批量扫频，作为"覆盖证明 + 批量调度"的中间对照。 +- 冻结基准集 `harness.suites`（种子/源数版本化），逐局校验全清与计时复算。 +- 指标：全清率、均值/中位/最大虚拟时间、检测数、请求数、位移、墙钟。 + +### 问题四（`q4/`） + +- **最优** `directional`：31 点定向覆盖计划 + 朝向遮挡推理 + (位置×朝向) 联合 + 信念 + ≤20 m 有限圆盘后备清除。 +- **基线**：把问题三策略原样搬用——`bayes` 的七站全向缺席证明会把朝外定向源 + 误判为 ABSENT（"快而错"）；`grid` 的 49 点覆盖对定向源发现完备，但无后备清除， + 定位停滞只能停在 DETECTED（"稳而不全"）。 +- 冻结基准集 `core+boundary`，其中 `boundary` 场景全部为背离圆心发射的边界定向 + 源，是最不利工况。 +- 指标：全清率、缺席误判数、虚拟时间、后备清除次数、墙钟。 + +## 4. 运行方式 + +```bash +uv run python -m project.run # 四问全部，写入 project/results/ +uv run python -m project.run --question 1 # 只跑问题一 +uv run python -m project.run --quick # 缩小随机算例/基准集规模 +``` + +> `project/` 用到 `numpy`（网格参考解）。它随 dev 依赖组（optuna）安装； +> 只跑正式求解入口 `mcm26b` 不需要它。 + +## 5. 结果文件 + +| 文件 | 内容 | +| --- | --- | +| `results/q1.md` / `q1.json` | 固定示例 + 随机算例的逐案明细与汇总 | +| `results/q2.md` / `q2.json` | 逐案第二点位置、保证接收、最坏后验与汇总 | +| `results/q3.md` / `q3.json` | 冻结基准集逐场景明细、逐方法汇总、配对变化 | +| `results/q4.md` / `q4.json` | core+boundary 逐场景明细与汇总 | +| `results/summary.md` | 四问核心指标总览 + 方法映射 + 目录结构 | + +## 6. 口径与边界（写论文时必须一并声明） + +- 问题一参考解与最优实现都是精确算法；固定示例的解析期望另有 + `tests/test_geometry*.py` 固化，本框架在其上补齐"朴素基线错在哪"。 +- 问题二"最坏后验半径"是**对候选集外包多边形的启发式评估**，不是连续问题 + 的全局最优证明；生产实现与参考网格共享该目标函数，只比较搜索质量。 +- 问题三、四的随机分布（源位置均匀、误差场逐点固定等）是**测试假设**， + 题面未规定；正式成绩以官方模拟器演练/正式测试为准。 +- 基线不是稻草人：`q2` 的 MEC 圆心、`q3` 的 `seven`、`q4` 的 `grid` 都是 + 能独立跑通、在部分场景有效的真实方法；它们暴露的是"缺了哪一步"。 diff --git a/project/__init__.py b/project/__init__.py new file mode 100644 index 0000000..019ff59 --- /dev/null +++ b/project/__init__.py @@ -0,0 +1,18 @@ +"""1-4 问"最优实现 / 基线实现"统一对比框架（非运行时依赖，仅用于分析与论文）。 + +本包不改动正式求解入口 ``mcm26b``，只做三层组织： + +- ``project.q1`` … ``project.q4``：四个问题各自的 + ``optimal.py``（生产最优实现，直接复用 ``mcm26b`` 内核）、 + ``baseline.py``（朴素基线，参照组）、``compare.py``（同题配对对比）； +- ``project.common``：方法描述、指标聚合、结果落盘、离线闭环装配； +- ``project.run``：统一入口，一次跑完四问并生成 ``project/results/``。 + +运行方式（仓库根目录）:: + + uv run python -m project.run # 四问全部 + uv run python -m project.run --question 3 # 只跑第三问 + uv run python -m project.run --quick # 缩小随机场景数 +""" + +__all__ = ["common"] diff --git a/project/common.py b/project/common.py new file mode 100644 index 0000000..c4f7007 --- /dev/null +++ b/project/common.py @@ -0,0 +1,308 @@ +"""对比框架公共层：方法描述、指标聚合、结果落盘、离线闭环装配。 + +设计口径 +-------- +- **最优实现** = 复用 ``src/mcm26b`` 中已由测试固化的生产实现； +- **基线实现** = 同题下更朴素但可独立运行的参照实现（不得共享最优实现的 + 关键步骤），用于量化"生产实现好在哪里、差多少"； +- **参考解** = 与分析算法相互独立的数值/枚举标准，用来判定谁对谁错。 + +第三、四问是闭环问题，统一走 ``LocalSimulator`` 内存回环（与官方 HTTP +协议同一边界），真值只在评测机侧，策略端只看响应。 +""" + +from __future__ import annotations + +import json +import statistics +from dataclasses import dataclass, replace +from pathlib import Path +from time import perf_counter + +from mcm26b.config import ProblemConfig +from mcm26b.evaluation import recompute_virtual_time +from mcm26b.harness import LocalSimTransport, LocalSimulator +from mcm26b.protocol.client import SimulatorClient + +ROOT = Path(__file__).resolve().parents[1] +RESULTS_DIR = Path(__file__).resolve().parent / "results" + + +@dataclass(frozen=True) +class Method: + """一个可对比方法：key 用作图表列名，kind 用于区分最优/基线/参考。""" + + key: str + name: str + kind: str # optimal | baseline | reference + note: str = "" + + +def problem_config(*, persistent_search: bool = False, + margin_deg: float | None = None) -> ProblemConfig: + """对比口径配置：默认关闭"扫到限时"的持续复扫（对齐首次找全证明）。""" + base = ProblemConfig() + kwargs: dict = {"persistent_search": persistent_search} + if margin_deg is not None: + kwargs["bearing_rounding_margin_deg"] = margin_deg + return replace(base, search=replace(base.search, **kwargs)) + + +# ---------------------------------------------------------------- 结果落盘 +def write_json(path: Path, payload) -> Path: + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(json.dumps(payload, ensure_ascii=False, indent=2, + allow_nan=False) + "\n", encoding="utf-8") + return path + + +def write_text(path: Path, text: str) -> Path: + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(text, encoding="utf-8") + return path + + +# ---------------------------------------------------------------- 指标工具 +def mean(values) -> float: + values = list(values) + return round(statistics.fmean(values), 4) if values else 0.0 + + +def median(values) -> float: + values = list(values) + return round(statistics.median(values), 4) if values else 0.0 + + +def ratio(hit: int, total: int) -> float: + return round(hit / total, 4) if total else 0.0 + + +def relative_change(value: float, reference: float) -> float | None: + if reference == 0: + return None + return round(value / reference - 1.0, 4) + + +def markdown_table(headers: list[str], rows: list[list[str]]) -> str: + lines = ["| " + " | ".join(headers) + " |", + "| " + " | ".join("---" for _ in headers) + " |"] + for row in rows: + lines.append("| " + " | ".join(str(cell) for cell in row) + " |") + return "\n".join(lines) + + +def _num(value, digits: int = 2) -> str: + if value is None: + return "—" + if isinstance(value, bool): + return "✔" if value else "✘" + if isinstance(value, float): + return f"{value:.{digits}f}" + return str(value) + + +# ---------------------------------------------------------------- 第三/四问闭环 +def run_loop_episode(loop_cls, scene_spec, config: ProblemConfig) -> dict: + """在冻结场景上跑一局闭环，返回逐局指标行（与 ``scripts/run_suite.py`` 同口径）。""" + sources = scene_spec.sources(config) # 真值：仅测试端可见 + simulator = LocalSimulator(sources, robot_id="COMPARE", config=config, + error_seed=scene_spec.error_seed) + client = SimulatorClient("COMPARE", config=config, + transport=LocalSimTransport(simulator)) + start = perf_counter() + loop = loop_cls(client, config) + summary = loop.run() + compute_wall_s = perf_counter() - start + report = recompute_virtual_time(client.log.action_events()) + + truth = sorted(source.channel for source in sources) + cleared = sorted(summary["cleared_channels"]) + absent = sorted(summary["absent_channels"]) + misjudged = sorted(set(absent) & set(truth)) + valid = (cleared == truth and not misjudged + and summary["exit_reason"] == "user_exit" + and not summary["anomalies"] + and not report["mismatches"]) + return { + "scene_id": scene_spec.scene_id, + "problem": scene_spec.problem, + "kind": scene_spec.kind, + "sources": len(truth), + "directional": scene_spec.directional, + "cleared": len(cleared), + "cleared_ratio": ratio(len(cleared), len(truth)), + "cleared_matches_truth": cleared == truth, + "absent_misjudged": len(misjudged), + "virtual_time_s": round(summary["virtual_time_s"], 3), + "accounted_virtual_time_s": ( + round(summary["accounted_virtual_time_s"], 3) + if summary.get("accounted_virtual_time_s") is not None else None), + "measures": summary["measures"], + "clears": summary["clears"], + "clear_success": summary["clear_success"], + "total_requests": summary["total_requests"], + "move_distance_m": round(summary["move_distance_m"], 2), + "fallback_clear_attempts": summary.get("fallback_clear_attempts", 0), + "coverage_points": summary.get("coverage_points", 0), + "stop_reason": summary["stop_reason"], + "exit_reason": summary["exit_reason"], + "anomaly_count": len(summary["anomalies"]), + "virtual_recompute_mismatches": len(report["mismatches"]), + "compute_wall_s": round(compute_wall_s, 3), + "valid": valid, + } + + +# 第三/四问统一汇报列（顺序即 Markdown 列序） +EPISODE_COLUMNS = ( + "cleared_ratio", "cleared_matches_truth", "absent_misjudged", + "virtual_time_s", "measures", "total_requests", "move_distance_m", + "fallback_clear_attempts", "compute_wall_s", "valid", +) + + +def aggregate_episodes(rows: list[dict], labels: list[str], + base_label: str | None = None) -> dict: + """逐方法汇总 + 相对基线的配对变化（按 scene_id 对齐）。""" + summary: dict[str, dict] = {} + for label in labels: + part = [row for row in rows if row["variant"] == label] + if not part: + continue + summary[label] = { + "episodes": len(part), + "valid_episodes": sum(1 for row in part if row["valid"]), + "cleared_ratio_mean": mean(row["cleared_ratio"] for row in part), + "cleared_matches_truth": sum(1 for row in part + if row["cleared_matches_truth"]), + "absent_misjudged_total": sum(row["absent_misjudged"] for row in part), + "virtual_time_mean_s": mean(row["virtual_time_s"] for row in part), + "virtual_time_median_s": median(row["virtual_time_s"] for row in part), + "virtual_time_max_s": round(max(row["virtual_time_s"] for row in part), 3), + "measures_mean": mean(row["measures"] for row in part), + "total_requests_mean": mean(row["total_requests"] for row in part), + "move_distance_mean_m": mean(row["move_distance_m"] for row in part), + "fallback_clear_attempts_mean": mean( + row["fallback_clear_attempts"] for row in part), + "compute_wall_mean_s": mean(row["compute_wall_s"] for row in part), + } + paired: dict[str, dict] = {} + if base_label and len(labels) > 1: + base_rows = {row["scene_id"]: row for row in rows + if row["variant"] == base_label} + for label in labels: + if label == base_label: + continue + deltas, faster, valid_pairs = [], 0, 0 + for row in rows: + if row["variant"] != label or row["scene_id"] not in base_rows: + continue + base_row = base_rows[row["scene_id"]] + reference = base_row["virtual_time_s"] + deltas.append(relative_change(row["virtual_time_s"], reference)) + if not (row["valid"] and base_row["valid"]): + continue + valid_pairs += 1 + if row["virtual_time_s"] < reference: + faster += 1 + paired[f"{label}_vs_{base_label}"] = { + "mean_relative_change": mean(d for d in deltas if d is not None), + "median_relative_change": median(d for d in deltas if d is not None), + "faster_scenes": faster, + "compared": len(deltas), + "both_valid_scenes": valid_pairs, + } + return {"variants": summary, "paired": paired} + + +def episodes_markdown(title: str, rows: list[dict], labels: list[str], + base_label: str | None = None) -> str: + """逐场景明细 + 汇总表。""" + headers = ["scene", "sources", "variant", "cleared", "T(s)", "检测", + "请求", "位移(m)", "后备清除", "墙钟(s)", "有效"] + body = [] + for row in sorted(rows, key=lambda r: (r["scene_id"], labels.index(r["variant"]))): + body.append([ + row["scene_id"], row["sources"], row["variant"], + f"{row['cleared']}/{row['sources']}", + _num(row["virtual_time_s"], 1), row["measures"], + row["total_requests"], _num(row["move_distance_m"], 1), + row["fallback_clear_attempts"], _num(row["compute_wall_s"], 2), + _num(row["valid"]), + ]) + text = [f"# {title}", "", "## 逐场景明细", "", + markdown_table(headers, body), "", "## 逐方法汇总", ""] + agg = aggregate_episodes(rows, labels, base_label) + agg_headers = ["方法", "有效局", "全清率", "全清对数", "缺席误判", + "T 均值(s)", "T 中位(s)", "T 最大(s)", "检测均值", + "请求均值", "位移均值(m)", "后备清除均值", "墙钟均值(s)"] + agg_rows = [] + for label in labels: + s = agg["variants"].get(label) + if not s: + continue + agg_rows.append([ + label, f"{s['valid_episodes']}/{s['episodes']}", + _num(s["cleared_ratio_mean"]), s["cleared_matches_truth"], + s["absent_misjudged_total"], _num(s["virtual_time_mean_s"], 1), + _num(s["virtual_time_median_s"], 1), _num(s["virtual_time_max_s"], 1), + _num(s["measures_mean"], 1), _num(s["total_requests_mean"], 1), + _num(s["move_distance_mean_m"], 1), + _num(s["fallback_clear_attempts_mean"], 2), + _num(s["compute_wall_mean_s"], 2), + ]) + text.append(markdown_table(agg_headers, agg_rows)) + if agg["paired"]: + text += ["", "## 相对基线的配对变化（虚拟时间）", ""] + pair_rows = [[name, f"{v['mean_relative_change']*100:+.1f}%", + f"{v['median_relative_change']*100:+.1f}%", + f"{v['faster_scenes']}/{v['compared']}", + v["both_valid_scenes"]] + for name, v in agg["paired"].items()] + text.append(markdown_table( + ["配对", "均值变化", "中位变化", "更快场景", "双方均有效"], pair_rows)) + invalid = [name for name, value in agg["paired"].items() + if value["both_valid_scenes"] < value["compared"]] + if invalid: + text += ["", + "> 注：" + "、".join(invalid) + + " 存在未通过有效性判定的配对；其虚拟时间仅作参考，" + "基线未完成全清任务时不构成「更快」证据" + "（以「双方均有效」列为准）。"] + return "\n".join(text) + "\n" + + +def json_safe(payload): + """把 numpy 标量等转成 json 可写类型（防御式，非必需）。""" + return json.loads(json.dumps(payload, ensure_ascii=False, default=float)) + + +# ---------------------------------------------------------------- 闭环批量执行 +def execute_variants(scenes, variants, config: ProblemConfig) -> list[dict]: + """对每个场景跑遍所有变体（串行；对比规模小，进程池收益有限且便于复现）。""" + rows = [] + for scene in scenes: + for label, loop_cls in variants: + row = run_loop_episode(loop_cls, scene, config) + row["variant"] = label + rows.append(row) + return rows + + +def closed_loop_payload(question: int, suite_name: str, scenes, variants, + rows: list[dict], labels: list[str], + base_label: str, config: ProblemConfig) -> dict: + return { + "question": question, + "suite": suite_name, + "scenes": [scene.as_dict() for scene in scenes], + "variants": [{"label": label, "class": loop_cls.__name__} + for label, loop_cls in variants], + "config": { + "persistent_search": config.search.persistent_search, + "bearing_rounding_margin_deg": config.search.bearing_rounding_margin_deg, + "q4_coverage_plan": config.search.q4_coverage_plan, + }, + "rows": rows, + "aggregate": aggregate_episodes(rows, labels, base_label), + } diff --git a/project/q1/__init__.py b/project/q1/__init__.py new file mode 100644 index 0000000..5faef30 --- /dev/null +++ b/project/q1/__init__.py @@ -0,0 +1,13 @@ +"""问题一：交会定位多边形直径与直径圆覆盖。 + +- ``optimal.py`` ：生产实现 ``mcm26b.geometry.localization.solve``（半平面交 + + 顶点对精确直径 + Welzl 最小包围圆 + 覆盖反例见证）； +- ``baseline.py`` ：基线实现（网格采样 + 轴对齐包围盒代理直径/覆盖）； +- ``reference.py``：独立精确参考解（大框半平面裁剪 + 暴力直径/最小包围圆）； +- ``cases.py`` ：固定示例（``examples/q1``）与随机算例生成； +- ``compare.py`` ：同案配对对比并落盘。 +""" + +from . import baseline, cases, optimal, reference + +__all__ = ["optimal", "baseline", "reference", "cases"] diff --git a/project/q1/baseline.py b/project/q1/baseline.py new file mode 100644 index 0000000..d66cfa9 --- /dev/null +++ b/project/q1/baseline.py @@ -0,0 +1,98 @@ +"""问题一基线实现：网格采样 + 轴对齐包围盒（bbox）代理。 + +这是"先上手"的朴素做法，常见于直接对可行点打网格再读包围盒： + +1. 在固定大框上按步长采样，保留满足全部角域约束的点； +2. 直径用包围盒对角线代理 —— 只要区域是斜的/细长的就会系统性高估； +3. 覆盖判断用"包围盒中心 + 代理直径"的圆 —— 因为包围盒自身对其中心对称， + 该判据几乎恒为"能覆盖"，从而丢掉问题一真正要考的反例。 + +本实现刻意保留这些结构性缺陷，作为``optimal.py``的对照；它不读取最优实现的 +任何中间量，两条代码路径完全独立。 +""" + +from __future__ import annotations + +import math +from time import perf_counter + +import numpy as np + +from mcm26b.geometry.localization import Measurement, halfplanes + +from project.common import Method + +METHOD = Method( + key="baseline", + name="网格采样 + bbox 对角线代理", + kind="baseline", + note="轴对齐包围盒近似直径与覆盖，O(盒面积/步长²)，与参考解同分辨率", +) + +BOX_M = 2600.0 +STEP_M = 5.0 + + +def solve_case(case: dict) -> dict: + start = perf_counter() + measurements = [Measurement(row["x"], row["y"], row["bearing_deg"], + row.get("half_angle_deg", 1.0)) + for row in case["measurements"]] + planes = [plane for m in measurements for plane in halfplanes(m)] + + xs = np.arange(-BOX_M, BOX_M + STEP_M, STEP_M) + grid_x, grid_y = np.meshgrid(xs, xs) # 行=y，列=x + mask = np.ones(grid_x.shape, dtype=bool) + for a, b, c in planes: + mask &= (a * grid_x + b * grid_y <= c) + + result = _evaluate(mask, xs) + result["method"] = METHOD.key + result["runtime_ms"] = round((perf_counter() - start) * 1000.0, 4) + result["algorithm"] = METHOD.name + return result + + +def _evaluate(mask: np.ndarray, axis: np.ndarray) -> dict: + if not mask.any(): + return _empty("empty") + # 可行点触到采样框边界 => 区域至少延伸到框外，判无界 + if (mask[0, :].any() or mask[-1, :].any() + or mask[:, 0].any() or mask[:, -1].any()): + return _empty("unbounded") + + rows, cols = np.nonzero(mask) + x_min, x_max = axis[cols].min(), axis[cols].max() + y_min, y_max = axis[rows].min(), axis[rows].max() + width, height = x_max - x_min, y_max - y_min + diameter = math.hypot(width, height) # 包围盒对角线代理 + center = ((x_min + x_max) / 2.0, (y_min + y_max) / 2.0) + px = axis[cols] + py = axis[rows] + max_distance = float(np.max(np.hypot(px - center[0], py - center[1]))) + return { + "status": "polygon" if mask.sum() >= 2 else "point", + "diameter_m": diameter, + "diameter_infinite": False, + "covers": bool(max_distance <= diameter / 2.0 + 1e-9), + "mec_radius_m": None, + "max_excess_m": round(max_distance - diameter / 2.0, 6), + "outside_vertex_count": None, + "vertex_count": int(mask.sum()), + "bbox_width_m": round(width, 3), + "bbox_height_m": round(height, 3), + "runtime_ms": None, + } + + +def _empty(status: str) -> dict: + return { + "status": status, + "diameter_m": None, + "diameter_infinite": status == "unbounded", + "covers": None, + "mec_radius_m": None, + "max_excess_m": None, + "outside_vertex_count": None, + "vertex_count": 0, + } diff --git a/project/q1/cases.py b/project/q1/cases.py new file mode 100644 index 0000000..3f2dc9d --- /dev/null +++ b/project/q1/cases.py @@ -0,0 +1,67 @@ +"""问题一算例：官方示例目录 ``examples/q1`` + 随机交会算例。""" + +from __future__ import annotations + +import json +import math +import random + +from project.common import ROOT + +EXAMPLE_DIR = ROOT / "examples" / "q1" +EXAMPLE_IDS = ("normal", "triangle", "poor", "segment", "empty") + + +def load_examples() -> list[dict]: + """读取固定算例；缺文件时跳过，保证离线可跑。""" + cases = [] + for key in EXAMPLE_IDS: + path = EXAMPLE_DIR / f"{key}.json" + if not path.exists(): + continue + raw = json.loads(path.read_text(encoding="utf-8-sig")) + cases.append({ + "id": raw.get("id", key), + "name": raw.get("name", key), + "source": "examples/q1", + "measurements": [ + {"x": float(row["x"]), "y": float(row["y"]), + "bearing_deg": float(row["bearing_deg"]), + "half_angle_deg": float(row.get("half_angle_deg", 1.0))} + for row in raw["measurements"] + ], + }) + return cases + + +def random_case(seed: int) -> dict: + """随机三点/四点交会：目标在 Ω 内，测站分布在不同象限。 + + 仅生成"区域有界且非退化"的良态算例，避免参考网格因细长区域失效； + 生成后由 ``compare`` 再用最优实现复核状态。 + """ + rng = random.Random(seed) + target = (rng.uniform(-900, 900), rng.uniform(-900, 900)) + count = rng.choice((3, 3, 4, 5)) + stations = [] + base_angle = rng.uniform(0, 360) + for index in range(count): + angle = base_angle + 360 * index / count + rng.uniform(-25, 25) + radius = rng.uniform(500, 1100) + stations.append((target[0] + radius * math.cos(math.radians(angle)), + target[1] + radius * math.sin(math.radians(angle)))) + measurements = [] + for (sx, sy) in stations: + true_bearing = math.degrees(math.atan2(target[1] - sy, target[0] - sx)) % 360.0 + # 观测误差固定在同一地点、落在 ±1° 内；读数保留两位小数 + error = rng.uniform(-0.9, 0.9) + measurements.append({"x": round(sx, 2), "y": round(sy, 2), + "bearing_deg": round((true_bearing + error) % 360.0, 2), + "half_angle_deg": 1.0}) + return {"id": f"rand-{seed}", "name": "随机交会", "source": "synthetic", + "target": [round(target[0], 2), round(target[1], 2)], + "measurements": measurements} + + +def random_cases(count: int, base_seed: int = 7000) -> list[dict]: + return [random_case(base_seed + index) for index in range(count)] diff --git a/project/q1/compare.py b/project/q1/compare.py new file mode 100644 index 0000000..fd94fba --- /dev/null +++ b/project/q1/compare.py @@ -0,0 +1,150 @@ +"""问题一同案配对对比：最优 vs 基线 vs 独立参考解。""" + +from __future__ import annotations + +from project.common import (Method, RESULTS_DIR, markdown_table, mean, + ratio, write_json, write_text) +from project.q1 import baseline, cases, optimal, reference + +METHODS: tuple[Method, ...] = (optimal.METHOD, baseline.METHOD, reference.METHOD) +FINITE = ("point", "segment", "polygon") + + +def _run(case: dict) -> dict: + opt = optimal.solve_case(case) + base = baseline.solve_case(case) + ref = reference.solve_case(case) + finite = ref["status"] in FINITE and ref["diameter_m"] is not None + return { + "id": case["id"], + "name": case.get("name", case["id"]), + "source": case.get("source", "synthetic"), + "measurements": len(case["measurements"]), + "status_ref": ref["status"], + "status_opt": opt["status"], + "status_base": base["status"], + "status_opt_ok": opt["status"] == ref["status"], + "status_base_ok": base["status"] == ref["status"], + "diameter_ref_m": ref["diameter_m"], + "diameter_opt_m": opt["diameter_m"], + "diameter_base_m": base["diameter_m"], + "abs_err_opt_m": (round(abs(opt["diameter_m"] - ref["diameter_m"]), 4) + if finite and opt["diameter_m"] is not None else None), + "abs_err_base_m": (round(abs(base["diameter_m"] - ref["diameter_m"]), 4) + if finite and base["diameter_m"] is not None else None), + "covers_ref": ref["covers"], + "covers_opt": opt["covers"], + "covers_base": base["covers"], + "covers_opt_ok": (opt["covers"] == ref["covers"] + if ref["covers"] is not None and opt["covers"] is not None + else None), + "covers_base_ok": (base["covers"] == ref["covers"] + if ref["covers"] is not None and base["covers"] is not None + else None), + "mec_radius_opt_m": opt["mec_radius_m"], + "mec_radius_ref_m": ref["mec_radius_m"], + "outside_vertices_opt": opt["outside_vertex_count"], + "runtime_opt_ms": opt["runtime_ms"], + "runtime_base_ms": base["runtime_ms"], + "runtime_ref_ms": ref["runtime_ms"], + "reference_resolution_m": ref["resolution_m"], + } + + +def _aggregate(rows: list[dict]) -> dict: + polygon_rows = [r for r in rows if r["status_ref"] == "polygon"] + opt_errs = [r["abs_err_opt_m"] for r in polygon_rows + if r["abs_err_opt_m"] is not None] + base_errs = [r["abs_err_base_m"] for r in polygon_rows + if r["abs_err_base_m"] is not None] + cov_opt = [r["covers_opt_ok"] for r in rows if r["covers_opt_ok"] is not None] + cov_base = [r["covers_base_ok"] for r in rows if r["covers_base_ok"] is not None] + return { + "cases": len(rows), + "diameter_compared": len(opt_errs), + "status_accuracy_optimal": ratio(sum(r["status_opt_ok"] for r in rows), len(rows)), + "status_accuracy_baseline": ratio(sum(r["status_base_ok"] for r in rows), len(rows)), + "diameter_mae_optimal_m": mean(opt_errs), + "diameter_mae_baseline_m": mean(base_errs), + "diameter_max_err_optimal_m": round(max(opt_errs), 4) if opt_errs else 0.0, + "diameter_max_err_baseline_m": round(max(base_errs), 4) if base_errs else 0.0, + "coverage_compared": len(cov_opt), + "coverage_accuracy_optimal": ratio(sum(cov_opt), len(cov_opt)), + "coverage_accuracy_baseline": ratio(sum(cov_base), len(cov_base)), + "runtime_optimal_mean_ms": mean(r["runtime_opt_ms"] for r in rows), + "runtime_baseline_mean_ms": mean(r["runtime_base_ms"] for r in rows), + "runtime_reference_mean_ms": mean(r["runtime_ref_ms"] for r in rows), + } + + +def _render(rows: list[dict], aggregate: dict, title: str) -> str: + headers = ["算例", "来源", "参考状态", "最优状态", "基线状态", + "D参考(m)", "D最优(m)", "D基线(m)", "|ΔD|最优", "|ΔD|基线", + "覆盖参考", "覆盖最优", "覆盖基线"] + body = [] + for r in rows: + body.append([ + r["name"], r["source"], r["status_ref"], r["status_opt"], r["status_base"], + _fmt(r["diameter_ref_m"]), _fmt(r["diameter_opt_m"]), + _fmt(r["diameter_base_m"]), + _fmt(r["abs_err_opt_m"]), _fmt(r["abs_err_base_m"]), + _bool(r["covers_ref"]), _bool(r["covers_opt"]), _bool(r["covers_base"]), + ]) + text = [f"# {title}", "", + "参考解为独立的大框半平面裁剪 + 精确直径/MEC；", + "固定示例见 `examples/q1`，解析期望由 `tests/test_geometry*.py` 固化。", + "", markdown_table(headers, body), "", + "## 汇总", ""] + summary_rows = [ + ["状态判定准确率", _pct(aggregate["status_accuracy_optimal"]), + _pct(aggregate["status_accuracy_baseline"])], + ["直径平均绝对误差 (m)", _fmt(aggregate["diameter_mae_optimal_m"], 3), + _fmt(aggregate["diameter_mae_baseline_m"], 3)], + ["直径最大误差 (m)", _fmt(aggregate["diameter_max_err_optimal_m"], 3), + _fmt(aggregate["diameter_max_err_baseline_m"], 3)], + ["覆盖判定准确率", _pct(aggregate["coverage_accuracy_optimal"]), + _pct(aggregate["coverage_accuracy_baseline"])], + ["平均耗时 (ms)", _fmt(aggregate["runtime_optimal_mean_ms"], 3), + _fmt(aggregate["runtime_baseline_mean_ms"], 3)], + ] + text.append(markdown_table(["指标", "最优", "基线"], summary_rows)) + return "\n".join(text) + "\n" + + +def _fmt(value, digits: int = 2) -> str: + if value is None: + return "—" + if isinstance(value, bool): + return "是" if value else "否" + if isinstance(value, float): + return f"{value:.{digits}f}" + return str(value) + + +def _bool(value) -> str: + return "—" if value is None else ("是" if value else "否") + + +def _pct(value: float) -> str: + return f"{value*100:.1f}%" + + +def run(quick: bool = False) -> dict: + example_rows = [_run(case) for case in cases.load_examples()] + random_rows = [_run(case) for case in + cases.random_cases(12 if quick else 40)] + payload = { + "question": 1, + "methods": [m.__dict__ for m in METHODS], + "examples": example_rows, + "random": random_rows, + "aggregate_examples": _aggregate(example_rows), + "aggregate_random": _aggregate(random_rows), + } + write_json(RESULTS_DIR / "q1.json", payload) + text = _render(example_rows, payload["aggregate_examples"], + "问题一：固定示例对比") + text += "\n" + _render(random_rows, payload["aggregate_random"], + "问题一：随机交会算例对比") + write_text(RESULTS_DIR / "q1.md", text) + return payload diff --git a/project/q1/optimal.py b/project/q1/optimal.py new file mode 100644 index 0000000..02a9754 --- /dev/null +++ b/project/q1/optimal.py @@ -0,0 +1,59 @@ +"""问题一最优实现：复用生产几何内核 ``mcm26b.geometry.localization.solve``。 + +算法（已由 ``tests/test_geometry.py`` / ``tests/test_geometry_certificates.py`` +固化，本模块只做输入输出适配，不重写）： + +1. 每条带 ±δ 误差的示向度写成前向角域的三条半平面约束（含 0°/360° 跨界）； +2. 枚举全部边界直线交点，保留满足全部约束者，单调链求凸包； +3. 检查是否存在非零衰退方向判定无界；否则枚举凸包顶点对取精确直径； +4. 用直径两端点中点圆检验覆盖，并给出圆外顶点、最大超出距离等反例见证； +5. Welzl 增量法求最小包围圆，给出 20 m 清除余量证书。 +""" + +from __future__ import annotations + +from time import perf_counter + +from mcm26b.geometry.localization import Measurement, solve + +from project.common import Method + +METHOD = Method( + key="optimal", + name="精确半平面交 + 顶点对直径 + MEC", + kind="optimal", + note="生产内核 mcm26b.geometry.localization.solve", +) + + +def solve_case(case: dict) -> dict: + """输入 case["measurements"]，输出归一化结果。""" + measurements = [Measurement(row["x"], row["y"], row["bearing_deg"], + row.get("half_angle_deg", 1.0)) + for row in case["measurements"]] + start = perf_counter() + result = solve(measurements) + elapsed_ms = (perf_counter() - start) * 1000.0 + return normalize(result, elapsed_ms) + + +def normalize(result: dict, elapsed_ms: float) -> dict: + status = result["status"] + diameter = result.get("diameter_m") + circle = result.get("diameter_circle") or {} + mec = result.get("minimum_enclosing_circle") or {} + covers = circle.get("covers") if status in ("point", "segment", "polygon") else None + return { + "method": METHOD.key, + "status": status, + "diameter_m": diameter, + "diameter_infinite": result.get("diameter_infinite"), + "covers": covers, + "mec_radius_m": mec.get("radius_m"), + "max_excess_m": circle.get("max_excess_m"), + "outside_vertex_count": len(circle.get("outside_vertex_indices", [])) + if circle else None, + "vertex_count": len(result.get("vertices", [])), + "runtime_ms": round(elapsed_ms, 4), + "algorithm": METHOD.name, + } diff --git a/project/q1/reference.py b/project/q1/reference.py new file mode 100644 index 0000000..af3f52d --- /dev/null +++ b/project/q1/reference.py @@ -0,0 +1,178 @@ +"""问题一独立参考解：大框 Sutherland–Hodgman 半平面裁剪 + 精确直径/MEC。 + +与生产实现 ``mcm26b.geometry.localization.solve`` 的独立性： + +- 生产实现枚举"半平面边界直线两两交点"再筛可行点； +- 本参考解从一个大方框出发，逐条半平面做 Sutherland–Hodgman 裁剪， + 是另一条构造路径，且这里的半平面系数、直径、最小包围圆都在本文件内 + 独立编码（不复用生产实现的 ``halfplanes`` / ``diameter`` / ``mec``）。 + +只要区域有界，大框（±1e7 m）裁剪得到的顶点即精确多边形；顶点触到大框 +边界则判无界。最小包围圆用"枚举所有 1/2/3 点支撑圆"的暴力算法，直径用 +顶点对暴力枚举，二者都是 O(m²)/O(m³) 的朴素精确算法，m 为多边形顶点数。 +""" + +from __future__ import annotations + +import math +from time import perf_counter + +from project.common import Method + +METHOD = Method( + key="reference", + name="大框半平面裁剪 + 精确直径/MEC", + kind="reference", + note="独立于生产顶点枚举的精确参考解", +) + +BOX_M = 1.0e7 +_PARALLEL_EPS = 1e-12 + + +def _planes(case: dict) -> list[tuple[float, float, float]]: + """独立重写 a*x+b*y<=c 的半平面构造（与题面角域定义一致）。""" + planes = [] + for row in case["measurements"]: + half = math.radians(row.get("half_angle_deg", 1.0)) + theta = math.radians(row["bearing_deg"] % 360.0) + sx, sy = row["x"], row["y"] + for angle, sign in ((theta - half, 1.0), (theta + half, -1.0)): + a = sign * math.sin(angle) + b = -sign * math.cos(angle) + planes.append((a, b, a * sx + b * sy)) + # 前向约束：不允许把角域取成反向无限双楔 + a, b = -math.cos(theta), -math.sin(theta) + planes.append((a, b, a * sx + b * sy)) + return planes + + +def _clip(polygon, a, b, c, tol=1e-7): + """Sutherland–Hodgman：保留 a*x+b*y<=c 的一侧。""" + if not polygon: + return [] + output = [] + count = len(polygon) + for index in range(count): + p, q = polygon[index], polygon[(index + 1) % count] + fp = a * p[0] + b * p[1] - c + fq = a * q[0] + b * q[1] - c + p_in, q_in = fp <= tol, fq <= tol + if p_in: + output.append(p) + if p_in != q_in: + ratio = fp / (fp - fq) + output.append((p[0] + ratio * (q[0] - p[0]), + p[1] + ratio * (q[1] - p[1]))) + deduped = [] + for point in output: + if not deduped or math.dist(point, deduped[-1]) > 1e-9: + deduped.append(point) + if len(deduped) > 1 and math.dist(deduped[0], deduped[-1]) <= 1e-9: + deduped.pop() + return deduped + + +def _brute_force_diameter(points): + best = 0.0 + pair = (points[0], points[0]) + for i, pi in enumerate(points): + for pj in points[i + 1:]: + value = math.dist(pi, pj) + if value > best: + best, pair = value, (pi, pj) + return best, pair + + +def _circumcircle(a, b, c): + ux, uy = b[0] - a[0], b[1] - a[1] + vx, vy = c[0] - a[0], c[1] - a[1] + det = 2.0 * (ux * vy - uy * vx) + if abs(det) <= _PARALLEL_EPS * max( + math.hypot(ux, uy) * math.hypot(vx, vy), 1e-300): + return None + uu, vv = ux * ux + uy * uy, vx * vx + vy * vy + center = (a[0] + (uu * vy - vv * uy) / det, + a[1] + (ux * vv - vx * uu) / det) + return center, math.dist(center, a) + + +def _brute_force_mec(points): + """枚举 1/2/3 点支撑圆的精确最小包围圆（朴素但无迭代）。""" + xs = [p[0] for p in points] + ys = [p[1] for p in points] + best_c = ((min(xs) + max(xs)) / 2.0, (min(ys) + max(ys)) / 2.0) + best_r = max(math.dist(best_c, p) for p in points) + candidates: list[tuple[tuple[float, float], float]] = [] + for i, p in enumerate(points): + for q in points[i + 1:]: + candidates.append((((p[0] + q[0]) / 2.0, (p[1] + q[1]) / 2.0), + math.dist(p, q) / 2.0)) + for i, p in enumerate(points): + for j in range(i + 1, len(points)): + for k in range(j + 1, len(points)): + circle = _circumcircle(p, points[j], points[k]) + if circle is not None: + candidates.append(circle) + for center, radius in candidates: + if radius >= best_r: + continue + if all(math.dist(center, p) <= radius + 1e-7 for p in points): + best_c, best_r = center, radius + return best_c, best_r + + +def solve_case(case: dict) -> dict: + start = perf_counter() + planes = _planes(case) + polygon = [(-BOX_M, -BOX_M), (BOX_M, -BOX_M), (BOX_M, BOX_M), (-BOX_M, BOX_M)] + for a, b, c in planes: + polygon = _clip(polygon, a, b, c) + if not polygon: + return _finish(_degenerate("empty"), start) + boundary_tol = 1e-6 * BOX_M + if any(abs(point[0]) >= BOX_M - boundary_tol + or abs(point[1]) >= BOX_M - boundary_tol for point in polygon): + return _finish(_degenerate("unbounded"), start) + + if len(polygon) == 1: + summary = {"status": "point", "diameter_m": 0.0, "covers": True, + "mec_radius_m": 0.0, "max_excess_m": 0.0, + "vertex_count": 1} + else: + value, (a, b) = _brute_force_diameter(polygon) + if len(polygon) == 2: + summary = {"status": "segment", "diameter_m": value, "covers": True, + "mec_radius_m": value / 2.0, "max_excess_m": 0.0, + "vertex_count": 2} + else: + _mec_center, radius = _brute_force_mec(polygon) + diameter_center = ((a[0] + b[0]) / 2.0, (a[1] + b[1]) / 2.0) + max_distance = max(math.dist(diameter_center, p) for p in polygon) + summary = { + "status": "polygon", + "diameter_m": value, + "covers": bool(radius <= value / 2.0 + 1e-7), + "mec_radius_m": radius, + "max_excess_m": round(max_distance - value / 2.0, 9), + "vertex_count": len(polygon), + } + return _finish(summary, start) + + +def _degenerate(status: str) -> dict: + return {"status": status, "diameter_m": None, "covers": None, + "mec_radius_m": None, "max_excess_m": None, "vertex_count": 0} + + +def _finish(summary: dict, start: float) -> dict: + result = { + "method": METHOD.key, + "algorithm": METHOD.name, + "resolution_m": 0.0, + "diameter_infinite": summary["status"] == "unbounded", + "outside_vertex_count": None, + "runtime_ms": round((perf_counter() - start) * 1000.0, 4), + } + result.update(summary) + return result diff --git a/project/q2/__init__.py b/project/q2/__init__.py new file mode 100644 index 0000000..356c48a --- /dev/null +++ b/project/q2/__init__.py @@ -0,0 +1,14 @@ +"""问题二：第二检测点选择策略。 + +- ``optimal.py`` ：生产选点器 ``mcm26b.planner.select_measurement_point`` + （保证接收盘内最坏后验半径最小化，采样启发式）； +- ``baseline.py`` ："垂直 1000 m 最大交会角"朴素启发式（忽略接收保证）， + 以及"退到候选集 MEC 圆心"的保守基线； +- ``reference.py``：在保证接收盘内稠密网格枚举的近似最优参考； +- ``cases.py`` ：随机首次示向度算例； +- ``compare.py`` ：同案配对对比并落盘。 +""" + +from . import baseline, cases, optimal, reference + +__all__ = ["optimal", "baseline", "reference", "cases"] diff --git a/project/q2/baseline.py b/project/q2/baseline.py new file mode 100644 index 0000000..b094086 --- /dev/null +++ b/project/q2/baseline.py @@ -0,0 +1,71 @@ +"""问题二基线实现：两个朴素但常见的对照。 + +- ``candidate_perp``：沿首次示向度垂直方向、距检测点约 1000 m 取点。 + 这是"尽量把交会角做成 90°"的教科书启发式，**但它忽略接收距离保证**： + 真源可能落在首次角域的远端（≤1500 m），此时第二点距离可超过 1000 m， + 第二次测量直接 ``no_signal``，几何收益落空。 +- ``candidate_mec``：退到候选集最小包围圆圆心。它确实落在保证接收盘内 + （ρ≤1000 时），但交会角可能接近 0°、后验几乎不收缩，代表"最保守"一端。 +""" + +from __future__ import annotations + +import math + +from mcm26b.config import ProblemConfig +from mcm26b.planner import safe_disk_radius + +from project.common import Method, problem_config +from project.q2.region import first_bearing_region + +PERP = Method( + key="baseline_perp", + name="垂直 1000 m 最大交会角", + kind="baseline", + note="忽略接收保证的几何启发式", +) +MEC = Method( + key="baseline_mec", + name="候选集 MEC 圆心", + kind="baseline", + note="保证接收但交会角最差的保守基线", +) +METHODS = (PERP, MEC) + + +def _region(case: dict, config: ProblemConfig): + return first_bearing_region(case, config) + + +def candidate_perp(case: dict, config: ProblemConfig | None = None) -> dict: + config = config or problem_config() + region = _region(case, config) + station = (case["station"][0], case["station"][1]) + theta = math.radians(case["bearing_deg"] + 90.0) + distance = config.field.r_eff_min_m + position = (station[0] + distance * math.cos(theta), + station[1] + distance * math.sin(theta)) + return { + "method": PERP.key, + "position": [round(position[0], 4), round(position[1], 4)], + "worst_posterior_radius_m": None, # 由 compare 统一评估 + "move_cost_s": None, + "safe_disk_radius_m": safe_disk_radius(region, config), + "initial_radius_m": region.mec()[1], + "reason": "沿首次示向度法向 1000 m 取 90° 交会点", + } + + +def candidate_mec(case: dict, config: ProblemConfig | None = None) -> dict: + config = config or problem_config() + region = _region(case, config) + center, radius = region.mec() + return { + "method": MEC.key, + "position": [round(center[0], 4), round(center[1], 4)], + "worst_posterior_radius_m": None, + "move_cost_s": None, + "safe_disk_radius_m": safe_disk_radius(region, config), + "initial_radius_m": radius, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差", + } diff --git a/project/q2/cases.py b/project/q2/cases.py new file mode 100644 index 0000000..9d3729c --- /dev/null +++ b/project/q2/cases.py @@ -0,0 +1,37 @@ +"""问题二算例：随机首次示向度（全向源）。""" + +from __future__ import annotations + +import math +import random + +from mcm26b.config import ProblemConfig + + +def random_case(seed: int, config: ProblemConfig | None = None) -> dict: + """随机检测点 s 与示向度 θ：默认让真源与读数一致（误差 ±1° 内）。""" + config = config or ProblemConfig() + rng = random.Random(seed) + radius = config.field.omega_radius_m + # 检测点可在目标域内或域外；这里取域内，符合题目常规场景 + angle_s = rng.uniform(0, 2 * math.pi) + distance_s = radius * math.sqrt(rng.random()) * 0.9 + station = (distance_s * math.cos(angle_s), distance_s * math.sin(angle_s)) + # 真源与检测点距离落在 [60, 1500) 且仍在 Ω 内 + while True: + bearing_true = rng.uniform(0, 2 * math.pi) + source_distance = rng.uniform(60, config.field.r_eff_max_m - 1) + target = (station[0] + source_distance * math.cos(bearing_true), + station[1] + source_distance * math.sin(bearing_true)) + if math.hypot(*target) <= radius: + break + error = math.radians(rng.uniform(-0.95, 0.95)) + bearing_deg = math.degrees(bearing_true + error) % 360.0 + return {"id": f"q2-{seed}", "station": [round(station[0], 2), round(station[1], 2)], + "bearing_deg": round(bearing_deg, 2), "half_angle_deg": 1.0, + "true_source": [round(target[0], 2), round(target[1], 2)]} + + +def random_cases(count: int, base_seed: int = 4200, + config: ProblemConfig | None = None) -> list[dict]: + return [random_case(base_seed + index, config) for index in range(count)] diff --git a/project/q2/compare.py b/project/q2/compare.py new file mode 100644 index 0000000..850b87b --- /dev/null +++ b/project/q2/compare.py @@ -0,0 +1,136 @@ +"""问题二同案配对对比：最优 / 两个基线 / 网格参考，用同一评估器打分。""" + +from __future__ import annotations + +import math + +from mcm26b.config import ProblemConfig +from mcm26b.planner import _worst_posterior_radius + +from project.common import (Method, RESULTS_DIR, markdown_table, mean, ratio, + write_json, write_text) +from project.q2 import baseline, cases, optimal, reference +from project.q2.region import first_bearing_region + +METHODS: tuple[Method, ...] = (optimal.METHOD, baseline.PERP, baseline.MEC, + reference.METHOD) +EVAL_WITNESS_SPACING_M = 60.0 + + +def _evaluate(case: dict, config: ProblemConfig) -> list[dict]: + region = first_bearing_region(case, config) + station = (case["station"][0], case["station"][1]) + initial_radius = region.mec()[1] + half_angle = (config.field.bearing_error_half_deg + + config.search.bearing_rounding_margin_deg) + witnesses = region.witnesses(EVAL_WITNESS_SPACING_M) + + plans = [optimal.candidate(case, config), + baseline.candidate_perp(case, config), + baseline.candidate_mec(case, config), + reference.candidate(case, config)] + rows = [] + for plan in plans: + q = (plan["position"][0], plan["position"][1]) + guarantee_distance = max(math.dist(q, vertex) for vertex in region.polygon) + worst = _worst_posterior_radius( + region, q, witnesses, half_angle, + config.field.near_radius_m, config.search.polygon_sides) + move_cost = math.dist(station, q) / config.cost.speed_mps + rows.append({ + "case_id": case["id"], + "method": plan["method"], + "initial_radius_m": round(initial_radius, 4), + "q": [round(q[0], 2), round(q[1], 2)], + "guaranteed_reception": bool(guarantee_distance + <= config.field.r_eff_min_m + 1e-6), + "guarantee_distance_m": round(guarantee_distance, 3), + "worst_posterior_radius_m": round(worst, 4), + "improvement_m": round(initial_radius - worst, 4), + "final_ratio": round(worst / initial_radius, 4) if initial_radius > 0 else None, + "move_cost_s": round(move_cost, 4), + "reason": plan["reason"], + }) + return rows + + +def _aggregate(rows: list[dict], labels: list[str]) -> dict: + summary: dict[str, dict] = {} + initial = mean(r["initial_radius_m"] for r in rows) if rows else 0.0 + for label in labels: + part = [r for r in rows if r["method"] == label] + if not part: + continue + summary[label] = { + "cases": len(part), + "guaranteed_rate": ratio(sum(r["guaranteed_reception"] for r in part), + len(part)), + "worst_posterior_mean_m": mean(r["worst_posterior_radius_m"] for r in part), + "worst_posterior_median_m": sorted( + r["worst_posterior_radius_m"] for r in part)[len(part) // 2], + "improvement_mean_m": mean(r["improvement_m"] for r in part), + "final_ratio_mean": mean(r["final_ratio"] for r in part + if r["final_ratio"] is not None), + "move_cost_mean_s": mean(r["move_cost_s"] for r in part), + } + summary["_initial_radius_mean_m"] = initial + return summary + + +def _render(rows: list[dict], aggregate: dict, labels: list[str]) -> str: + headers = ["算例", "方法", "初始 ρ(m)", "第二点 q", "保证接收", + "q 到 K₁ 最远(m)", "最坏后验 ρ'(m)", "收缩(m)", "移动(s)"] + body = [] + order = {label: index for index, label in enumerate(labels)} + for row in sorted(rows, key=lambda r: (r["case_id"], order.get(r["method"], 99))): + body.append([ + row["case_id"], row["method"], _f(row["initial_radius_m"]), + f"({row['q'][0]:.0f},{row['q'][1]:.0f})", + "是" if row["guaranteed_reception"] else "否", + _f(row["guarantee_distance_m"]), _f(row["worst_posterior_radius_m"]), + _f(row["improvement_m"]), _f(row["move_cost_s"]), + ]) + text = ["# 问题二：第二检测点选择对比", "", + "初始 ρ 为首次示向度候选集 K₁ 的最小包围半径；最坏后验按" + "目标边界采样 × 读数区间端点统一评估。", "", + markdown_table(headers, body), "", "## 逐方法汇总", ""] + agg_headers = ["方法", "保证接收率", "最坏后验均值(m)", "中位(m)", + "平均收缩(m)", "终值比 ρ'/ρ", "移动均值(s)"] + agg_rows = [] + for label in labels: + s = aggregate.get(label) + if not s: + continue + agg_rows.append([label, f"{s['guaranteed_rate']*100:.1f}%", + _f(s["worst_posterior_mean_m"]), + _f(s["worst_posterior_median_m"]), + _f(s["improvement_mean_m"]), + _f(s["final_ratio_mean"], 3), + _f(s["move_cost_mean_s"])]) + text.append(markdown_table(agg_headers, agg_rows)) + text.append("") + text.append(f"初始 ρ 均值：{aggregate['_initial_radius_mean_m']:.2f} m") + return "\n".join(text) + "\n" + + +def _f(value, digits: int = 2) -> str: + if value is None: + return "—" + if isinstance(value, bool): + return "是" if value else "否" + if isinstance(value, float): + return f"{value:.{digits}f}" + return str(value) + + +def run(quick: bool = False) -> dict: + config = ProblemConfig() + case_list = cases.random_cases(8 if quick else 30, config=config) + rows = [row for case in case_list for row in _evaluate(case, config)] + labels = [m.key for m in METHODS] + aggregate = _aggregate(rows, labels) + payload = {"question": 2, "methods": [m.__dict__ for m in METHODS], + "cases": case_list, "rows": rows, "aggregate": aggregate} + write_json(RESULTS_DIR / "q2.json", payload) + write_text(RESULTS_DIR / "q2.md", _render(rows, aggregate, labels)) + return payload diff --git a/project/q2/optimal.py b/project/q2/optimal.py new file mode 100644 index 0000000..7905145 --- /dev/null +++ b/project/q2/optimal.py @@ -0,0 +1,42 @@ +"""问题二最优实现：保证接收盘内的最坏后验半径最小化选点（生产实现）。 + +复用 ``mcm26b.planner.select_measurement_point``： + +1. 在"保证接收盘" B(mec_center, 1000-ρ) 内环形采样候选点； +2. 对每个候选，用"目标边界点 × 读数区间端点（+near 分支）"估计 + 最坏后验最小包围半径，并以移动时间同分决胜； +3. 选定后按 1/4 间距加密复核，返回位置、后验半径与理由。 + +采样是启发式（不是连续问题全局最优证明），但保证接收是严格的。 +""" + +from __future__ import annotations + +from mcm26b.config import ProblemConfig +from mcm26b.planner import safe_disk_radius, select_measurement_point + +from project.common import Method, problem_config +from project.q2.region import first_bearing_region + +METHOD = Method( + key="optimal", + name="保证接收盘内最小最坏后验半径", + kind="optimal", + note="生产实现 mcm26b.planner.select_measurement_point", +) + + +def candidate(case: dict, config: ProblemConfig | None = None) -> dict: + config = config or problem_config() + region = first_bearing_region(case, config) + station = (case["station"][0], case["station"][1]) + plan = select_measurement_point(region, station, config) + return { + "method": METHOD.key, + "position": [round(plan.position[0], 4), round(plan.position[1], 4)], + "worst_posterior_radius_m": plan.worst_posterior_radius_m, + "move_cost_s": plan.move_cost_s, + "safe_disk_radius_m": safe_disk_radius(region, config), + "initial_radius_m": region.mec()[1], + "reason": plan.reason, + } diff --git a/project/q2/reference.py b/project/q2/reference.py new file mode 100644 index 0000000..ba4a2a3 --- /dev/null +++ b/project/q2/reference.py @@ -0,0 +1,67 @@ +"""问题二近似最优参考：在保证接收盘内做稠密网格枚举。 + +目标函数与生产实现一致（最坏后验包围半径 + 移动时间同分决胜），但候选点 +取自**均匀网格**而非环形采样族，因此可用来检验生产采样是否接近该目标下的 +网格最优。注意这是"同一目标下的网格参考"，不是连续问题的严格全局最优。 +""" + +from __future__ import annotations + +import math + +from mcm26b.config import ProblemConfig +from mcm26b.planner import (_worst_posterior_radius, safe_disk_radius) + +from project.common import Method, problem_config +from project.q2.region import first_bearing_region + +METHOD = Method( + key="reference", + name="保证接收盘内网格枚举", + kind="reference", + note="同一目标下的稠密网格参考，非连续全局最优", +) +GRID_SIDES = 9 +WITNESS_SPACING_M = 150.0 + + +def candidate(case: dict, config: ProblemConfig | None = None) -> dict: + config = config or problem_config() + region = first_bearing_region(case, config) + station = (case["station"][0], case["station"][1]) + center = region.mec()[0] + safe = safe_disk_radius(region, config) + if safe < 0: + return _payload(center, region, config, station, "无保证接收盘：退回 MEC 圆心") + + field, search = config.field, config.search + half_angle = field.bearing_error_half_deg + search.bearing_rounding_margin_deg + witnesses = region.witnesses(WITNESS_SPACING_M) + step = 2.0 * safe / (GRID_SIDES - 1) + best_key, best_point, best_worst = None, center, None + for i in range(GRID_SIDES): + for j in range(GRID_SIDES): + point = (center[0] - safe + i * step, center[1] - safe + j * step) + if math.dist(point, center) > safe + 1e-9: + continue + worst = _worst_posterior_radius(region, point, witnesses, half_angle, + field.near_radius_m, search.polygon_sides) + move = math.dist(station, point) / config.cost.speed_mps + key = (round(worst, 6), round(move, 6)) + if best_key is None or key < best_key: + best_key, best_point, best_worst = key, point, worst + return _payload(best_point, region, config, station, + f"安全盘网格 {GRID_SIDES}×{GRID_SIDES} 取最坏后验最小", + worst_value=best_worst) + + +def _payload(point, region, config, station, reason, worst_value=None) -> dict: + return { + "method": METHOD.key, + "position": [round(point[0], 4), round(point[1], 4)], + "worst_posterior_radius_m": worst_value, + "move_cost_s": math.dist(station, point) / config.cost.speed_mps, + "safe_disk_radius_m": safe_disk_radius(region, config), + "initial_radius_m": region.mec()[1], + "reason": reason, + } diff --git a/project/q2/region.py b/project/q2/region.py new file mode 100644 index 0000000..53aca00 --- /dev/null +++ b/project/q2/region.py @@ -0,0 +1,24 @@ +"""问题二候选集 K1 的统一构造（三个方法共用同一输入，保证配对公平）。 + +K1 = Ω ∩ W(s, θ ± δ_eff) ∩ B(s, 1500)，δ_eff = 题设 1° + 示向度舍入裕量。 +生产实现用"圆盘外切多边形 ∩ 半平面"的保守外包（``CandidateRegion``）， +圆盘用外切多边形严格外包，保证真源不丢。 +""" + +from __future__ import annotations + +from mcm26b.belief import CandidateRegion +from mcm26b.config import ProblemConfig, Vec2 + +from project.common import problem_config + + +def first_bearing_region(case: dict, + config: ProblemConfig | None = None) -> CandidateRegion: + config = config or problem_config() + field, search = config.field, config.search + half_angle = field.bearing_error_half_deg + search.bearing_rounding_margin_deg + station: Vec2 = (case["station"][0], case["station"][1]) + region = CandidateRegion.initial(station, config) + region.clip_wedge(station, case["bearing_deg"], half_angle) + return region diff --git a/project/q3/__init__.py b/project/q3/__init__.py new file mode 100644 index 0000000..d987003 --- /dev/null +++ b/project/q3/__init__.py @@ -0,0 +1,11 @@ +"""问题三：全向源搜索—定位—清除闭环。 + +- ``optimal.py`` ：贝叶斯网格粒子滤波 + 信息增益选点 + 滚动 2-opt（``bayes``）； +- ``baseline.py``：49 点网格发现 + 就近服务（``grid``，历史基线）， + 以及七点解析覆盖批量扫频（``seven``，中间对照）； +- ``compare.py`` ：冻结基准集配对对比并落盘。 +""" + +from . import baseline, optimal + +__all__ = ["optimal", "baseline"] diff --git a/project/q3/baseline.py b/project/q3/baseline.py new file mode 100644 index 0000000..5ab12b7 --- /dev/null +++ b/project/q3/baseline.py @@ -0,0 +1,28 @@ +"""问题三基线实现：两条不共享贝叶斯决策的对照策略。 + +- ``OmnidirectionalLoop``（grid）：49 点（700 m 步长）网格保证发现， + 发现后就近进入定位子循环；策略简单、无信息增益选点、无任务排序优化。 +- ``SevenBatch``（seven）：七点解析覆盖 + 同站批量扫频 + 最近候选服务队列， + 是"覆盖证明 + 批量调度"的中间对照（官方演练 12/12 全清）。 +""" + +from __future__ import annotations + +from mcm26b.planner import OmnidirectionalLoop +from mcm26b.planner.seven import SevenBatch + +from project.common import Method + +GRID = Method(key="baseline", name="49 点网格 + 就近服务 (grid)", + kind="baseline", note="历史基线，无信息增益与滚动排序") +SEVEN = Method(key="seven", name="七点解析覆盖 + 批量扫频 (seven)", + kind="baseline", note="覆盖证明与批量调度的中间对照") + +def build_grid(client, config): + """工厂：49 点网格基线闭环。""" + return OmnidirectionalLoop(client, config) + + +def build_seven(client, config): + """工厂：七点批量扫频中间对照。""" + return SevenBatch(client, config) diff --git a/project/q3/compare.py b/project/q3/compare.py new file mode 100644 index 0000000..c2f227b --- /dev/null +++ b/project/q3/compare.py @@ -0,0 +1,32 @@ +"""问题三冻结基准集配对对比：bayes（最优） vs grid（基线） vs seven（中间）。""" + +from __future__ import annotations + +from project.common import (RESULTS_DIR, closed_loop_payload, episodes_markdown, + execute_variants, problem_config, write_json, + write_text) +from project.q3 import baseline, optimal + +VARIANTS = ( + ("optimal", optimal.build_loop), + ("seven", baseline.build_seven), + ("baseline", baseline.build_grid), +) +LABELS = [label for label, _ in VARIANTS] +BASE_LABEL = "baseline" + + +def run(quick: bool = False) -> dict: + from mcm26b.harness.suites import suite + scenes = suite("core", 3) + if quick: + scenes = scenes[:6] + config = problem_config() + rows = execute_variants(scenes, VARIANTS, config) + payload = closed_loop_payload(3, "core", scenes, VARIANTS, rows, + LABELS, BASE_LABEL, config) + write_json(RESULTS_DIR / "q3.json", payload) + write_text(RESULTS_DIR / "q3.md", + episodes_markdown("问题三：全向闭环配对对比（core 基准集）", + rows, LABELS, BASE_LABEL)) + return payload diff --git a/project/q3/optimal.py b/project/q3/optimal.py new file mode 100644 index 0000000..b2c421c --- /dev/null +++ b/project/q3/optimal.py @@ -0,0 +1,19 @@ +"""问题三最优实现：``mcm26b.planner.bayes_loop.BayesLoop``（bayes 策略）。 + +要点：逐频道网格粒子滤波维护幸存集；以期望信息增益选探点、 +滚动时域 2-opt 排序任务；证书（凸证书或 PF 幸存集 MEC）达到 20 m 即清除； +全频道"已清除或证明不存在"后立即 /exit（虚拟时间即成绩口径）。 +自建消融相对 SevenBatch 再降约 30%（docs/algo-3-bayes.md）。 +""" + +from __future__ import annotations + +from mcm26b.planner.bayes_loop import BayesLoop + +from project.common import Method + +METHOD = Method(key="optimal", name="贝叶斯粒子滤波闭环 (bayes)", + kind="optimal", note="生产默认策略，虚拟时间口径") +def build_loop(client, config): + """工厂：返回生产 bayes 闭环实例。""" + return BayesLoop(client, config) diff --git a/project/q4/__init__.py b/project/q4/__init__.py new file mode 100644 index 0000000..63afcd9 --- /dev/null +++ b/project/q4/__init__.py @@ -0,0 +1,12 @@ +"""问题四：含定向干扰源的检测与清除。 + +- ``optimal.py`` ：``DirectionalExtension``（保证覆盖 + 定向观测推理 + + (位置×朝向) 联合信念 + ≤20 m 有限圆盘后备清除）； +- ``baseline.py``：把问题三最优策略**直接搬用**的两条基线—— + ``bayes``（七站全向缺席证明）与 ``grid``（49 点全向覆盖，无后备清除）； +- ``compare.py`` ：core + boundary 基准集配对对比并落盘。 +""" + +from . import baseline, optimal + +__all__ = ["optimal", "baseline"] diff --git a/project/q4/baseline.py b/project/q4/baseline.py new file mode 100644 index 0000000..290e451 --- /dev/null +++ b/project/q4/baseline.py @@ -0,0 +1,29 @@ +"""问题四基线实现：把问题三策略原样搬用的两条对照。 + +- ``bayes``：问题三最优策略直接用于混合源。它用七站环的**全向**缺席证明， + 对"定向源朝外发射"场景会错误地把真源判为 ABSENT，属于"快而错"的典型； +- ``grid``：49 点全向网格（对定向源发现是完备的），但缺少定向观测推理与 + ≤20 m 后备清除，定位停滞时只能停在 DETECTED，属于"稳而不全"。 +两条基线都不共享最优实现的联合信念与后备清除逻辑。 +""" + +from __future__ import annotations + +from mcm26b.planner import OmnidirectionalLoop +from mcm26b.planner.bayes_loop import BayesLoop + +from project.common import Method + +BAYES = Method(key="baseline", name="问题三最优策略直接搬用 (bayes)", + kind="baseline", note="七站全向缺席证明在定向源上失效") +GRID = Method(key="baseline_grid", name="49 点网格全向策略 (grid)", + kind="baseline", note="覆盖完备但无定向推理与后备清除") + +def build_bayes(client, config): + """工厂：问题三 bayes 策略直接搬用。""" + return BayesLoop(client, config) + + +def build_grid(client, config): + """工厂：49 点网格全向策略直接搬用。""" + return OmnidirectionalLoop(client, config) diff --git a/project/q4/compare.py b/project/q4/compare.py new file mode 100644 index 0000000..b85a1aa --- /dev/null +++ b/project/q4/compare.py @@ -0,0 +1,32 @@ +"""问题四 core+boundary 基准集配对对比：directional（最优） vs 两条搬用基线。""" + +from __future__ import annotations + +from project.common import (RESULTS_DIR, closed_loop_payload, episodes_markdown, + execute_variants, problem_config, write_json, + write_text) +from project.q4 import baseline, optimal + +VARIANTS = ( + ("optimal", optimal.build_loop), + ("baseline_grid", baseline.build_grid), + ("baseline", baseline.build_bayes), +) +LABELS = [label for label, _ in VARIANTS] +BASE_LABEL = "baseline" + + +def run(quick: bool = False) -> dict: + from mcm26b.harness.suites import suite + scenes = suite("core", 4) + suite("boundary", 4) + if quick: + scenes = scenes[:4] + config = problem_config() + rows = execute_variants(scenes, VARIANTS, config) + payload = closed_loop_payload(4, "core+boundary", scenes, VARIANTS, rows, + LABELS, BASE_LABEL, config) + write_json(RESULTS_DIR / "q4.json", payload) + write_text(RESULTS_DIR / "q4.md", + episodes_markdown("问题四：混合源闭环配对对比（core+boundary 基准集）", + rows, LABELS, BASE_LABEL)) + return payload diff --git a/project/q4/optimal.py b/project/q4/optimal.py new file mode 100644 index 0000000..21df9cb --- /dev/null +++ b/project/q4/optimal.py @@ -0,0 +1,22 @@ +"""问题四最优实现：``mcm26b.planner.DirectionalExtension``（directional 策略）。 + +三点相对全向闭环的加装： +1. 发现覆盖改用经全向/定向双口径证伪的 31 点最小命中集 + （``q4_mincover_v2``，15 m/72 档验证零缺口）； +2. 保证接收盘内 ``no_signal`` 只可能由朝向遮挡解释：记为"观测到定向"， + 对 MEC 圆心取对跖点复核，并用 (位置×朝向) 联合可行集选可见性探点； +3. 定位停滞时对有界候选集构造 ≤20 m 网格圆盘覆盖，预算核对后逐格 /clear + （清除与朝向无关），是定向源不依赖可见性的完备后备。 +""" + +from __future__ import annotations + +from mcm26b.planner import DirectionalExtension + +from project.common import Method + +METHOD = Method(key="optimal", name="定向扩展闭环 (directional)", + kind="optimal", note="联合信念 + 后备清除 + 定向覆盖计划") +def build_loop(client, config): + """工厂：返回定向扩展闭环实例。""" + return DirectionalExtension(client, config) diff --git a/project/results/q1.json b/project/results/q1.json new file mode 100644 index 0000000..ce25107 --- /dev/null +++ b/project/results/q1.json @@ -0,0 +1,1319 @@ +{ + "question": 1, + "methods": [ + { + "key": "optimal", + "name": "精确半平面交 + 顶点对直径 + MEC", + "kind": "optimal", + "note": "生产内核 mcm26b.geometry.localization.solve" + }, + { + "key": "baseline", + "name": "网格采样 + bbox 对角线代理", + "kind": "baseline", + "note": "轴对齐包围盒近似直径与覆盖，O(盒面积/步长²)，与参考解同分辨率" + }, + { + "key": "reference", + "name": "大框半平面裁剪 + 精确直径/MEC", + "kind": "reference", + "note": "独立于生产顶点枚举的精确参考解" + } + ], + "examples": [ + { + "id": "normal", + "name": "三点交会", + "source": "examples/q1", + "measurements": 3, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 26.986082918271922, + "diameter_opt_m": 26.986082918182134, + "diameter_base_m": 21.213203435596427, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 5.7729, + "covers_ref": false, + "covers_opt": false, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": false, + "mec_radius_opt_m": 13.943107186092131, + "mec_radius_ref_m": 13.943107186131595, + "outside_vertices_opt": 2, + "runtime_opt_ms": 0.1252, + "runtime_base_ms": 22.0265, + "runtime_ref_ms": 0.0635, + "reference_resolution_m": 0.0 + }, + { + "id": "triangle", + "name": "直径圆反例", + "source": "examples/q1", + "measurements": 3, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 39.99999999999925, + "diameter_opt_m": 40.00000000000088, + "diameter_base_m": 50.0, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 10.0, + "covers_ref": false, + "covers_opt": false, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": false, + "mec_radius_opt_m": 23.09401076758553, + "mec_radius_ref_m": 23.09401076749959, + "outside_vertices_opt": 1, + "runtime_opt_ms": 0.083, + "runtime_base_ms": 15.1903, + "runtime_ref_ms": 0.0302, + "reference_resolution_m": 0.0 + }, + { + "id": "poor", + "name": "近共线检测点", + "source": "examples/q1", + "measurements": 3, + "status_ref": "unbounded", + "status_opt": "unbounded", + "status_base": "unbounded", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": null, + "diameter_opt_m": null, + "diameter_base_m": null, + "abs_err_opt_m": null, + "abs_err_base_m": null, + "covers_ref": null, + "covers_opt": null, + "covers_base": null, + "covers_opt_ok": null, + "covers_base_ok": null, + "mec_radius_opt_m": null, + "mec_radius_ref_m": null, + "outside_vertices_opt": null, + "runtime_opt_ms": 0.0365, + "runtime_base_ms": 13.2888, + "runtime_ref_ms": 0.0213, + "reference_resolution_m": 0.0 + }, + { + "id": "segment", + "name": "零误差退化线段", + "source": "examples/q1", + "measurements": 2, + "status_ref": "segment", + "status_opt": "segment", + "status_base": "point", + "status_opt_ok": true, + "status_base_ok": false, + "diameter_ref_m": 100.0, + "diameter_opt_m": 100.0, + "diameter_base_m": 0.0, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 100.0, + "covers_ref": true, + "covers_opt": true, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": true, + "mec_radius_opt_m": 50.0, + "mec_radius_ref_m": 50.0, + "outside_vertices_opt": 0, + "runtime_opt_ms": 0.0552, + "runtime_base_ms": 11.8087, + "runtime_ref_ms": 0.0202, + "reference_resolution_m": 0.0 + }, + { + "id": "empty", + "name": "不相容观测", + "source": "examples/q1", + "measurements": 2, + "status_ref": "empty", + "status_opt": "empty", + "status_base": "empty", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": null, + "diameter_opt_m": null, + "diameter_base_m": null, + "abs_err_opt_m": null, + "abs_err_base_m": null, + "covers_ref": null, + "covers_opt": null, + "covers_base": null, + "covers_opt_ok": null, + "covers_base_ok": null, + "mec_radius_opt_m": null, + "mec_radius_ref_m": null, + "outside_vertices_opt": null, + "runtime_opt_ms": 0.02, + "runtime_base_ms": 8.6963, + "runtime_ref_ms": 0.0133, + "reference_resolution_m": 0.0 + } + ], + "random": [ + { + "id": "rand-7000", + "name": "随机交会", + "source": "synthetic", + "measurements": 3, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 40.31607432662983, + "diameter_opt_m": 40.316074326883715, + "diameter_base_m": 29.154759474226502, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 11.1613, + "covers_ref": true, + "covers_opt": true, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": true, + "mec_radius_opt_m": 20.158037163441882, + "mec_radius_ref_m": 20.158037163314916, + "outside_vertices_opt": 0, + "runtime_opt_ms": 0.0701, + "runtime_base_ms": 14.8831, + "runtime_ref_ms": 0.0265, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7001", + "name": "随机交会", + "source": "synthetic", + "measurements": 4, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 33.35581916597704, + "diameter_opt_m": 33.35581916596637, + "diameter_base_m": 35.35533905932738, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 1.9995, + "covers_ref": true, + "covers_opt": true, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": true, + "mec_radius_opt_m": 16.6779095829832, + "mec_radius_ref_m": 16.67790958298852, + "outside_vertices_opt": 0, + "runtime_opt_ms": 0.0984, + "runtime_base_ms": 17.744, + "runtime_ref_ms": 0.0398, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7002", + "name": "随机交会", + "source": "synthetic", + "measurements": 3, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 39.783249312055396, + "diameter_opt_m": 39.78324931261148, + "diameter_base_m": 40.311288741492746, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 0.528, + "covers_ref": true, + "covers_opt": true, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": true, + "mec_radius_opt_m": 19.89162465630574, + "mec_radius_ref_m": 19.891624656027698, + "outside_vertices_opt": 0, + "runtime_opt_ms": 0.0683, + "runtime_base_ms": 15.5409, + "runtime_ref_ms": 0.0445, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7003", + "name": "随机交会", + "source": "synthetic", + "measurements": 5, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 37.49511447410562, + "diameter_opt_m": 37.49511447404206, + "diameter_base_m": 36.05551275463989, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 1.4396, + "covers_ref": false, + "covers_opt": false, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": false, + "mec_radius_opt_m": 19.071131680801468, + "mec_radius_ref_m": 19.071131680796437, + "outside_vertices_opt": 1, + "runtime_opt_ms": 0.1464, + "runtime_base_ms": 22.4326, + "runtime_ref_ms": 0.061, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7004", + "name": "随机交会", + "source": "synthetic", + "measurements": 3, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 48.23933852741983, + "diameter_opt_m": 48.2393385273776, + "diameter_base_m": 47.43416490252569, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 0.8052, + "covers_ref": true, + "covers_opt": true, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": true, + "mec_radius_opt_m": 24.1196692636888, + "mec_radius_ref_m": 24.119669263709916, + "outside_vertices_opt": 0, + "runtime_opt_ms": 0.0935, + "runtime_base_ms": 14.286, + "runtime_ref_ms": 0.0454, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7005", + "name": "随机交会", + "source": "synthetic", + "measurements": 3, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 27.96560761243825, + "diameter_opt_m": 27.965607612446398, + "diameter_base_m": 25.0, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 2.9656, + "covers_ref": false, + "covers_opt": false, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": false, + "mec_radius_opt_m": 14.272821844543175, + "mec_radius_ref_m": 14.272821844512093, + "outside_vertices_opt": 1, + "runtime_opt_ms": 0.0915, + "runtime_base_ms": 14.5331, + "runtime_ref_ms": 0.0348, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7006", + "name": "随机交会", + "source": "synthetic", + "measurements": 3, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 31.844568250205466, + "diameter_opt_m": 31.844568250346587, + "diameter_base_m": 32.01562118716424, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 0.1711, + "covers_ref": false, + "covers_opt": false, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": false, + "mec_radius_opt_m": 15.97095016202765, + "mec_radius_ref_m": 15.970950161991171, + "outside_vertices_opt": 2, + "runtime_opt_ms": 0.0769, + "runtime_base_ms": 14.6975, + "runtime_ref_ms": 0.0473, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7007", + "name": "随机交会", + "source": "synthetic", + "measurements": 3, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 39.1289255704389, + "diameter_opt_m": 39.12892557042704, + "diameter_base_m": 31.622776601683793, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 7.5061, + "covers_ref": true, + "covers_opt": true, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": true, + "mec_radius_opt_m": 19.56446278521352, + "mec_radius_ref_m": 19.56446278521945, + "outside_vertices_opt": 0, + "runtime_opt_ms": 0.0692, + "runtime_base_ms": 14.0158, + "runtime_ref_ms": 0.0263, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7008", + "name": "随机交会", + "source": "synthetic", + "measurements": 4, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 31.596242176635336, + "diameter_opt_m": 31.596242176144823, + "diameter_base_m": 32.01562118716424, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 0.4194, + "covers_ref": true, + "covers_opt": true, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": true, + "mec_radius_opt_m": 15.798121088072417, + "mec_radius_ref_m": 15.798121088317668, + "outside_vertices_opt": 0, + "runtime_opt_ms": 0.0832, + "runtime_base_ms": 17.8745, + "runtime_ref_ms": 0.0349, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7009", + "name": "随机交会", + "source": "synthetic", + "measurements": 5, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 34.49397606215848, + "diameter_opt_m": 34.49397606210777, + "diameter_base_m": 32.01562118716424, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 2.4784, + "covers_ref": false, + "covers_opt": false, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": false, + "mec_radius_opt_m": 17.48708565608903, + "mec_radius_ref_m": 17.4870856561063, + "outside_vertices_opt": 1, + "runtime_opt_ms": 0.1234, + "runtime_base_ms": 19.8028, + "runtime_ref_ms": 0.0467, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7010", + "name": "随机交会", + "source": "synthetic", + "measurements": 4, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 32.60743702037258, + "diameter_opt_m": 32.60743701922049, + "diameter_base_m": 26.92582403567252, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 5.6816, + "covers_ref": true, + "covers_opt": true, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": true, + "mec_radius_opt_m": 16.303718509610245, + "mec_radius_ref_m": 16.30371851018629, + "outside_vertices_opt": 0, + "runtime_opt_ms": 0.0762, + "runtime_base_ms": 15.912, + "runtime_ref_ms": 0.0278, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7011", + "name": "随机交会", + "source": "synthetic", + "measurements": 3, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 37.40957622658966, + "diameter_opt_m": 37.409576227091996, + "diameter_base_m": 35.35533905932738, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 2.0542, + "covers_ref": false, + "covers_opt": false, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": false, + "mec_radius_opt_m": 18.827682252432144, + "mec_radius_ref_m": 18.827682252179876, + "outside_vertices_opt": 1, + "runtime_opt_ms": 0.0785, + "runtime_base_ms": 12.7775, + "runtime_ref_ms": 0.0322, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7012", + "name": "随机交会", + "source": "synthetic", + "measurements": 3, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 35.15454034670783, + "diameter_opt_m": 35.15454034735778, + "diameter_base_m": 36.05551275463989, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 0.901, + "covers_ref": false, + "covers_opt": false, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": false, + "mec_radius_opt_m": 18.334091642307992, + "mec_radius_ref_m": 18.33409164197152, + "outside_vertices_opt": 1, + "runtime_opt_ms": 0.0685, + "runtime_base_ms": 12.8204, + "runtime_ref_ms": 0.0357, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7013", + "name": "随机交会", + "source": "synthetic", + "measurements": 5, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 20.561745332698695, + "diameter_opt_m": 20.561745332773153, + "diameter_base_m": 18.027756377319946, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 2.534, + "covers_ref": false, + "covers_opt": false, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": false, + "mec_radius_opt_m": 10.625215848996303, + "mec_radius_ref_m": 10.625215848911967, + "outside_vertices_opt": 2, + "runtime_opt_ms": 0.1268, + "runtime_base_ms": 18.8594, + "runtime_ref_ms": 0.0495, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7014", + "name": "随机交会", + "source": "synthetic", + "measurements": 4, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 25.229758323274588, + "diameter_opt_m": 25.229758323272243, + "diameter_base_m": 18.027756377319946, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 7.202, + "covers_ref": false, + "covers_opt": false, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": false, + "mec_radius_opt_m": 12.635959042303675, + "mec_radius_ref_m": 12.635959042304922, + "outside_vertices_opt": 1, + "runtime_opt_ms": 0.0898, + "runtime_base_ms": 15.9148, + "runtime_ref_ms": 0.0344, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7015", + "name": "随机交会", + "source": "synthetic", + "measurements": 4, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 31.60847739168007, + "diameter_opt_m": 31.608477391787925, + "diameter_base_m": 32.01562118716424, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 0.4071, + "covers_ref": true, + "covers_opt": true, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": true, + "mec_radius_opt_m": 15.804238695893975, + "mec_radius_ref_m": 15.804238695840034, + "outside_vertices_opt": 0, + "runtime_opt_ms": 0.0782, + "runtime_base_ms": 16.2486, + "runtime_ref_ms": 0.039, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7016", + "name": "随机交会", + "source": "synthetic", + "measurements": 5, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 22.193018917189054, + "diameter_opt_m": 22.19301891690189, + "diameter_base_m": 14.142135623730951, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 8.0509, + "covers_ref": false, + "covers_opt": false, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": false, + "mec_radius_opt_m": 11.170994309634908, + "mec_radius_ref_m": 11.170994309769059, + "outside_vertices_opt": 1, + "runtime_opt_ms": 0.0927, + "runtime_base_ms": 20.9535, + "runtime_ref_ms": 0.0365, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7017", + "name": "随机交会", + "source": "synthetic", + "measurements": 5, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 26.31063096947535, + "diameter_opt_m": 26.31063096947216, + "diameter_base_m": 18.027756377319946, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 8.2829, + "covers_ref": true, + "covers_opt": true, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": true, + "mec_radius_opt_m": 13.15531548473608, + "mec_radius_ref_m": 13.155315484737676, + "outside_vertices_opt": 0, + "runtime_opt_ms": 0.0886, + "runtime_base_ms": 20.8107, + "runtime_ref_ms": 0.0315, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7018", + "name": "随机交会", + "source": "synthetic", + "measurements": 3, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 37.84681297443216, + "diameter_opt_m": 37.84681297550498, + "diameter_base_m": 28.284271247461902, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 9.5625, + "covers_ref": true, + "covers_opt": true, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": true, + "mec_radius_opt_m": 18.923406487752498, + "mec_radius_ref_m": 18.92340648721608, + "outside_vertices_opt": 0, + "runtime_opt_ms": 0.0589, + "runtime_base_ms": 13.759, + "runtime_ref_ms": 0.0244, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7019", + "name": "随机交会", + "source": "synthetic", + "measurements": 4, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 25.77920437194686, + "diameter_opt_m": 25.77920437266436, + "diameter_base_m": 11.180339887498949, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 14.5989, + "covers_ref": true, + "covers_opt": true, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": true, + "mec_radius_opt_m": 12.88960218633219, + "mec_radius_ref_m": 12.88960218597343, + "outside_vertices_opt": 0, + "runtime_opt_ms": 0.068, + "runtime_base_ms": 16.923, + "runtime_ref_ms": 0.0334, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7020", + "name": "随机交会", + "source": "synthetic", + "measurements": 5, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 22.532918786458076, + "diameter_opt_m": 22.532918786458968, + "diameter_base_m": 18.027756377319946, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 4.5052, + "covers_ref": false, + "covers_opt": false, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": false, + "mec_radius_opt_m": 11.84812501858517, + "mec_radius_ref_m": 11.84812501851732, + "outside_vertices_opt": 2, + "runtime_opt_ms": 0.1108, + "runtime_base_ms": 19.3977, + "runtime_ref_ms": 0.0362, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7021", + "name": "随机交会", + "source": "synthetic", + "measurements": 3, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 36.83680710846674, + "diameter_opt_m": 36.836807108256096, + "diameter_base_m": 26.92582403567252, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 9.911, + "covers_ref": true, + "covers_opt": true, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": true, + "mec_radius_opt_m": 18.418403554128048, + "mec_radius_ref_m": 18.41840355423337, + "outside_vertices_opt": 0, + "runtime_opt_ms": 0.078, + "runtime_base_ms": 13.0248, + "runtime_ref_ms": 0.0313, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7022", + "name": "随机交会", + "source": "synthetic", + "measurements": 3, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 51.21412600999724, + "diameter_opt_m": 51.214126009576596, + "diameter_base_m": 47.16990566028302, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 4.0442, + "covers_ref": true, + "covers_opt": true, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": true, + "mec_radius_opt_m": 25.607063004788298, + "mec_radius_ref_m": 25.60706300499862, + "outside_vertices_opt": 0, + "runtime_opt_ms": 0.065, + "runtime_base_ms": 14.177, + "runtime_ref_ms": 0.0349, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7023", + "name": "随机交会", + "source": "synthetic", + "measurements": 3, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 32.88285380532669, + "diameter_opt_m": 32.88285380548078, + "diameter_base_m": 29.154759474226502, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 3.7281, + "covers_ref": true, + "covers_opt": true, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": true, + "mec_radius_opt_m": 16.441426902740396, + "mec_radius_ref_m": 16.441426902663345, + "outside_vertices_opt": 0, + "runtime_opt_ms": 0.0898, + "runtime_base_ms": 14.9865, + "runtime_ref_ms": 0.0412, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7024", + "name": "随机交会", + "source": "synthetic", + "measurements": 3, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 29.992127633835427, + "diameter_opt_m": 29.99212763338539, + "diameter_base_m": 32.01562118716424, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 2.0235, + "covers_ref": false, + "covers_opt": false, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": false, + "mec_radius_opt_m": 15.232966284678072, + "mec_radius_ref_m": 15.232966285007048, + "outside_vertices_opt": 2, + "runtime_opt_ms": 0.0736, + "runtime_base_ms": 14.7848, + "runtime_ref_ms": 0.0399, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7025", + "name": "随机交会", + "source": "synthetic", + "measurements": 3, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 36.49852724056778, + "diameter_opt_m": 36.49852723941667, + "diameter_base_m": 28.284271247461902, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 8.2143, + "covers_ref": true, + "covers_opt": true, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": true, + "mec_radius_opt_m": 18.249263619708334, + "mec_radius_ref_m": 18.24926362028389, + "outside_vertices_opt": 0, + "runtime_opt_ms": 0.0972, + "runtime_base_ms": 14.1027, + "runtime_ref_ms": 0.0398, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7026", + "name": "随机交会", + "source": "synthetic", + "measurements": 4, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 26.38009544372075, + "diameter_opt_m": 26.380095443067933, + "diameter_base_m": 18.027756377319946, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 8.3523, + "covers_ref": true, + "covers_opt": true, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": true, + "mec_radius_opt_m": 13.190047721533977, + "mec_radius_ref_m": 13.190047721860376, + "outside_vertices_opt": 0, + "runtime_opt_ms": 0.081, + "runtime_base_ms": 16.3059, + "runtime_ref_ms": 0.0368, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7027", + "name": "随机交会", + "source": "synthetic", + "measurements": 3, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 50.106954210530944, + "diameter_opt_m": 50.106954213051324, + "diameter_base_m": 49.24428900898052, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 0.8627, + "covers_ref": true, + "covers_opt": true, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": true, + "mec_radius_opt_m": 25.053477106525687, + "mec_radius_ref_m": 25.053477105265472, + "outside_vertices_opt": 0, + "runtime_opt_ms": 0.0625, + "runtime_base_ms": 13.4405, + "runtime_ref_ms": 0.0304, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7028", + "name": "随机交会", + "source": "synthetic", + "measurements": 4, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 23.293546922634267, + "diameter_opt_m": 23.29354692201816, + "diameter_base_m": 22.360679774997898, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 0.9329, + "covers_ref": false, + "covers_opt": false, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": false, + "mec_radius_opt_m": 12.050848110096064, + "mec_radius_ref_m": 12.050848110414112, + "outside_vertices_opt": 1, + "runtime_opt_ms": 0.0882, + "runtime_base_ms": 16.6899, + "runtime_ref_ms": 0.0278, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7029", + "name": "随机交会", + "source": "synthetic", + "measurements": 3, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 40.72939617953489, + "diameter_opt_m": 40.729396179428505, + "diameter_base_m": 42.42640687119285, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 1.697, + "covers_ref": true, + "covers_opt": true, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": true, + "mec_radius_opt_m": 20.364698089714256, + "mec_radius_ref_m": 20.364698089767444, + "outside_vertices_opt": 0, + "runtime_opt_ms": 0.0903, + "runtime_base_ms": 12.7776, + "runtime_ref_ms": 0.0417, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7030", + "name": "随机交会", + "source": "synthetic", + "measurements": 3, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 34.087528410034416, + "diameter_opt_m": 34.0875284094775, + "diameter_base_m": 25.0, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 9.0875, + "covers_ref": true, + "covers_opt": true, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": true, + "mec_radius_opt_m": 17.043764204738757, + "mec_radius_ref_m": 17.043764205017208, + "outside_vertices_opt": 0, + "runtime_opt_ms": 0.0896, + "runtime_base_ms": 13.1668, + "runtime_ref_ms": 0.0384, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7031", + "name": "随机交会", + "source": "synthetic", + "measurements": 3, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 23.349478820863148, + "diameter_opt_m": 23.349478820491875, + "diameter_base_m": 18.027756377319946, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 5.3217, + "covers_ref": false, + "covers_opt": false, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": false, + "mec_radius_opt_m": 11.717388488808723, + "mec_radius_ref_m": 11.717388489014777, + "outside_vertices_opt": 1, + "runtime_opt_ms": 0.0689, + "runtime_base_ms": 12.9799, + "runtime_ref_ms": 0.0261, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7032", + "name": "随机交会", + "source": "synthetic", + "measurements": 4, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 14.894980777826397, + "diameter_opt_m": 14.894980777882363, + "diameter_base_m": 11.180339887498949, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 3.7146, + "covers_ref": false, + "covers_opt": false, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": false, + "mec_radius_opt_m": 7.453494960896134, + "mec_radius_ref_m": 7.453494960868165, + "outside_vertices_opt": 1, + "runtime_opt_ms": 0.079, + "runtime_base_ms": 15.9627, + "runtime_ref_ms": 0.0288, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7033", + "name": "随机交会", + "source": "synthetic", + "measurements": 3, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 38.11988449845443, + "diameter_opt_m": 38.119884497841866, + "diameter_base_m": 33.54101966249684, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 4.5789, + "covers_ref": true, + "covers_opt": true, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": true, + "mec_radius_opt_m": 19.059942248920944, + "mec_radius_ref_m": 19.059942249227216, + "outside_vertices_opt": 0, + "runtime_opt_ms": 0.0574, + "runtime_base_ms": 13.0265, + "runtime_ref_ms": 0.04, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7034", + "name": "随机交会", + "source": "synthetic", + "measurements": 5, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 13.684491438876828, + "diameter_opt_m": 13.684491438514321, + "diameter_base_m": 5.0, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 8.6845, + "covers_ref": true, + "covers_opt": true, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": true, + "mec_radius_opt_m": 6.842245719257161, + "mec_radius_ref_m": 6.842245719438414, + "outside_vertices_opt": 0, + "runtime_opt_ms": 0.0967, + "runtime_base_ms": 19.4125, + "runtime_ref_ms": 0.032, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7035", + "name": "随机交会", + "source": "synthetic", + "measurements": 3, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 41.439650340566565, + "diameter_opt_m": 41.43965034102056, + "diameter_base_m": 43.01162633521314, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 1.572, + "covers_ref": false, + "covers_opt": false, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": false, + "mec_radius_opt_m": 20.731707538528333, + "mec_radius_ref_m": 20.731707538308516, + "outside_vertices_opt": 1, + "runtime_opt_ms": 0.0917, + "runtime_base_ms": 13.0208, + "runtime_ref_ms": 0.04, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7036", + "name": "随机交会", + "source": "synthetic", + "measurements": 5, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 22.9932027470415, + "diameter_opt_m": 22.993202747061332, + "diameter_base_m": 18.027756377319946, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 4.9654, + "covers_ref": false, + "covers_opt": false, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": false, + "mec_radius_opt_m": 11.67395498092525, + "mec_radius_ref_m": 11.673954980915163, + "outside_vertices_opt": 1, + "runtime_opt_ms": 0.1047, + "runtime_base_ms": 18.6447, + "runtime_ref_ms": 0.0401, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7037", + "name": "随机交会", + "source": "synthetic", + "measurements": 4, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 34.00463363020301, + "diameter_opt_m": 34.00463363023506, + "diameter_base_m": 35.35533905932738, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 1.3507, + "covers_ref": false, + "covers_opt": false, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": false, + "mec_radius_opt_m": 17.834158435419383, + "mec_radius_ref_m": 17.834158435396787, + "outside_vertices_opt": 2, + "runtime_opt_ms": 0.0955, + "runtime_base_ms": 16.2452, + "runtime_ref_ms": 0.0367, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7038", + "name": "随机交会", + "source": "synthetic", + "measurements": 5, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 16.204024768849592, + "diameter_opt_m": 16.20402476884961, + "diameter_base_m": 7.0710678118654755, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 9.133, + "covers_ref": false, + "covers_opt": false, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": false, + "mec_radius_opt_m": 8.618962801497863, + "mec_radius_ref_m": 8.618962801497812, + "outside_vertices_opt": 1, + "runtime_opt_ms": 0.095, + "runtime_base_ms": 18.7867, + "runtime_ref_ms": 0.0325, + "reference_resolution_m": 0.0 + }, + { + "id": "rand-7039", + "name": "随机交会", + "source": "synthetic", + "measurements": 4, + "status_ref": "polygon", + "status_opt": "polygon", + "status_base": "polygon", + "status_opt_ok": true, + "status_base_ok": true, + "diameter_ref_m": 26.90194382595001, + "diameter_opt_m": 26.901943825808125, + "diameter_base_m": 25.0, + "abs_err_opt_m": 0.0, + "abs_err_base_m": 1.9019, + "covers_ref": false, + "covers_opt": false, + "covers_base": true, + "covers_opt_ok": true, + "covers_base_ok": false, + "mec_radius_opt_m": 13.94817032918484, + "mec_radius_ref_m": 13.94817032907026, + "outside_vertices_opt": 1, + "runtime_opt_ms": 0.0829, + "runtime_base_ms": 15.5779, + "runtime_ref_ms": 0.0297, + "reference_resolution_m": 0.0 + } + ], + "aggregate_examples": { + "cases": 5, + "diameter_compared": 2, + "status_accuracy_optimal": 1.0, + "status_accuracy_baseline": 0.8, + "diameter_mae_optimal_m": 0.0, + "diameter_mae_baseline_m": 7.8864, + "diameter_max_err_optimal_m": 0.0, + "diameter_max_err_baseline_m": 10.0, + "coverage_compared": 3, + "coverage_accuracy_optimal": 1.0, + "coverage_accuracy_baseline": 0.3333, + "runtime_optimal_mean_ms": 0.064, + "runtime_baseline_mean_ms": 14.2021, + "runtime_reference_mean_ms": 0.0297 + }, + "aggregate_random": { + "cases": 40, + "diameter_compared": 40, + "status_accuracy_optimal": 1.0, + "status_accuracy_baseline": 1.0, + "diameter_mae_optimal_m": 0.0, + "diameter_mae_baseline_m": 4.5833, + "diameter_max_err_optimal_m": 0.0, + "diameter_max_err_baseline_m": 14.5989, + "coverage_compared": 40, + "coverage_accuracy_optimal": 1.0, + "coverage_accuracy_baseline": 0.525, + "runtime_optimal_mean_ms": 0.0861, + "runtime_baseline_mean_ms": 15.9325, + "runtime_reference_mean_ms": 0.0364 + } +} diff --git a/project/results/q1.md b/project/results/q1.md new file mode 100644 index 0000000..f86e8a5 --- /dev/null +++ b/project/results/q1.md @@ -0,0 +1,80 @@ +# 问题一：固定示例对比 + +参考解为独立的大框半平面裁剪 + 精确直径/MEC； +固定示例见 `examples/q1`，解析期望由 `tests/test_geometry*.py` 固化。 + +| 算例 | 来源 | 参考状态 | 最优状态 | 基线状态 | D参考(m) | D最优(m) | D基线(m) | |ΔD|最优 | |ΔD|基线 | 覆盖参考 | 覆盖最优 | 覆盖基线 | +| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | +| 三点交会 | examples/q1 | polygon | polygon | polygon | 26.99 | 26.99 | 21.21 | 0.00 | 5.77 | 否 | 否 | 是 | +| 直径圆反例 | examples/q1 | polygon | polygon | polygon | 40.00 | 40.00 | 50.00 | 0.00 | 10.00 | 否 | 否 | 是 | +| 近共线检测点 | examples/q1 | unbounded | unbounded | unbounded | — | — | — | — | — | — | — | — | +| 零误差退化线段 | examples/q1 | segment | segment | point | 100.00 | 100.00 | 0.00 | 0.00 | 100.00 | 是 | 是 | 是 | +| 不相容观测 | examples/q1 | empty | empty | empty | — | — | — | — | — | — | — | — | + +## 汇总 + +| 指标 | 最优 | 基线 | +| --- | --- | --- | +| 状态判定准确率 | 100.0% | 80.0% | +| 直径平均绝对误差 (m) | 0.000 | 7.886 | +| 直径最大误差 (m) | 0.000 | 10.000 | +| 覆盖判定准确率 | 100.0% | 33.3% | +| 平均耗时 (ms) | 0.064 | 14.202 | + +# 问题一：随机交会算例对比 + +参考解为独立的大框半平面裁剪 + 精确直径/MEC； +固定示例见 `examples/q1`，解析期望由 `tests/test_geometry*.py` 固化。 + +| 算例 | 来源 | 参考状态 | 最优状态 | 基线状态 | D参考(m) | D最优(m) | D基线(m) | |ΔD|最优 | |ΔD|基线 | 覆盖参考 | 覆盖最优 | 覆盖基线 | +| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | +| 随机交会 | synthetic | polygon | polygon | polygon | 40.32 | 40.32 | 29.15 | 0.00 | 11.16 | 是 | 是 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 33.36 | 33.36 | 35.36 | 0.00 | 2.00 | 是 | 是 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 39.78 | 39.78 | 40.31 | 0.00 | 0.53 | 是 | 是 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 37.50 | 37.50 | 36.06 | 0.00 | 1.44 | 否 | 否 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 48.24 | 48.24 | 47.43 | 0.00 | 0.81 | 是 | 是 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 27.97 | 27.97 | 25.00 | 0.00 | 2.97 | 否 | 否 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 31.84 | 31.84 | 32.02 | 0.00 | 0.17 | 否 | 否 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 39.13 | 39.13 | 31.62 | 0.00 | 7.51 | 是 | 是 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 31.60 | 31.60 | 32.02 | 0.00 | 0.42 | 是 | 是 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 34.49 | 34.49 | 32.02 | 0.00 | 2.48 | 否 | 否 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 32.61 | 32.61 | 26.93 | 0.00 | 5.68 | 是 | 是 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 37.41 | 37.41 | 35.36 | 0.00 | 2.05 | 否 | 否 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 35.15 | 35.15 | 36.06 | 0.00 | 0.90 | 否 | 否 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 20.56 | 20.56 | 18.03 | 0.00 | 2.53 | 否 | 否 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 25.23 | 25.23 | 18.03 | 0.00 | 7.20 | 否 | 否 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 31.61 | 31.61 | 32.02 | 0.00 | 0.41 | 是 | 是 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 22.19 | 22.19 | 14.14 | 0.00 | 8.05 | 否 | 否 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 26.31 | 26.31 | 18.03 | 0.00 | 8.28 | 是 | 是 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 37.85 | 37.85 | 28.28 | 0.00 | 9.56 | 是 | 是 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 25.78 | 25.78 | 11.18 | 0.00 | 14.60 | 是 | 是 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 22.53 | 22.53 | 18.03 | 0.00 | 4.51 | 否 | 否 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 36.84 | 36.84 | 26.93 | 0.00 | 9.91 | 是 | 是 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 51.21 | 51.21 | 47.17 | 0.00 | 4.04 | 是 | 是 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 32.88 | 32.88 | 29.15 | 0.00 | 3.73 | 是 | 是 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 29.99 | 29.99 | 32.02 | 0.00 | 2.02 | 否 | 否 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 36.50 | 36.50 | 28.28 | 0.00 | 8.21 | 是 | 是 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 26.38 | 26.38 | 18.03 | 0.00 | 8.35 | 是 | 是 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 50.11 | 50.11 | 49.24 | 0.00 | 0.86 | 是 | 是 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 23.29 | 23.29 | 22.36 | 0.00 | 0.93 | 否 | 否 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 40.73 | 40.73 | 42.43 | 0.00 | 1.70 | 是 | 是 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 34.09 | 34.09 | 25.00 | 0.00 | 9.09 | 是 | 是 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 23.35 | 23.35 | 18.03 | 0.00 | 5.32 | 否 | 否 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 14.89 | 14.89 | 11.18 | 0.00 | 3.71 | 否 | 否 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 38.12 | 38.12 | 33.54 | 0.00 | 4.58 | 是 | 是 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 13.68 | 13.68 | 5.00 | 0.00 | 8.68 | 是 | 是 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 41.44 | 41.44 | 43.01 | 0.00 | 1.57 | 否 | 否 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 22.99 | 22.99 | 18.03 | 0.00 | 4.97 | 否 | 否 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 34.00 | 34.00 | 35.36 | 0.00 | 1.35 | 否 | 否 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 16.20 | 16.20 | 7.07 | 0.00 | 9.13 | 否 | 否 | 是 | +| 随机交会 | synthetic | polygon | polygon | polygon | 26.90 | 26.90 | 25.00 | 0.00 | 1.90 | 否 | 否 | 是 | + +## 汇总 + +| 指标 | 最优 | 基线 | +| --- | --- | --- | +| 状态判定准确率 | 100.0% | 100.0% | +| 直径平均绝对误差 (m) | 0.000 | 4.583 | +| 直径最大误差 (m) | 0.000 | 14.599 | +| 覆盖判定准确率 | 100.0% | 52.5% | +| 平均耗时 (ms) | 0.086 | 15.932 | diff --git a/project/results/q2.json b/project/results/q2.json new file mode 100644 index 0000000..57b6ba1 --- /dev/null +++ b/project/results/q2.json @@ -0,0 +1,2382 @@ +{ + "question": 2, + "methods": [ + { + "key": "optimal", + "name": "保证接收盘内最小最坏后验半径", + "kind": "optimal", + "note": "生产实现 mcm26b.planner.select_measurement_point" + }, + { + "key": "baseline_perp", + "name": "垂直 1000 m 最大交会角", + "kind": "baseline", + "note": "忽略接收保证的几何启发式" + }, + { + "key": "baseline_mec", + "name": "候选集 MEC 圆心", + "kind": "baseline", + "note": "保证接收但交会角最差的保守基线" + }, + { + "key": "reference", + "name": "保证接收盘内网格枚举", + "kind": "reference", + "note": "同一目标下的稠密网格参考，非连续全局最优" + } + ], + "cases": [ + { + "id": "q2-4200", + "station": [ + 545.7, + -474.18 + ], + "bearing_deg": 20.61, + "half_angle_deg": 1.0, + "true_source": [ + 1347.34, + -187.32 + ] + }, + { + "id": "q2-4201", + "station": [ + -1368.99, + 94.53 + ], + "bearing_deg": 215.96, + "half_angle_deg": 1.0, + "true_source": [ + -1646.4, + -113.49 + ] + }, + { + "id": "q2-4202", + "station": [ + -316.46, + -545.83 + ], + "bearing_deg": 226.43, + "half_angle_deg": 1.0, + "true_source": [ + -1008.85, + -1281.03 + ] + }, + { + "id": "q2-4203", + "station": [ + 933.57, + -1095.17 + ], + "bearing_deg": 244.66, + "half_angle_deg": 1.0, + "true_source": [ + 832.17, + -1309.43 + ] + }, + { + "id": "q2-4204", + "station": [ + -931.54, + -490.47 + ], + "bearing_deg": 37.56, + "half_angle_deg": 1.0, + "true_source": [ + -478.32, + -139.2 + ] + }, + { + "id": "q2-4205", + "station": [ + 15.99, + -691.72 + ], + "bearing_deg": 141.1, + "half_angle_deg": 1.0, + "true_source": [ + -533.81, + -260.36 + ] + }, + { + "id": "q2-4206", + "station": [ + 613.71, + 1475.11 + ], + "bearing_deg": 257.93, + "half_angle_deg": 1.0, + "true_source": [ + 463.25, + 797.25 + ] + }, + { + "id": "q2-4207", + "station": [ + 306.3, + 502.4 + ], + "bearing_deg": 344.25, + "half_angle_deg": 1.0, + "true_source": [ + 984.81, + 308.26 + ] + }, + { + "id": "q2-4208", + "station": [ + -974.02, + 495.52 + ], + "bearing_deg": 255.13, + "half_angle_deg": 1.0, + "true_source": [ + -1084.91, + 85.1 + ] + }, + { + "id": "q2-4209", + "station": [ + -122.73, + 232.72 + ], + "bearing_deg": 29.91, + "half_angle_deg": 1.0, + "true_source": [ + 1174.14, + 957.27 + ] + }, + { + "id": "q2-4210", + "station": [ + 415.63, + 798.23 + ], + "bearing_deg": 141.6, + "half_angle_deg": 1.0, + "true_source": [ + -57.58, + 1168.92 + ] + }, + { + "id": "q2-4211", + "station": [ + -1084.66, + 328.56 + ], + "bearing_deg": 315.09, + "half_angle_deg": 1.0, + "true_source": [ + -532.3, + -238.32 + ] + }, + { + "id": "q2-4212", + "station": [ + 1248.44, + -9.02 + ], + "bearing_deg": 193.75, + "half_angle_deg": 1.0, + "true_source": [ + 252.02, + -254.88 + ] + }, + { + "id": "q2-4213", + "station": [ + -1190.0, + -963.11 + ], + "bearing_deg": 27.36, + "half_angle_deg": 1.0, + "true_source": [ + -844.79, + -783.47 + ] + }, + { + "id": "q2-4214", + "station": [ + -160.49, + -1597.36 + ], + "bearing_deg": 16.53, + "half_angle_deg": 1.0, + "true_source": [ + 734.05, + -1327.49 + ] + }, + { + "id": "q2-4215", + "station": [ + -666.58, + -351.66 + ], + "bearing_deg": 176.29, + "half_angle_deg": 1.0, + "true_source": [ + -811.68, + -339.99 + ] + }, + { + "id": "q2-4216", + "station": [ + -1468.89, + -560.41 + ], + "bearing_deg": 306.91, + "half_angle_deg": 1.0, + "true_source": [ + -1270.03, + -831.62 + ] + }, + { + "id": "q2-4217", + "station": [ + -858.55, + 1314.12 + ], + "bearing_deg": 240.3, + "half_angle_deg": 1.0, + "true_source": [ + -1553.59, + 84.63 + ] + }, + { + "id": "q2-4218", + "station": [ + -991.36, + -857.97 + ], + "bearing_deg": 56.04, + "half_angle_deg": 1.0, + "true_source": [ + -837.77, + -623.18 + ] + }, + { + "id": "q2-4219", + "station": [ + 473.91, + 113.4 + ], + "bearing_deg": 144.97, + "half_angle_deg": 1.0, + "true_source": [ + -548.94, + 808.35 + ] + }, + { + "id": "q2-4220", + "station": [ + -289.71, + -616.25 + ], + "bearing_deg": 64.36, + "half_angle_deg": 1.0, + "true_source": [ + 213.2, + 443.43 + ] + }, + { + "id": "q2-4221", + "station": [ + -277.2, + -361.13 + ], + "bearing_deg": 357.43, + "half_angle_deg": 1.0, + "true_source": [ + 1185.68, + -441.64 + ] + }, + { + "id": "q2-4222", + "station": [ + 1437.56, + -741.29 + ], + "bearing_deg": 77.54, + "half_angle_deg": 1.0, + "true_source": [ + 1653.48, + 166.74 + ] + }, + { + "id": "q2-4223", + "station": [ + -1056.59, + -633.05 + ], + "bearing_deg": 156.16, + "half_angle_deg": 1.0, + "true_source": [ + -1628.93, + -369.26 + ] + }, + { + "id": "q2-4224", + "station": [ + -514.36, + 1470.58 + ], + "bearing_deg": 259.06, + "half_angle_deg": 1.0, + "true_source": [ + -772.21, + 122.14 + ] + }, + { + "id": "q2-4225", + "station": [ + -160.22, + -1147.83 + ], + "bearing_deg": 115.4, + "half_angle_deg": 1.0, + "true_source": [ + -686.67, + -55.06 + ] + }, + { + "id": "q2-4226", + "station": [ + 1062.03, + 1151.45 + ], + "bearing_deg": 224.04, + "half_angle_deg": 1.0, + "true_source": [ + 203.78, + 313.8 + ] + }, + { + "id": "q2-4227", + "station": [ + 557.83, + -797.07 + ], + "bearing_deg": 251.02, + "half_angle_deg": 1.0, + "true_source": [ + 472.13, + -1048.13 + ] + }, + { + "id": "q2-4228", + "station": [ + -651.57, + 1278.91 + ], + "bearing_deg": 317.82, + "half_angle_deg": 1.0, + "true_source": [ + 138.3, + 543.89 + ] + }, + { + "id": "q2-4229", + "station": [ + -76.01, + -1580.92 + ], + "bearing_deg": 37.47, + "half_angle_deg": 1.0, + "true_source": [ + 313.38, + -1290.33 + ] + } + ], + "rows": [ + { + "case_id": "q2-4200", + "method": "optimal", + "initial_radius_m": 674.5869, + "q": [ + 1257.07, + 88.64 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 907.093, + "worst_posterior_radius_m": 54.4545, + "improvement_m": 620.1324, + "final_ratio": 0.0807, + "move_cost_s": 181.4186, + "reason": "安全盘 B(centre,325m) 内 37 候选；粗采样最坏后验 54.5m，1/4 间距加密复核 54.5m" + }, + { + "case_id": "q2-4200", + "method": "baseline_perp", + "initial_radius_m": 674.5869, + "q": [ + 193.69, + 461.82 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1679.158, + "worst_posterior_radius_m": 76.2247, + "improvement_m": 598.3622, + "final_ratio": 0.113, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4200", + "method": "baseline_mec", + "initial_radius_m": 674.5869, + "q": [ + 1172.85, + -225.68 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 674.587, + "worst_posterior_radius_m": 337.2934, + "improvement_m": 337.2935, + "final_ratio": 0.5, + "move_cost_s": 134.9174, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4200", + "method": "reference", + "initial_radius_m": 674.5869, + "q": [ + 1172.85, + 99.73 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 850.11, + "worst_posterior_radius_m": 57.7006, + "improvement_m": 616.8863, + "final_ratio": 0.0855, + "move_cost_s": 170.0221, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4201", + "method": "optimal", + "initial_radius_m": 261.3319, + "q": [ + -1501.32, + -348.01 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 461.907, + "worst_posterior_radius_m": 13.554, + "improvement_m": 247.7779, + "final_ratio": 0.0519, + "move_cost_s": 92.3814, + "reason": "安全盘 B(centre,739m) 内 37 候选；粗采样最坏后验 13.6m，1/4 间距加密复核 13.6m" + }, + { + "case_id": "q2-4201", + "method": "baseline_perp", + "initial_radius_m": 261.3319, + "q": [ + -781.77, + -714.9 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1131.685, + "worst_posterior_radius_m": 27.2223, + "improvement_m": 234.1096, + "final_ratio": 0.1042, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4201", + "method": "baseline_mec", + "initial_radius_m": 261.3319, + "q": [ + -1577.8, + -62.62 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 261.332, + "worst_posterior_radius_m": 130.666, + "improvement_m": 130.6659, + "final_ratio": 0.5, + "move_cost_s": 52.2664, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4201", + "method": "reference", + "initial_radius_m": 261.3319, + "q": [ + -1393.13, + -431.95 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 527.033, + "worst_posterior_radius_m": 14.9755, + "improvement_m": 246.3564, + "final_ratio": 0.0573, + "move_cost_s": 105.4065, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4202", + "method": "optimal", + "initial_radius_m": 591.0865, + "q": [ + -1126.29, + -861.05 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 869.013, + "worst_posterior_radius_m": 37.9172, + "improvement_m": 553.1693, + "final_ratio": 0.0641, + "move_cost_s": 173.8026, + "reason": "安全盘 B(centre,409m) 内 37 候选；粗采样最坏后验 37.9m，1/4 间距加密复核 37.9m" + }, + { + "case_id": "q2-4202", + "method": "baseline_perp", + "initial_radius_m": 591.0865, + "q": [ + 408.07, + -1235.07 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1561.731, + "worst_posterior_radius_m": 64.5663, + "improvement_m": 526.5201, + "final_ratio": 0.1092, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4202", + "method": "baseline_mec", + "initial_radius_m": 591.0865, + "q": [ + -731.31, + -966.88 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 591.086, + "worst_posterior_radius_m": 295.543, + "improvement_m": 295.5435, + "final_ratio": 0.5, + "move_cost_s": 118.2173, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4202", + "method": "reference", + "initial_radius_m": 591.0865, + "q": [ + -1037.99, + -864.65 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 788.834, + "worst_posterior_radius_m": 46.2224, + "improvement_m": 544.8641, + "final_ratio": 0.0782, + "move_cost_s": 157.7667, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4203", + "method": "optimal", + "initial_radius_m": 326.9242, + "q": [ + 1145.44, + -1745.09 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 683.584, + "worst_posterior_radius_m": 17.1337, + "improvement_m": 309.7905, + "final_ratio": 0.0524, + "move_cost_s": 136.7168, + "reason": "安全盘 B(centre,673m) 内 37 候选；粗采样最坏后验 17.1m，1/4 间距加密复核 17.1m" + }, + { + "case_id": "q2-4203", + "method": "baseline_perp", + "initial_radius_m": 326.9242, + "q": [ + 1837.35, + -1523.16 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1204.348, + "worst_posterior_radius_m": 32.9937, + "improvement_m": 293.9305, + "final_ratio": 0.1009, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4203", + "method": "baseline_mec", + "initial_radius_m": 326.9242, + "q": [ + 788.49, + -1388.14 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 326.924, + "worst_posterior_radius_m": 163.4621, + "improvement_m": 163.4621, + "final_ratio": 0.5, + "move_cost_s": 65.3848, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4203", + "method": "reference", + "initial_radius_m": 326.9242, + "q": [ + 1125.03, + -1724.68 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 657.977, + "worst_posterior_radius_m": 16.9004, + "improvement_m": 310.0238, + "final_ratio": 0.0517, + "move_cost_s": 131.5955, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4204", + "method": "optimal", + "initial_radius_m": 750.2026, + "q": [ + -401.08, + 207.59 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 876.743, + "worst_posterior_radius_m": 91.6039, + "improvement_m": 658.5987, + "final_ratio": 0.1221, + "move_cost_s": 175.3487, + "reason": "安全盘 B(centre,250m) 内 37 候选；粗采样最坏后验 91.6m，1/4 间距加密复核 91.6m" + }, + { + "case_id": "q2-4204", + "method": "baseline_perp", + "initial_radius_m": 750.2026, + "q": [ + -1541.13, + 302.25 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1817.476, + "worst_posterior_radius_m": 90.7926, + "improvement_m": 659.41, + "final_ratio": 0.121, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4204", + "method": "baseline_mec", + "initial_radius_m": 750.2026, + "q": [ + -336.43, + -33.69 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 750.203, + "worst_posterior_radius_m": 375.1022, + "improvement_m": 375.1004, + "final_ratio": 0.5, + "move_cost_s": 150.0405, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4204", + "method": "reference", + "initial_radius_m": 750.2026, + "q": [ + -336.43, + 216.1 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 923.799, + "worst_posterior_radius_m": 92.2487, + "improvement_m": 657.9539, + "final_ratio": 0.123, + "move_cost_s": 184.7599, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4205", + "method": "optimal", + "initial_radius_m": 750.1405, + "q": [ + -502.88, + 21.0 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 881.587, + "worst_posterior_radius_m": 91.0955, + "improvement_m": 659.045, + "final_ratio": 0.1214, + "move_cost_s": 176.3175, + "reason": "安全盘 B(centre,250m) 内 37 候选；粗采样最坏后验 91.1m，1/4 间距加密复核 91.1m" + }, + { + "case_id": "q2-4205", + "method": "baseline_perp", + "initial_radius_m": 750.1405, + "q": [ + -611.97, + -1469.96 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1817.364, + "worst_posterior_radius_m": 90.7805, + "improvement_m": 659.3599, + "final_ratio": 0.121, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4205", + "method": "baseline_mec", + "initial_radius_m": 750.1405, + "q": [ + -567.55, + -220.34 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 750.14, + "worst_posterior_radius_m": 375.0849, + "improvement_m": 375.0556, + "final_ratio": 0.5, + "move_cost_s": 150.0281, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4205", + "method": "reference", + "initial_radius_m": 750.1405, + "q": [ + -567.55, + 29.52 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 927.736, + "worst_posterior_radius_m": 92.2506, + "improvement_m": 657.8898, + "final_ratio": 0.123, + "move_cost_s": 185.5473, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4206", + "method": "optimal", + "initial_radius_m": 750.1175, + "q": [ + 215.59, + 676.88 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 892.004, + "worst_posterior_radius_m": 90.9599, + "improvement_m": 659.1576, + "final_ratio": 0.1213, + "move_cost_s": 178.4008, + "reason": "安全盘 B(centre,250m) 内 37 候选；粗采样最坏后验 91.0m，1/4 间距加密复核 91.0m" + }, + { + "case_id": "q2-4206", + "method": "baseline_perp", + "initial_radius_m": 750.1175, + "q": [ + 1591.6, + 1266.0 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1817.311, + "worst_posterior_radius_m": 90.7748, + "improvement_m": 659.3427, + "final_ratio": 0.121, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4206", + "method": "baseline_mec", + "initial_radius_m": 750.1175, + "q": [ + 456.96, + 741.55 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 750.118, + "worst_posterior_radius_m": 375.0979, + "improvement_m": 375.0196, + "final_ratio": 0.5001, + "move_cost_s": 150.0235, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4206", + "method": "reference", + "initial_radius_m": 750.1175, + "q": [ + 207.07, + 741.55 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 838.723, + "worst_posterior_radius_m": 94.2065, + "improvement_m": 655.911, + "final_ratio": 0.1256, + "move_cost_s": 167.7446, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4207", + "method": "optimal", + "initial_radius_m": 750.1199, + "q": [ + 1204.99, + 475.64 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 899.091, + "worst_posterior_radius_m": 90.8511, + "improvement_m": 659.2688, + "final_ratio": 0.1211, + "move_cost_s": 179.8182, + "reason": "安全盘 B(centre,250m) 内 37 候选；粗采样最坏后验 90.9m，1/4 间距加密复核 90.9m" + }, + { + "case_id": "q2-4207", + "method": "baseline_perp", + "initial_radius_m": 750.1199, + "q": [ + 577.74, + 1464.86 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1817.314, + "worst_posterior_radius_m": 90.775, + "improvement_m": 659.3449, + "final_ratio": 0.121, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4207", + "method": "baseline_mec", + "initial_radius_m": 750.1199, + "q": [ + 1028.3, + 298.95 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 750.12, + "worst_posterior_radius_m": 375.0932, + "improvement_m": 375.0267, + "final_ratio": 0.5, + "move_cost_s": 150.024, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4207", + "method": "reference", + "initial_radius_m": 750.1199, + "q": [ + 1028.3, + 49.07 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 852.524, + "worst_posterior_radius_m": 92.9717, + "improvement_m": 657.1483, + "final_ratio": 0.1239, + "move_cost_s": 170.5048, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4208", + "method": "optimal", + "initial_radius_m": 750.1908, + "q": [ + -1408.52, + -294.02 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 901.202, + "worst_posterior_radius_m": 90.7476, + "improvement_m": 659.4432, + "final_ratio": 0.121, + "move_cost_s": 180.2404, + "reason": "安全盘 B(centre,250m) 内 37 候选；粗采样最坏后验 90.7m，1/4 间距加密复核 90.7m" + }, + { + "case_id": "q2-4208", + "method": "baseline_perp", + "initial_radius_m": 750.1908, + "q": [ + -7.51, + 238.89 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1817.457, + "worst_posterior_radius_m": 90.7906, + "improvement_m": 659.4002, + "final_ratio": 0.121, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4208", + "method": "baseline_mec", + "initial_radius_m": 750.1908, + "q": [ + -1167.23, + -229.36 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 750.191, + "worst_posterior_radius_m": 375.0973, + "improvement_m": 375.0934, + "final_ratio": 0.5, + "move_cost_s": 150.0381, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4208", + "method": "reference", + "initial_radius_m": 750.1908, + "q": [ + -1417.03, + -229.36 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 849.54, + "worst_posterior_radius_m": 93.0509, + "improvement_m": 657.1399, + "final_ratio": 0.124, + "move_cost_s": 169.9081, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4209", + "method": "optimal", + "initial_radius_m": 750.1984, + "q": [ + 462.52, + 848.73 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 849.702, + "worst_posterior_radius_m": 93.0327, + "improvement_m": 657.1657, + "final_ratio": 0.124, + "move_cost_s": 169.9405, + "reason": "安全盘 B(centre,250m) 内 37 候选；粗采样最坏后验 93.0m，1/4 间距加密复核 93.0m" + }, + { + "case_id": "q2-4209", + "method": "baseline_perp", + "initial_radius_m": 750.1984, + "q": [ + -621.37, + 1099.53 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1817.427, + "worst_posterior_radius_m": 90.7873, + "improvement_m": 659.411, + "final_ratio": 0.121, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4209", + "method": "baseline_mec", + "initial_radius_m": 750.1984, + "q": [ + 527.18, + 607.44 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 750.198, + "worst_posterior_radius_m": 375.1004, + "improvement_m": 375.0979, + "final_ratio": 0.5, + "move_cost_s": 150.0397, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4209", + "method": "reference", + "initial_radius_m": 750.1984, + "q": [ + 527.18, + 857.24 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 901.338, + "worst_posterior_radius_m": 90.7428, + "improvement_m": 659.4555, + "final_ratio": 0.121, + "move_cost_s": 180.2676, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4210", + "method": "optimal", + "initial_radius_m": 706.0314, + "q": [ + -429.24, + 1150.92 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 915.531, + "worst_posterior_radius_m": 63.6889, + "improvement_m": 642.3425, + "final_ratio": 0.0902, + "move_cost_s": 183.1063, + "reason": "安全盘 B(centre,294m) 内 37 候选；粗采样最坏后验 63.7m，1/4 间距加密复核 63.7m" + }, + { + "case_id": "q2-4210", + "method": "baseline_perp", + "initial_radius_m": 706.0314, + "q": [ + -205.52, + 14.54 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1722.001, + "worst_posterior_radius_m": 80.6406, + "improvement_m": 625.3908, + "final_ratio": 0.1142, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4210", + "method": "baseline_mec", + "initial_radius_m": 706.0314, + "q": [ + -145.29, + 1227.01 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 706.031, + "worst_posterior_radius_m": 353.0157, + "improvement_m": 353.0157, + "final_ratio": 0.5, + "move_cost_s": 141.2063, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4210", + "method": "reference", + "initial_radius_m": 706.0314, + "q": [ + -365.76, + 1080.02 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 830.654, + "worst_posterior_radius_m": 72.3965, + "improvement_m": 633.635, + "final_ratio": 0.1025, + "move_cost_s": 166.1307, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4211", + "method": "optimal", + "initial_radius_m": 750.1984, + "q": [ + -618.54, + -442.89 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 901.338, + "worst_posterior_radius_m": 90.7428, + "improvement_m": 659.4555, + "final_ratio": 0.121, + "move_cost_s": 180.2676, + "reason": "安全盘 B(centre,250m) 内 37 候选；粗采样最坏后验 90.7m，1/4 间距加密复核 90.7m" + }, + { + "case_id": "q2-4211", + "method": "baseline_perp", + "initial_radius_m": 750.1984, + "q": [ + -378.66, + 1036.78 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1817.471, + "worst_posterior_radius_m": 90.7921, + "improvement_m": 659.4063, + "final_ratio": 0.121, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4211", + "method": "baseline_mec", + "initial_radius_m": 750.1984, + "q": [ + -553.88, + -201.6 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 750.198, + "worst_posterior_radius_m": 375.1004, + "improvement_m": 375.0979, + "final_ratio": 0.5, + "move_cost_s": 150.0397, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4211", + "method": "reference", + "initial_radius_m": 750.1984, + "q": [ + -553.88, + -451.4 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 943.434, + "worst_posterior_radius_m": 94.7071, + "improvement_m": 655.4913, + "final_ratio": 0.1262, + "move_cost_s": 188.6869, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4212", + "method": "optimal", + "initial_radius_m": 750.1271, + "q": [ + 343.06, + -10.36 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 905.382, + "worst_posterior_radius_m": 90.9008, + "improvement_m": 659.2263, + "final_ratio": 0.1212, + "move_cost_s": 181.0765, + "reason": "安全盘 B(centre,250m) 内 37 候选；粗采样最坏后验 90.9m，1/4 间距加密复核 90.9m" + }, + { + "case_id": "q2-4212", + "method": "baseline_perp", + "initial_radius_m": 750.1271, + "q": [ + 1486.13, + -980.36 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1817.338, + "worst_posterior_radius_m": 90.7777, + "improvement_m": 659.3494, + "final_ratio": 0.121, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4212", + "method": "baseline_mec", + "initial_radius_m": 750.1271, + "q": [ + 519.74, + -187.05 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 750.127, + "worst_posterior_radius_m": 375.0874, + "improvement_m": 375.0397, + "final_ratio": 0.5, + "move_cost_s": 150.0254, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4212", + "method": "reference", + "initial_radius_m": 750.1271, + "q": [ + 519.74, + -436.92 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 845.041, + "worst_posterior_radius_m": 93.6496, + "improvement_m": 656.4775, + "final_ratio": 0.1248, + "move_cost_s": 169.0083, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4213", + "method": "optimal", + "initial_radius_m": 750.1193, + "q": [ + -347.17, + -794.93 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 859.446, + "worst_posterior_radius_m": 92.4362, + "improvement_m": 657.6831, + "final_ratio": 0.1232, + "move_cost_s": 171.8893, + "reason": "安全盘 B(centre,250m) 内 37 候选；粗采样最坏后验 92.4m，1/4 间距加密复核 92.4m" + }, + { + "case_id": "q2-4213", + "method": "baseline_perp", + "initial_radius_m": 750.1193, + "q": [ + -1649.58, + -74.97 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1817.313, + "worst_posterior_radius_m": 90.7749, + "improvement_m": 659.3444, + "final_ratio": 0.121, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4213", + "method": "baseline_mec", + "initial_radius_m": 750.1193, + "q": [ + -523.86, + -618.24 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 750.119, + "worst_posterior_radius_m": 375.0941, + "improvement_m": 375.0252, + "final_ratio": 0.5, + "move_cost_s": 150.0239, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4213", + "method": "reference", + "initial_radius_m": 750.1193, + "q": [ + -523.86, + -368.36 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 893.013, + "worst_posterior_radius_m": 90.8785, + "improvement_m": 659.2408, + "final_ratio": 0.1212, + "move_cost_s": 178.6027, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4214", + "method": "optimal", + "initial_radius_m": 750.1562, + "q": [ + 623.18, + -1142.1 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 906.311, + "worst_posterior_radius_m": 90.8653, + "improvement_m": 659.2909, + "final_ratio": 0.1211, + "move_cost_s": 181.2622, + "reason": "安全盘 B(centre,250m) 内 37 候选；粗采样最坏后验 90.9m，1/4 间距加密复核 90.9m" + }, + { + "case_id": "q2-4214", + "method": "baseline_perp", + "initial_radius_m": 750.1562, + "q": [ + -445.01, + -638.69 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1817.363, + "worst_posterior_radius_m": 90.7804, + "improvement_m": 659.3758, + "final_ratio": 0.121, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4214", + "method": "baseline_mec", + "initial_radius_m": 750.1562, + "q": [ + 558.51, + -1383.43 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 750.156, + "worst_posterior_radius_m": 375.0866, + "improvement_m": 375.0696, + "final_ratio": 0.5, + "move_cost_s": 150.0312, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4214", + "method": "reference", + "initial_radius_m": 750.1562, + "q": [ + 558.51, + -1133.59 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 855.602, + "worst_posterior_radius_m": 92.5807, + "improvement_m": 657.5755, + "final_ratio": 0.1234, + "move_cost_s": 171.1203, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4215", + "method": "optimal", + "initial_radius_m": 559.2726, + "q": [ + -1338.03, + 120.02 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 820.564, + "worst_posterior_radius_m": 35.5642, + "improvement_m": 523.7084, + "final_ratio": 0.0636, + "move_cost_s": 164.1129, + "reason": "安全盘 B(centre,441m) 内 37 候选；粗采样最坏后验 35.6m，1/4 间距加密复核 35.6m" + }, + { + "case_id": "q2-4215", + "method": "baseline_perp", + "initial_radius_m": 559.2726, + "q": [ + -731.29, + -1349.56 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1513.4, + "worst_posterior_radius_m": 59.9571, + "improvement_m": 499.3155, + "final_ratio": 0.1072, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4215", + "method": "baseline_mec", + "initial_radius_m": 559.2726, + "q": [ + -1223.96, + -305.69 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 559.273, + "worst_posterior_radius_m": 279.636, + "improvement_m": 279.6365, + "final_ratio": 0.5, + "move_cost_s": 111.8545, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4215", + "method": "reference", + "initial_radius_m": 559.2726, + "q": [ + -1444.32, + -636.23 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 828.17, + "worst_posterior_radius_m": 35.8572, + "improvement_m": 523.4154, + "final_ratio": 0.0641, + "move_cost_s": 165.6341, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4216", + "method": "optimal", + "initial_radius_m": 725.317, + "q": [ + -757.87, + -1061.54 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 869.875, + "worst_posterior_radius_m": 65.5855, + "improvement_m": 659.7315, + "final_ratio": 0.0904, + "move_cost_s": 173.975, + "reason": "安全盘 B(centre,275m) 内 37 候选；粗采样最坏后验 65.6m，1/4 间距加密复核 65.6m" + }, + { + "case_id": "q2-4216", + "method": "baseline_perp", + "initial_radius_m": 725.317, + "q": [ + -669.31, + 40.15 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1747.413, + "worst_posterior_radius_m": 79.8013, + "improvement_m": 645.5157, + "final_ratio": 0.11, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4216", + "method": "baseline_mec", + "initial_radius_m": 725.317, + "q": [ + -1023.19, + -1132.63 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 725.317, + "worst_posterior_radius_m": 362.6584, + "improvement_m": 362.6586, + "final_ratio": 0.5, + "move_cost_s": 145.0634, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4216", + "method": "reference", + "initial_radius_m": 725.317, + "q": [ + -748.51, + -1132.63 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 919.993, + "worst_posterior_radius_m": 63.6695, + "improvement_m": 661.6475, + "final_ratio": 0.0878, + "move_cost_s": 183.9986, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4217", + "method": "optimal", + "initial_radius_m": 750.1626, + "q": [ + -1472.03, + 727.45 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 848.853, + "worst_posterior_radius_m": 93.1306, + "improvement_m": 657.0319, + "final_ratio": 0.1241, + "move_cost_s": 169.7705, + "reason": "安全盘 B(centre,250m) 内 37 候选；粗采样最坏后验 93.1m，1/4 间距加密复核 93.1m" + }, + { + "case_id": "q2-4217", + "method": "baseline_perp", + "initial_radius_m": 750.1626, + "q": [ + 10.08, + 818.66 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1817.406, + "worst_posterior_radius_m": 90.785, + "improvement_m": 659.3776, + "final_ratio": 0.121, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4217", + "method": "baseline_mec", + "initial_radius_m": 750.1626, + "q": [ + -1230.71, + 662.78 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 750.163, + "worst_posterior_radius_m": 375.088, + "improvement_m": 375.0746, + "final_ratio": 0.5, + "move_cost_s": 150.0325, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4217", + "method": "reference", + "initial_radius_m": 750.1626, + "q": [ + -1480.55, + 662.78 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 900.623, + "worst_posterior_radius_m": 90.7703, + "improvement_m": 659.3922, + "final_ratio": 0.121, + "move_cost_s": 180.1245, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4218", + "method": "optimal", + "initial_radius_m": 750.1767, + "q": [ + -331.52, + -300.05 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 864.093, + "worst_posterior_radius_m": 92.2696, + "improvement_m": 657.907, + "final_ratio": 0.123, + "move_cost_s": 172.8186, + "reason": "安全盘 B(centre,250m) 内 37 候选；粗采样最坏后验 92.3m，1/4 间距加密复核 92.3m" + }, + { + "case_id": "q2-4218", + "method": "baseline_perp", + "initial_radius_m": 750.1767, + "q": [ + -1820.79, + -299.36 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1817.394, + "worst_posterior_radius_m": 90.7837, + "improvement_m": 659.3929, + "final_ratio": 0.121, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4218", + "method": "baseline_mec", + "initial_radius_m": 750.1767, + "q": [ + -572.83, + -235.4 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 750.177, + "worst_posterior_radius_m": 375.0922, + "improvement_m": 375.0845, + "final_ratio": 0.5, + "move_cost_s": 150.0353, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4218", + "method": "reference", + "initial_radius_m": 750.1767, + "q": [ + -323.01, + -235.4 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 913.396, + "worst_posterior_radius_m": 91.4835, + "improvement_m": 658.6932, + "final_ratio": 0.1219, + "move_cost_s": 182.6792, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4219", + "method": "optimal", + "initial_radius_m": 750.1294, + "q": [ + -75.49, + 785.58 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 868.14, + "worst_posterior_radius_m": 91.7592, + "improvement_m": 658.3702, + "final_ratio": 0.1223, + "move_cost_s": 173.628, + "reason": "安全盘 B(centre,250m) 内 37 候选；粗采样最坏后验 91.8m，1/4 间距加密复核 91.8m" + }, + { + "case_id": "q2-4219", + "method": "baseline_perp", + "initial_radius_m": 750.1294, + "q": [ + -100.1, + -705.45 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1817.343, + "worst_posterior_radius_m": 90.7782, + "improvement_m": 659.3512, + "final_ratio": 0.121, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4219", + "method": "baseline_mec", + "initial_radius_m": 750.1294, + "q": [ + -140.16, + 544.22 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 750.129, + "worst_posterior_radius_m": 375.0865, + "improvement_m": 375.0429, + "final_ratio": 0.5, + "move_cost_s": 150.0259, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4219", + "method": "reference", + "initial_radius_m": 750.1294, + "q": [ + -140.16, + 794.09 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 916.749, + "worst_posterior_radius_m": 91.3486, + "improvement_m": 658.7807, + "final_ratio": 0.1218, + "move_cost_s": 183.3498, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4220", + "method": "optimal", + "initial_radius_m": 750.1282, + "q": [ + -141.54, + 236.57 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 865.6, + "worst_posterior_radius_m": 92.0601, + "improvement_m": 658.0681, + "final_ratio": 0.1227, + "move_cost_s": 173.1199, + "reason": "安全盘 B(centre,250m) 内 37 候选；粗采样最坏后验 92.1m，1/4 间距加密复核 92.1m" + }, + { + "case_id": "q2-4220", + "method": "baseline_perp", + "initial_radius_m": 750.1282, + "q": [ + -1191.24, + -183.53 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1817.341, + "worst_posterior_radius_m": 90.7779, + "improvement_m": 659.3503, + "final_ratio": 0.121, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4220", + "method": "baseline_mec", + "initial_radius_m": 750.1282, + "q": [ + 35.14, + 59.89 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 750.128, + "worst_posterior_radius_m": 375.0869, + "improvement_m": 375.0413, + "final_ratio": 0.5, + "move_cost_s": 150.0256, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4220", + "method": "reference", + "initial_radius_m": 750.1282, + "q": [ + 285.01, + 59.89 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 887.395, + "worst_posterior_radius_m": 90.9462, + "improvement_m": 659.182, + "final_ratio": 0.1212, + "move_cost_s": 177.479, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4221", + "method": "optimal", + "initial_radius_m": 750.1227, + "q": [ + 536.85, + -635.91 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 859.177, + "worst_posterior_radius_m": 92.4725, + "improvement_m": 657.6502, + "final_ratio": 0.1233, + "move_cost_s": 171.8353, + "reason": "安全盘 B(centre,250m) 内 37 候选；粗采样最坏后验 92.5m，1/4 间距加密复核 92.5m" + }, + { + "case_id": "q2-4221", + "method": "baseline_perp", + "initial_radius_m": 750.1227, + "q": [ + -232.36, + 637.86 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1817.317, + "worst_posterior_radius_m": 90.7753, + "improvement_m": 659.3473, + "final_ratio": 0.121, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4221", + "method": "baseline_mec", + "initial_radius_m": 750.1227, + "q": [ + 472.18, + -394.55 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 750.123, + "worst_posterior_radius_m": 375.0902, + "improvement_m": 375.0324, + "final_ratio": 0.5, + "move_cost_s": 150.0245, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4221", + "method": "reference", + "initial_radius_m": 750.1227, + "q": [ + 472.18, + -644.43 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 801.14, + "worst_posterior_radius_m": 98.7801, + "improvement_m": 651.3425, + "final_ratio": 0.1317, + "move_cost_s": 160.228, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4222", + "method": "optimal", + "initial_radius_m": 672.8456, + "q": [ + 1339.85, + 149.49 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 896.118, + "worst_posterior_radius_m": 46.6908, + "improvement_m": 626.1547, + "final_ratio": 0.0694, + "move_cost_s": 179.2236, + "reason": "安全盘 B(centre,327m) 内 37 候选；粗采样最坏后验 46.7m，1/4 间距加密复核 46.7m" + }, + { + "case_id": "q2-4222", + "method": "baseline_perp", + "initial_radius_m": 672.8456, + "q": [ + 461.11, + -525.53 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1662.432, + "worst_posterior_radius_m": 70.9473, + "improvement_m": 601.8982, + "final_ratio": 0.1054, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4222", + "method": "baseline_mec", + "initial_radius_m": 672.8456, + "q": [ + 1571.19, + -81.85 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 672.846, + "worst_posterior_radius_m": 336.422, + "improvement_m": 336.4236, + "final_ratio": 0.5, + "move_cost_s": 134.5691, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4222", + "method": "reference", + "initial_radius_m": 672.8456, + "q": [ + 1325.82, + 81.73 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 830.571, + "worst_posterior_radius_m": 53.4171, + "improvement_m": 619.4285, + "final_ratio": 0.0794, + "move_cost_s": 166.1141, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4223", + "method": "optimal", + "initial_radius_m": 395.7032, + "q": [ + -1736.15, + -787.27 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 696.835, + "worst_posterior_radius_m": 21.2216, + "improvement_m": 374.4816, + "final_ratio": 0.0536, + "move_cost_s": 139.367, + "reason": "安全盘 B(centre,604m) 内 37 候选；粗采样最坏后验 21.2m，1/4 间距加密复核 21.2m" + }, + { + "case_id": "q2-4223", + "method": "baseline_perp", + "initial_radius_m": 395.7032, + "q": [ + -1460.77, + -1547.73 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1286.113, + "worst_posterior_radius_m": 39.7243, + "improvement_m": 355.9789, + "final_ratio": 0.1004, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4223", + "method": "baseline_mec", + "initial_radius_m": 395.7032, + "q": [ + -1415.67, + -466.79 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 395.703, + "worst_posterior_radius_m": 197.8516, + "improvement_m": 197.8516, + "final_ratio": 0.5, + "move_cost_s": 79.1406, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4223", + "method": "reference", + "initial_radius_m": 395.7032, + "q": [ + -1415.67, + -13.57 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 716.029, + "worst_posterior_radius_m": 20.8331, + "improvement_m": 374.8701, + "final_ratio": 0.0526, + "move_cost_s": 143.2057, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4224", + "method": "optimal", + "initial_radius_m": 750.1611, + "q": [ + -898.59, + 669.49 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 888.467, + "worst_posterior_radius_m": 90.8686, + "improvement_m": 659.2925, + "final_ratio": 0.1211, + "move_cost_s": 177.6934, + "reason": "安全盘 B(centre,250m) 内 37 候选；粗采样最坏后验 90.9m，1/4 间距加密复核 90.9m" + }, + { + "case_id": "q2-4224", + "method": "baseline_perp", + "initial_radius_m": 750.1611, + "q": [ + 467.47, + 1280.8 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1817.403, + "worst_posterior_radius_m": 90.7847, + "improvement_m": 659.3764, + "final_ratio": 0.121, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4224", + "method": "baseline_mec", + "initial_radius_m": 750.1611, + "q": [ + -657.27, + 734.16 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 750.161, + "worst_posterior_radius_m": 375.0876, + "improvement_m": 375.0735, + "final_ratio": 0.5, + "move_cost_s": 150.0322, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4224", + "method": "reference", + "initial_radius_m": 750.1611, + "q": [ + -907.11, + 734.16 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 834.607, + "worst_posterior_radius_m": 94.497, + "improvement_m": 655.6641, + "final_ratio": 0.126, + "move_cost_s": 166.9213, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4225", + "method": "optimal", + "initial_radius_m": 750.1168, + "q": [ + -305.35, + -293.56 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 866.507, + "worst_posterior_radius_m": 91.9451, + "improvement_m": 658.1717, + "final_ratio": 0.1226, + "move_cost_s": 173.3014, + "reason": "安全盘 B(centre,250m) 内 37 候选；粗采样最坏后验 91.9m，1/4 间距加密复核 91.9m" + }, + { + "case_id": "q2-4225", + "method": "baseline_perp", + "initial_radius_m": 750.1168, + "q": [ + -1063.56, + -1576.77 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1817.311, + "worst_posterior_radius_m": 90.7747, + "improvement_m": 659.3421, + "final_ratio": 0.121, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4225", + "method": "baseline_mec", + "initial_radius_m": 750.1168, + "q": [ + -482.04, + -470.26 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 750.117, + "worst_posterior_radius_m": 375.1002, + "improvement_m": 375.0166, + "final_ratio": 0.5001, + "move_cost_s": 150.0234, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4225", + "method": "reference", + "initial_radius_m": 750.1168, + "q": [ + -731.92, + -470.26 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 886.539, + "worst_posterior_radius_m": 91.0177, + "improvement_m": 659.0991, + "final_ratio": 0.1213, + "move_cost_s": 177.3078, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4226", + "method": "optimal", + "initial_radius_m": 750.116, + "q": [ + 587.47, + 388.64 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 898.378, + "worst_posterior_radius_m": 90.899, + "improvement_m": 659.2169, + "final_ratio": 0.1212, + "move_cost_s": 179.6755, + "reason": "安全盘 B(centre,250m) 内 37 候选；粗采样最坏后验 90.9m，1/4 间距加密复核 90.9m" + }, + { + "case_id": "q2-4226", + "method": "baseline_perp", + "initial_radius_m": 750.116, + "q": [ + 1757.19, + 432.6 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1817.312, + "worst_posterior_radius_m": 90.7749, + "improvement_m": 659.3411, + "final_ratio": 0.121, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4226", + "method": "baseline_mec", + "initial_radius_m": 750.116, + "q": [ + 522.79, + 630.01 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 750.116, + "worst_posterior_radius_m": 375.106, + "improvement_m": 375.01, + "final_ratio": 0.5001, + "move_cost_s": 150.0232, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4226", + "method": "reference", + "initial_radius_m": 750.116, + "q": [ + 522.79, + 380.13 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 941.123, + "worst_posterior_radius_m": 94.4658, + "improvement_m": 655.6502, + "final_ratio": 0.1259, + "move_cost_s": 188.2245, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4227", + "method": "optimal", + "initial_radius_m": 527.9089, + "q": [ + 711.22, + -1627.01 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 843.994, + "worst_posterior_radius_m": 29.9847, + "improvement_m": 497.9242, + "final_ratio": 0.0568, + "move_cost_s": 168.7988, + "reason": "安全盘 B(centre,472m) 内 37 候选；粗采样最坏后验 30.0m，1/4 间距加密复核 30.0m" + }, + { + "case_id": "q2-4227", + "method": "baseline_perp", + "initial_radius_m": 527.9089, + "q": [ + 1503.46, + -1122.31 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1466.898, + "worst_posterior_radius_m": 55.6254, + "improvement_m": 472.2835, + "final_ratio": 0.1054, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4227", + "method": "baseline_mec", + "initial_radius_m": 527.9089, + "q": [ + 377.4, + -1293.19 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 527.909, + "worst_posterior_radius_m": 263.9545, + "improvement_m": 263.9544, + "final_ratio": 0.5, + "move_cost_s": 105.5818, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4227", + "method": "reference", + "initial_radius_m": 527.9089, + "q": [ + -94.69, + -1293.19 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 819.702, + "worst_posterior_radius_m": 30.7397, + "improvement_m": 497.1692, + "final_ratio": 0.0582, + "move_cost_s": 163.9404, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4228", + "method": "optimal", + "initial_radius_m": 750.1159, + "q": [ + -160.37, + 533.87 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 892.387, + "worst_posterior_radius_m": 90.9276, + "improvement_m": 659.1883, + "final_ratio": 0.1212, + "move_cost_s": 178.4773, + "reason": "安全盘 B(centre,250m) 内 37 候选；粗采样最坏后验 90.9m，1/4 间距加密复核 90.9m" + }, + { + "case_id": "q2-4228", + "method": "baseline_perp", + "initial_radius_m": 750.1159, + "q": [ + 19.89, + 2019.95 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1817.312, + "worst_posterior_radius_m": 90.7748, + "improvement_m": 659.3411, + "final_ratio": 0.121, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4228", + "method": "baseline_mec", + "initial_radius_m": 750.1159, + "q": [ + -95.7, + 775.24 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 750.116, + "worst_posterior_radius_m": 375.1074, + "improvement_m": 375.0085, + "final_ratio": 0.5001, + "move_cost_s": 150.0232, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4228", + "method": "reference", + "initial_radius_m": 750.1159, + "q": [ + -95.7, + 525.36 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 936.393, + "worst_posterior_radius_m": 93.5804, + "improvement_m": 656.5355, + "final_ratio": 0.1248, + "move_cost_s": 187.2787, + "reason": "安全盘网格 9×9 取最坏后验最小" + }, + { + "case_id": "q2-4229", + "method": "optimal", + "initial_radius_m": 750.2021, + "q": [ + 454.55, + -882.98 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 876.702, + "worst_posterior_radius_m": 91.3426, + "improvement_m": 658.8594, + "final_ratio": 0.1218, + "move_cost_s": 175.3403, + "reason": "安全盘 B(centre,250m) 内 37 候选；粗采样最坏后验 91.3m，1/4 间距加密复核 91.3m" + }, + { + "case_id": "q2-4229", + "method": "baseline_perp", + "initial_radius_m": 750.2021, + "q": [ + -684.36, + -787.25 + ], + "guaranteed_reception": false, + "guarantee_distance_m": 1817.445, + "worst_posterior_radius_m": 90.7893, + "improvement_m": 659.4127, + "final_ratio": 0.121, + "move_cost_s": 200.0, + "reason": "沿首次示向度法向 1000 m 取 90° 交会点" + }, + { + "case_id": "q2-4229", + "method": "baseline_mec", + "initial_radius_m": 750.2021, + "q": [ + 519.2, + -1124.27 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 750.202, + "worst_posterior_radius_m": 375.1019, + "improvement_m": 375.1001, + "final_ratio": 0.5, + "move_cost_s": 150.0404, + "reason": "取候选集最小包围圆圆心，保证接收但交会角可能最差" + }, + { + "case_id": "q2-4229", + "method": "reference", + "initial_radius_m": 750.2021, + "q": [ + 519.2, + -874.47 + ], + "guaranteed_reception": true, + "guarantee_distance_m": 923.765, + "worst_posterior_radius_m": 91.9054, + "improvement_m": 658.2967, + "final_ratio": 0.1225, + "move_cost_s": 184.7531, + "reason": "安全盘网格 9×9 取最坏后验最小" + } + ], + "aggregate": { + "optimal": { + "cases": 30, + "guaranteed_rate": 1.0, + "worst_posterior_mean_m": 73.8902, + "worst_posterior_median_m": 90.899, + "improvement_mean_m": 607.5768, + "final_ratio_mean": 0.1038, + "move_cost_mean_s": 170.4375 + }, + "baseline_perp": { + "cases": 30, + "guaranteed_rate": 0.0, + "worst_posterior_mean_m": 80.1109, + "worst_posterior_median_m": 90.775, + "improvement_mean_m": 601.3561, + "final_ratio_mean": 0.1163, + "move_cost_mean_s": 200.0 + }, + "baseline_mec": { + "cases": 30, + "guaranteed_rate": 1.0, + "worst_posterior_mean_m": 340.7465, + "worst_posterior_median_m": 375.0876, + "improvement_mean_m": 340.7205, + "final_ratio_mean": 0.5, + "move_cost_mean_s": 136.2934 + }, + "reference": { + "cases": 30, + "guaranteed_rate": 1.0, + "worst_posterior_mean_m": 75.6265, + "worst_posterior_median_m": 91.3486, + "improvement_mean_m": 605.8405, + "final_ratio_mean": 0.1064, + "move_cost_mean_s": 170.277 + }, + "_initial_radius_mean_m": 681.467 + } +} diff --git a/project/results/q2.md b/project/results/q2.md new file mode 100644 index 0000000..cbbaec0 --- /dev/null +++ b/project/results/q2.md @@ -0,0 +1,137 @@ +# 问题二：第二检测点选择对比 + +初始 ρ 为首次示向度候选集 K₁ 的最小包围半径；最坏后验按目标边界采样 × 读数区间端点统一评估。 + +| 算例 | 方法 | 初始 ρ(m) | 第二点 q | 保证接收 | q 到 K₁ 最远(m) | 最坏后验 ρ'(m) | 收缩(m) | 移动(s) | +| --- | --- | --- | --- | --- | --- | --- | --- | --- | +| q2-4200 | optimal | 674.59 | (1257,89) | 是 | 907.09 | 54.45 | 620.13 | 181.42 | +| q2-4200 | baseline_perp | 674.59 | (194,462) | 否 | 1679.16 | 76.22 | 598.36 | 200.00 | +| q2-4200 | baseline_mec | 674.59 | (1173,-226) | 是 | 674.59 | 337.29 | 337.29 | 134.92 | +| q2-4200 | reference | 674.59 | (1173,100) | 是 | 850.11 | 57.70 | 616.89 | 170.02 | +| q2-4201 | optimal | 261.33 | (-1501,-348) | 是 | 461.91 | 13.55 | 247.78 | 92.38 | +| q2-4201 | baseline_perp | 261.33 | (-782,-715) | 否 | 1131.68 | 27.22 | 234.11 | 200.00 | +| q2-4201 | baseline_mec | 261.33 | (-1578,-63) | 是 | 261.33 | 130.67 | 130.67 | 52.27 | +| q2-4201 | reference | 261.33 | (-1393,-432) | 是 | 527.03 | 14.98 | 246.36 | 105.41 | +| q2-4202 | optimal | 591.09 | (-1126,-861) | 是 | 869.01 | 37.92 | 553.17 | 173.80 | +| q2-4202 | baseline_perp | 591.09 | (408,-1235) | 否 | 1561.73 | 64.57 | 526.52 | 200.00 | +| q2-4202 | baseline_mec | 591.09 | (-731,-967) | 是 | 591.09 | 295.54 | 295.54 | 118.22 | +| q2-4202 | reference | 591.09 | (-1038,-865) | 是 | 788.83 | 46.22 | 544.86 | 157.77 | +| q2-4203 | optimal | 326.92 | (1145,-1745) | 是 | 683.58 | 17.13 | 309.79 | 136.72 | +| q2-4203 | baseline_perp | 326.92 | (1837,-1523) | 否 | 1204.35 | 32.99 | 293.93 | 200.00 | +| q2-4203 | baseline_mec | 326.92 | (788,-1388) | 是 | 326.92 | 163.46 | 163.46 | 65.38 | +| q2-4203 | reference | 326.92 | (1125,-1725) | 是 | 657.98 | 16.90 | 310.02 | 131.60 | +| q2-4204 | optimal | 750.20 | (-401,208) | 是 | 876.74 | 91.60 | 658.60 | 175.35 | +| q2-4204 | baseline_perp | 750.20 | (-1541,302) | 否 | 1817.48 | 90.79 | 659.41 | 200.00 | +| q2-4204 | baseline_mec | 750.20 | (-336,-34) | 是 | 750.20 | 375.10 | 375.10 | 150.04 | +| q2-4204 | reference | 750.20 | (-336,216) | 是 | 923.80 | 92.25 | 657.95 | 184.76 | +| q2-4205 | optimal | 750.14 | (-503,21) | 是 | 881.59 | 91.10 | 659.04 | 176.32 | +| q2-4205 | baseline_perp | 750.14 | (-612,-1470) | 否 | 1817.36 | 90.78 | 659.36 | 200.00 | +| q2-4205 | baseline_mec | 750.14 | (-568,-220) | 是 | 750.14 | 375.08 | 375.06 | 150.03 | +| q2-4205 | reference | 750.14 | (-568,30) | 是 | 927.74 | 92.25 | 657.89 | 185.55 | +| q2-4206 | optimal | 750.12 | (216,677) | 是 | 892.00 | 90.96 | 659.16 | 178.40 | +| q2-4206 | baseline_perp | 750.12 | (1592,1266) | 否 | 1817.31 | 90.77 | 659.34 | 200.00 | +| q2-4206 | baseline_mec | 750.12 | (457,742) | 是 | 750.12 | 375.10 | 375.02 | 150.02 | +| q2-4206 | reference | 750.12 | (207,742) | 是 | 838.72 | 94.21 | 655.91 | 167.74 | +| q2-4207 | optimal | 750.12 | (1205,476) | 是 | 899.09 | 90.85 | 659.27 | 179.82 | +| q2-4207 | baseline_perp | 750.12 | (578,1465) | 否 | 1817.31 | 90.78 | 659.34 | 200.00 | +| q2-4207 | baseline_mec | 750.12 | (1028,299) | 是 | 750.12 | 375.09 | 375.03 | 150.02 | +| q2-4207 | reference | 750.12 | (1028,49) | 是 | 852.52 | 92.97 | 657.15 | 170.50 | +| q2-4208 | optimal | 750.19 | (-1409,-294) | 是 | 901.20 | 90.75 | 659.44 | 180.24 | +| q2-4208 | baseline_perp | 750.19 | (-8,239) | 否 | 1817.46 | 90.79 | 659.40 | 200.00 | +| q2-4208 | baseline_mec | 750.19 | (-1167,-229) | 是 | 750.19 | 375.10 | 375.09 | 150.04 | +| q2-4208 | reference | 750.19 | (-1417,-229) | 是 | 849.54 | 93.05 | 657.14 | 169.91 | +| q2-4209 | optimal | 750.20 | (463,849) | 是 | 849.70 | 93.03 | 657.17 | 169.94 | +| q2-4209 | baseline_perp | 750.20 | (-621,1100) | 否 | 1817.43 | 90.79 | 659.41 | 200.00 | +| q2-4209 | baseline_mec | 750.20 | (527,607) | 是 | 750.20 | 375.10 | 375.10 | 150.04 | +| q2-4209 | reference | 750.20 | (527,857) | 是 | 901.34 | 90.74 | 659.46 | 180.27 | +| q2-4210 | optimal | 706.03 | (-429,1151) | 是 | 915.53 | 63.69 | 642.34 | 183.11 | +| q2-4210 | baseline_perp | 706.03 | (-206,15) | 否 | 1722.00 | 80.64 | 625.39 | 200.00 | +| q2-4210 | baseline_mec | 706.03 | (-145,1227) | 是 | 706.03 | 353.02 | 353.02 | 141.21 | +| q2-4210 | reference | 706.03 | (-366,1080) | 是 | 830.65 | 72.40 | 633.63 | 166.13 | +| q2-4211 | optimal | 750.20 | (-619,-443) | 是 | 901.34 | 90.74 | 659.46 | 180.27 | +| q2-4211 | baseline_perp | 750.20 | (-379,1037) | 否 | 1817.47 | 90.79 | 659.41 | 200.00 | +| q2-4211 | baseline_mec | 750.20 | (-554,-202) | 是 | 750.20 | 375.10 | 375.10 | 150.04 | +| q2-4211 | reference | 750.20 | (-554,-451) | 是 | 943.43 | 94.71 | 655.49 | 188.69 | +| q2-4212 | optimal | 750.13 | (343,-10) | 是 | 905.38 | 90.90 | 659.23 | 181.08 | +| q2-4212 | baseline_perp | 750.13 | (1486,-980) | 否 | 1817.34 | 90.78 | 659.35 | 200.00 | +| q2-4212 | baseline_mec | 750.13 | (520,-187) | 是 | 750.13 | 375.09 | 375.04 | 150.03 | +| q2-4212 | reference | 750.13 | (520,-437) | 是 | 845.04 | 93.65 | 656.48 | 169.01 | +| q2-4213 | optimal | 750.12 | (-347,-795) | 是 | 859.45 | 92.44 | 657.68 | 171.89 | +| q2-4213 | baseline_perp | 750.12 | (-1650,-75) | 否 | 1817.31 | 90.77 | 659.34 | 200.00 | +| q2-4213 | baseline_mec | 750.12 | (-524,-618) | 是 | 750.12 | 375.09 | 375.03 | 150.02 | +| q2-4213 | reference | 750.12 | (-524,-368) | 是 | 893.01 | 90.88 | 659.24 | 178.60 | +| q2-4214 | optimal | 750.16 | (623,-1142) | 是 | 906.31 | 90.87 | 659.29 | 181.26 | +| q2-4214 | baseline_perp | 750.16 | (-445,-639) | 否 | 1817.36 | 90.78 | 659.38 | 200.00 | +| q2-4214 | baseline_mec | 750.16 | (559,-1383) | 是 | 750.16 | 375.09 | 375.07 | 150.03 | +| q2-4214 | reference | 750.16 | (559,-1134) | 是 | 855.60 | 92.58 | 657.58 | 171.12 | +| q2-4215 | optimal | 559.27 | (-1338,120) | 是 | 820.56 | 35.56 | 523.71 | 164.11 | +| q2-4215 | baseline_perp | 559.27 | (-731,-1350) | 否 | 1513.40 | 59.96 | 499.32 | 200.00 | +| q2-4215 | baseline_mec | 559.27 | (-1224,-306) | 是 | 559.27 | 279.64 | 279.64 | 111.85 | +| q2-4215 | reference | 559.27 | (-1444,-636) | 是 | 828.17 | 35.86 | 523.42 | 165.63 | +| q2-4216 | optimal | 725.32 | (-758,-1062) | 是 | 869.88 | 65.59 | 659.73 | 173.97 | +| q2-4216 | baseline_perp | 725.32 | (-669,40) | 否 | 1747.41 | 79.80 | 645.52 | 200.00 | +| q2-4216 | baseline_mec | 725.32 | (-1023,-1133) | 是 | 725.32 | 362.66 | 362.66 | 145.06 | +| q2-4216 | reference | 725.32 | (-749,-1133) | 是 | 919.99 | 63.67 | 661.65 | 184.00 | +| q2-4217 | optimal | 750.16 | (-1472,727) | 是 | 848.85 | 93.13 | 657.03 | 169.77 | +| q2-4217 | baseline_perp | 750.16 | (10,819) | 否 | 1817.41 | 90.78 | 659.38 | 200.00 | +| q2-4217 | baseline_mec | 750.16 | (-1231,663) | 是 | 750.16 | 375.09 | 375.07 | 150.03 | +| q2-4217 | reference | 750.16 | (-1481,663) | 是 | 900.62 | 90.77 | 659.39 | 180.12 | +| q2-4218 | optimal | 750.18 | (-332,-300) | 是 | 864.09 | 92.27 | 657.91 | 172.82 | +| q2-4218 | baseline_perp | 750.18 | (-1821,-299) | 否 | 1817.39 | 90.78 | 659.39 | 200.00 | +| q2-4218 | baseline_mec | 750.18 | (-573,-235) | 是 | 750.18 | 375.09 | 375.08 | 150.04 | +| q2-4218 | reference | 750.18 | (-323,-235) | 是 | 913.40 | 91.48 | 658.69 | 182.68 | +| q2-4219 | optimal | 750.13 | (-75,786) | 是 | 868.14 | 91.76 | 658.37 | 173.63 | +| q2-4219 | baseline_perp | 750.13 | (-100,-705) | 否 | 1817.34 | 90.78 | 659.35 | 200.00 | +| q2-4219 | baseline_mec | 750.13 | (-140,544) | 是 | 750.13 | 375.09 | 375.04 | 150.03 | +| q2-4219 | reference | 750.13 | (-140,794) | 是 | 916.75 | 91.35 | 658.78 | 183.35 | +| q2-4220 | optimal | 750.13 | (-142,237) | 是 | 865.60 | 92.06 | 658.07 | 173.12 | +| q2-4220 | baseline_perp | 750.13 | (-1191,-184) | 否 | 1817.34 | 90.78 | 659.35 | 200.00 | +| q2-4220 | baseline_mec | 750.13 | (35,60) | 是 | 750.13 | 375.09 | 375.04 | 150.03 | +| q2-4220 | reference | 750.13 | (285,60) | 是 | 887.39 | 90.95 | 659.18 | 177.48 | +| q2-4221 | optimal | 750.12 | (537,-636) | 是 | 859.18 | 92.47 | 657.65 | 171.84 | +| q2-4221 | baseline_perp | 750.12 | (-232,638) | 否 | 1817.32 | 90.78 | 659.35 | 200.00 | +| q2-4221 | baseline_mec | 750.12 | (472,-395) | 是 | 750.12 | 375.09 | 375.03 | 150.02 | +| q2-4221 | reference | 750.12 | (472,-644) | 是 | 801.14 | 98.78 | 651.34 | 160.23 | +| q2-4222 | optimal | 672.85 | (1340,149) | 是 | 896.12 | 46.69 | 626.15 | 179.22 | +| q2-4222 | baseline_perp | 672.85 | (461,-526) | 否 | 1662.43 | 70.95 | 601.90 | 200.00 | +| q2-4222 | baseline_mec | 672.85 | (1571,-82) | 是 | 672.85 | 336.42 | 336.42 | 134.57 | +| q2-4222 | reference | 672.85 | (1326,82) | 是 | 830.57 | 53.42 | 619.43 | 166.11 | +| q2-4223 | optimal | 395.70 | (-1736,-787) | 是 | 696.84 | 21.22 | 374.48 | 139.37 | +| q2-4223 | baseline_perp | 395.70 | (-1461,-1548) | 否 | 1286.11 | 39.72 | 355.98 | 200.00 | +| q2-4223 | baseline_mec | 395.70 | (-1416,-467) | 是 | 395.70 | 197.85 | 197.85 | 79.14 | +| q2-4223 | reference | 395.70 | (-1416,-14) | 是 | 716.03 | 20.83 | 374.87 | 143.21 | +| q2-4224 | optimal | 750.16 | (-899,669) | 是 | 888.47 | 90.87 | 659.29 | 177.69 | +| q2-4224 | baseline_perp | 750.16 | (467,1281) | 否 | 1817.40 | 90.78 | 659.38 | 200.00 | +| q2-4224 | baseline_mec | 750.16 | (-657,734) | 是 | 750.16 | 375.09 | 375.07 | 150.03 | +| q2-4224 | reference | 750.16 | (-907,734) | 是 | 834.61 | 94.50 | 655.66 | 166.92 | +| q2-4225 | optimal | 750.12 | (-305,-294) | 是 | 866.51 | 91.95 | 658.17 | 173.30 | +| q2-4225 | baseline_perp | 750.12 | (-1064,-1577) | 否 | 1817.31 | 90.77 | 659.34 | 200.00 | +| q2-4225 | baseline_mec | 750.12 | (-482,-470) | 是 | 750.12 | 375.10 | 375.02 | 150.02 | +| q2-4225 | reference | 750.12 | (-732,-470) | 是 | 886.54 | 91.02 | 659.10 | 177.31 | +| q2-4226 | optimal | 750.12 | (587,389) | 是 | 898.38 | 90.90 | 659.22 | 179.68 | +| q2-4226 | baseline_perp | 750.12 | (1757,433) | 否 | 1817.31 | 90.77 | 659.34 | 200.00 | +| q2-4226 | baseline_mec | 750.12 | (523,630) | 是 | 750.12 | 375.11 | 375.01 | 150.02 | +| q2-4226 | reference | 750.12 | (523,380) | 是 | 941.12 | 94.47 | 655.65 | 188.22 | +| q2-4227 | optimal | 527.91 | (711,-1627) | 是 | 843.99 | 29.98 | 497.92 | 168.80 | +| q2-4227 | baseline_perp | 527.91 | (1503,-1122) | 否 | 1466.90 | 55.63 | 472.28 | 200.00 | +| q2-4227 | baseline_mec | 527.91 | (377,-1293) | 是 | 527.91 | 263.95 | 263.95 | 105.58 | +| q2-4227 | reference | 527.91 | (-95,-1293) | 是 | 819.70 | 30.74 | 497.17 | 163.94 | +| q2-4228 | optimal | 750.12 | (-160,534) | 是 | 892.39 | 90.93 | 659.19 | 178.48 | +| q2-4228 | baseline_perp | 750.12 | (20,2020) | 否 | 1817.31 | 90.77 | 659.34 | 200.00 | +| q2-4228 | baseline_mec | 750.12 | (-96,775) | 是 | 750.12 | 375.11 | 375.01 | 150.02 | +| q2-4228 | reference | 750.12 | (-96,525) | 是 | 936.39 | 93.58 | 656.54 | 187.28 | +| q2-4229 | optimal | 750.20 | (455,-883) | 是 | 876.70 | 91.34 | 658.86 | 175.34 | +| q2-4229 | baseline_perp | 750.20 | (-684,-787) | 否 | 1817.44 | 90.79 | 659.41 | 200.00 | +| q2-4229 | baseline_mec | 750.20 | (519,-1124) | 是 | 750.20 | 375.10 | 375.10 | 150.04 | +| q2-4229 | reference | 750.20 | (519,-874) | 是 | 923.76 | 91.91 | 658.30 | 184.75 | + +## 逐方法汇总 + +| 方法 | 保证接收率 | 最坏后验均值(m) | 中位(m) | 平均收缩(m) | 终值比 ρ'/ρ | 移动均值(s) | +| --- | --- | --- | --- | --- | --- | --- | +| optimal | 100.0% | 73.89 | 90.90 | 607.58 | 0.104 | 170.44 | +| baseline_perp | 0.0% | 80.11 | 90.78 | 601.36 | 0.116 | 200.00 | +| baseline_mec | 100.0% | 340.75 | 375.09 | 340.72 | 0.500 | 136.29 | +| reference | 100.0% | 75.63 | 91.35 | 605.84 | 0.106 | 170.28 | + +初始 ρ 均值：681.47 m diff --git a/project/results/q3.json b/project/results/q3.json new file mode 100644 index 0000000..244465d --- /dev/null +++ b/project/results/q3.json @@ -0,0 +1,1712 @@ +{ + "question": 3, + "suite": "core", + "scenes": [ + { + "scene_id": "q3-core-s100-n10", + "problem": 3, + "kind": "random", + "seed": 100, + "error_seed": 20261010, + "count": 10, + "directional": 0 + }, + { + "scene_id": "q3-core-s100-n13", + "problem": 3, + "kind": "random", + "seed": 100, + "error_seed": 20261010, + "count": 13, + "directional": 0 + }, + { + "scene_id": "q3-core-s100-n16", + "problem": 3, + "kind": "random", + "seed": 100, + "error_seed": 20261010, + "count": 16, + "directional": 0 + }, + { + "scene_id": "q3-core-s101-n10", + "problem": 3, + "kind": "random", + "seed": 101, + "error_seed": 20261011, + "count": 10, + "directional": 0 + }, + { + "scene_id": "q3-core-s101-n13", + "problem": 3, + "kind": "random", + "seed": 101, + "error_seed": 20261011, + "count": 13, + "directional": 0 + }, + { + "scene_id": "q3-core-s101-n16", + "problem": 3, + "kind": "random", + "seed": 101, + "error_seed": 20261011, + "count": 16, + "directional": 0 + }, + { + "scene_id": "q3-core-s102-n10", + "problem": 3, + "kind": "random", + "seed": 102, + "error_seed": 20261012, + "count": 10, + "directional": 0 + }, + { + "scene_id": "q3-core-s102-n13", + "problem": 3, + "kind": "random", + "seed": 102, + "error_seed": 20261012, + "count": 13, + "directional": 0 + }, + { + "scene_id": "q3-core-s102-n16", + "problem": 3, + "kind": "random", + "seed": 102, + "error_seed": 20261012, + "count": 16, + "directional": 0 + }, + { + "scene_id": "q3-core-s103-n10", + "problem": 3, + "kind": "random", + "seed": 103, + "error_seed": 20261013, + "count": 10, + "directional": 0 + }, + { + "scene_id": "q3-core-s103-n13", + "problem": 3, + "kind": "random", + "seed": 103, + "error_seed": 20261013, + "count": 13, + "directional": 0 + }, + { + "scene_id": "q3-core-s103-n16", + "problem": 3, + "kind": "random", + "seed": 103, + "error_seed": 20261013, + "count": 16, + "directional": 0 + }, + { + "scene_id": "q3-core-s104-n10", + "problem": 3, + "kind": "random", + "seed": 104, + "error_seed": 20261014, + "count": 10, + "directional": 0 + }, + { + "scene_id": "q3-core-s104-n13", + "problem": 3, + "kind": "random", + "seed": 104, + "error_seed": 20261014, + "count": 13, + "directional": 0 + }, + { + "scene_id": "q3-core-s104-n16", + "problem": 3, + "kind": "random", + "seed": 104, + "error_seed": 20261014, + "count": 16, + "directional": 0 + }, + { + "scene_id": "q3-core-s105-n10", + "problem": 3, + "kind": "random", + "seed": 105, + "error_seed": 20261015, + "count": 10, + "directional": 0 + }, + { + "scene_id": "q3-core-s105-n13", + "problem": 3, + "kind": "random", + "seed": 105, + "error_seed": 20261015, + "count": 13, + "directional": 0 + }, + { + "scene_id": "q3-core-s105-n16", + "problem": 3, + "kind": "random", + "seed": 105, + "error_seed": 20261015, + "count": 16, + "directional": 0 + } + ], + "variants": [ + { + "label": "optimal", + "class": "build_loop" + }, + { + "label": "seven", + "class": "build_seven" + }, + { + "label": "baseline", + "class": "build_grid" + } + ], + "config": { + "persistent_search": false, + "bearing_rounding_margin_deg": 0.005, + "q4_coverage_plan": "q4_mincover_v2" + }, + "rows": [ + { + "scene_id": "q3-core-s100-n10", + "problem": 3, + "kind": "random", + "sources": 10, + "directional": 0, + "cleared": 10, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 2563.017, + "accounted_virtual_time_s": 2563.017, + "measures": 109, + "clears": 10, + "clear_success": 10, + "total_requests": 119, + "move_distance_m": 9330.1, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 0.704, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q3-core-s100-n10", + "problem": 3, + "kind": "random", + "sources": 10, + "directional": 0, + "cleared": 10, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 4465.513, + "accounted_virtual_time_s": 4465.513, + "measures": 102, + "clears": 10, + "clear_success": 10, + "total_requests": 112, + "move_distance_m": 19057.6, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.182, + "valid": true, + "variant": "seven" + }, + { + "scene_id": "q3-core-s100-n10", + "problem": 3, + "kind": "random", + "sources": 10, + "directional": 0, + "cleared": 10, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 15309.574, + "accounted_virtual_time_s": 15309.574, + "measures": 564, + "clears": 10, + "clear_success": 10, + "total_requests": 574, + "move_distance_m": 59457.9, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.156, + "valid": true, + "variant": "baseline" + }, + { + "scene_id": "q3-core-s100-n13", + "problem": 3, + "kind": "random", + "sources": 13, + "directional": 0, + "cleared": 13, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 3120.813, + "accounted_virtual_time_s": 3120.813, + "measures": 114, + "clears": 13, + "clear_success": 13, + "total_requests": 127, + "move_distance_m": 11914.1, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 0.734, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q3-core-s100-n13", + "problem": 3, + "kind": "random", + "sources": 13, + "directional": 0, + "cleared": 13, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 5215.953, + "accounted_virtual_time_s": 5215.953, + "measures": 96, + "clears": 13, + "clear_success": 13, + "total_requests": 109, + "move_distance_m": 22919.8, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.395, + "valid": true, + "variant": "seven" + }, + { + "scene_id": "q3-core-s100-n13", + "problem": 3, + "kind": "random", + "sources": 13, + "directional": 0, + "cleared": 13, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 16205.316, + "accounted_virtual_time_s": 16205.316, + "measures": 450, + "clears": 13, + "clear_success": 13, + "total_requests": 463, + "move_distance_m": 67311.6, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.455, + "valid": true, + "variant": "baseline" + }, + { + "scene_id": "q3-core-s100-n16", + "problem": 3, + "kind": "random", + "sources": 16, + "directional": 0, + "cleared": 16, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 3618.083, + "accounted_virtual_time_s": null, + "measures": 113, + "clears": 16, + "clear_success": 16, + "total_requests": 129, + "move_distance_m": 14355.4, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "sixteen_cleared", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 0.886, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q3-core-s100-n16", + "problem": 3, + "kind": "random", + "sources": 16, + "directional": 0, + "cleared": 16, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 5978.757, + "accounted_virtual_time_s": null, + "measures": 96, + "clears": 16, + "clear_success": 16, + "total_requests": 112, + "move_distance_m": 26653.8, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "sixteen_cleared", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.658, + "valid": true, + "variant": "seven" + }, + { + "scene_id": "q3-core-s100-n16", + "problem": 3, + "kind": "random", + "sources": 16, + "directional": 0, + "cleared": 16, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 13180.379, + "accounted_virtual_time_s": null, + "measures": 254, + "clears": 16, + "clear_success": 16, + "total_requests": 270, + "move_distance_m": 58011.9, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "sixteen_cleared", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.854, + "valid": true, + "variant": "baseline" + }, + { + "scene_id": "q3-core-s101-n10", + "problem": 3, + "kind": "random", + "sources": 10, + "directional": 0, + "cleared": 10, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 3101.698, + "accounted_virtual_time_s": 3101.698, + "measures": 119, + "clears": 10, + "clear_success": 10, + "total_requests": 129, + "move_distance_m": 11723.5, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 0.686, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q3-core-s101-n10", + "problem": 3, + "kind": "random", + "sources": 10, + "directional": 0, + "cleared": 10, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 4498.119, + "accounted_virtual_time_s": 4498.119, + "measures": 107, + "clears": 10, + "clear_success": 10, + "total_requests": 117, + "move_distance_m": 19065.6, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.108, + "valid": true, + "variant": "seven" + }, + { + "scene_id": "q3-core-s101-n10", + "problem": 3, + "kind": "random", + "sources": 10, + "directional": 0, + "cleared": 10, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 15552.789, + "accounted_virtual_time_s": 15552.789, + "measures": 545, + "clears": 10, + "clear_success": 10, + "total_requests": 555, + "move_distance_m": 61248.9, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.148, + "valid": true, + "variant": "baseline" + }, + { + "scene_id": "q3-core-s101-n13", + "problem": 3, + "kind": "random", + "sources": 13, + "directional": 0, + "cleared": 13, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 2943.279, + "accounted_virtual_time_s": 2943.279, + "measures": 112, + "clears": 13, + "clear_success": 13, + "total_requests": 125, + "move_distance_m": 11106.4, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 0.849, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q3-core-s101-n13", + "problem": 3, + "kind": "random", + "sources": 13, + "directional": 0, + "cleared": 13, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 5390.286, + "accounted_virtual_time_s": 5390.286, + "measures": 101, + "clears": 13, + "clear_success": 13, + "total_requests": 114, + "move_distance_m": 23656.4, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.432, + "valid": true, + "variant": "seven" + }, + { + "scene_id": "q3-core-s101-n13", + "problem": 3, + "kind": "random", + "sources": 13, + "directional": 0, + "cleared": 13, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 16620.614, + "accounted_virtual_time_s": 16620.614, + "measures": 452, + "clears": 13, + "clear_success": 13, + "total_requests": 465, + "move_distance_m": 69338.1, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.602, + "valid": true, + "variant": "baseline" + }, + { + "scene_id": "q3-core-s101-n16", + "problem": 3, + "kind": "random", + "sources": 16, + "directional": 0, + "cleared": 16, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 3559.975, + "accounted_virtual_time_s": null, + "measures": 99, + "clears": 16, + "clear_success": 16, + "total_requests": 115, + "move_distance_m": 14469.9, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "sixteen_cleared", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 0.814, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q3-core-s101-n16", + "problem": 3, + "kind": "random", + "sources": 16, + "directional": 0, + "cleared": 16, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 6462.351, + "accounted_virtual_time_s": null, + "measures": 92, + "clears": 16, + "clear_success": 16, + "total_requests": 108, + "move_distance_m": 29211.8, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "sixteen_cleared", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.76, + "valid": true, + "variant": "seven" + }, + { + "scene_id": "q3-core-s101-n16", + "problem": 3, + "kind": "random", + "sources": 16, + "directional": 0, + "cleared": 16, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 13434.351, + "accounted_virtual_time_s": null, + "measures": 260, + "clears": 16, + "clear_success": 16, + "total_requests": 276, + "move_distance_m": 59121.8, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "sixteen_cleared", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.955, + "valid": true, + "variant": "baseline" + }, + { + "scene_id": "q3-core-s102-n10", + "problem": 3, + "kind": "random", + "sources": 10, + "directional": 0, + "cleared": 10, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 2915.962, + "accounted_virtual_time_s": 2915.962, + "measures": 125, + "clears": 10, + "clear_success": 10, + "total_requests": 135, + "move_distance_m": 10634.8, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 0.585, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q3-core-s102-n10", + "problem": 3, + "kind": "random", + "sources": 10, + "directional": 0, + "cleared": 10, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 5411.314, + "accounted_virtual_time_s": 5411.314, + "measures": 118, + "clears": 10, + "clear_success": 10, + "total_requests": 128, + "move_distance_m": 23326.6, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.277, + "valid": true, + "variant": "seven" + }, + { + "scene_id": "q3-core-s102-n10", + "problem": 3, + "kind": "random", + "sources": 10, + "directional": 0, + "cleared": 10, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 15015.506, + "accounted_virtual_time_s": 15015.506, + "measures": 613, + "clears": 10, + "clear_success": 10, + "total_requests": 623, + "move_distance_m": 56517.5, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.285, + "valid": true, + "variant": "baseline" + }, + { + "scene_id": "q3-core-s102-n13", + "problem": 3, + "kind": "random", + "sources": 13, + "directional": 0, + "cleared": 13, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 3039.465, + "accounted_virtual_time_s": 3039.465, + "measures": 122, + "clears": 13, + "clear_success": 13, + "total_requests": 135, + "move_distance_m": 11242.3, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 0.842, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q3-core-s102-n13", + "problem": 3, + "kind": "random", + "sources": 13, + "directional": 0, + "cleared": 13, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 5209.454, + "accounted_virtual_time_s": 5209.454, + "measures": 112, + "clears": 13, + "clear_success": 13, + "total_requests": 125, + "move_distance_m": 22407.3, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.521, + "valid": true, + "variant": "seven" + }, + { + "scene_id": "q3-core-s102-n13", + "problem": 3, + "kind": "random", + "sources": 13, + "directional": 0, + "cleared": 13, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 16062.769, + "accounted_virtual_time_s": 16062.769, + "measures": 450, + "clears": 13, + "clear_success": 13, + "total_requests": 463, + "move_distance_m": 66603.8, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.543, + "valid": true, + "variant": "baseline" + }, + { + "scene_id": "q3-core-s102-n16", + "problem": 3, + "kind": "random", + "sources": 16, + "directional": 0, + "cleared": 16, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 3266.217, + "accounted_virtual_time_s": null, + "measures": 119, + "clears": 16, + "clear_success": 16, + "total_requests": 135, + "move_distance_m": 12441.1, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "sixteen_cleared", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 0.744, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q3-core-s102-n16", + "problem": 3, + "kind": "random", + "sources": 16, + "directional": 0, + "cleared": 16, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 5549.93, + "accounted_virtual_time_s": null, + "measures": 97, + "clears": 16, + "clear_success": 16, + "total_requests": 113, + "move_distance_m": 24489.6, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "sixteen_cleared", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.648, + "valid": true, + "variant": "seven" + }, + { + "scene_id": "q3-core-s102-n16", + "problem": 3, + "kind": "random", + "sources": 16, + "directional": 0, + "cleared": 16, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 13146.425, + "accounted_virtual_time_s": null, + "measures": 282, + "clears": 16, + "clear_success": 16, + "total_requests": 298, + "move_distance_m": 57012.1, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "sixteen_cleared", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.71, + "valid": true, + "variant": "baseline" + }, + { + "scene_id": "q3-core-s103-n10", + "problem": 3, + "kind": "random", + "sources": 10, + "directional": 0, + "cleared": 10, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 2847.812, + "accounted_virtual_time_s": 2847.812, + "measures": 112, + "clears": 10, + "clear_success": 10, + "total_requests": 122, + "move_distance_m": 10684.1, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 0.675, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q3-core-s103-n10", + "problem": 3, + "kind": "random", + "sources": 10, + "directional": 0, + "cleared": 10, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 4877.277, + "accounted_virtual_time_s": 4877.277, + "measures": 110, + "clears": 10, + "clear_success": 10, + "total_requests": 120, + "move_distance_m": 20886.4, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.217, + "valid": true, + "variant": "seven" + }, + { + "scene_id": "q3-core-s103-n10", + "problem": 3, + "kind": "random", + "sources": 10, + "directional": 0, + "cleared": 10, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 14895.178, + "accounted_virtual_time_s": 14895.178, + "measures": 550, + "clears": 10, + "clear_success": 10, + "total_requests": 560, + "move_distance_m": 57815.9, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.269, + "valid": true, + "variant": "baseline" + }, + { + "scene_id": "q3-core-s103-n13", + "problem": 3, + "kind": "random", + "sources": 13, + "directional": 0, + "cleared": 13, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 3339.878, + "accounted_virtual_time_s": 3339.878, + "measures": 114, + "clears": 13, + "clear_success": 13, + "total_requests": 127, + "move_distance_m": 13024.4, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 0.713, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q3-core-s103-n13", + "problem": 3, + "kind": "random", + "sources": 13, + "directional": 0, + "cleared": 13, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 5344.623, + "accounted_virtual_time_s": 5344.623, + "measures": 102, + "clears": 13, + "clear_success": 13, + "total_requests": 115, + "move_distance_m": 23373.1, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.259, + "valid": true, + "variant": "seven" + }, + { + "scene_id": "q3-core-s103-n13", + "problem": 3, + "kind": "random", + "sources": 13, + "directional": 0, + "cleared": 13, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 16691.406, + "accounted_virtual_time_s": 16691.406, + "measures": 501, + "clears": 13, + "clear_success": 13, + "total_requests": 514, + "move_distance_m": 68212.0, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.557, + "valid": true, + "variant": "baseline" + }, + { + "scene_id": "q3-core-s103-n16", + "problem": 3, + "kind": "random", + "sources": 16, + "directional": 0, + "cleared": 16, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 3378.847, + "accounted_virtual_time_s": null, + "measures": 99, + "clears": 16, + "clear_success": 16, + "total_requests": 115, + "move_distance_m": 13559.2, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "sixteen_cleared", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 0.887, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q3-core-s103-n16", + "problem": 3, + "kind": "random", + "sources": 16, + "directional": 0, + "cleared": 16, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 5526.362, + "accounted_virtual_time_s": null, + "measures": 87, + "clears": 16, + "clear_success": 16, + "total_requests": 103, + "move_distance_m": 24681.8, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "sixteen_cleared", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.77, + "valid": true, + "variant": "seven" + }, + { + "scene_id": "q3-core-s103-n16", + "problem": 3, + "kind": "random", + "sources": 16, + "directional": 0, + "cleared": 16, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 12627.793, + "accounted_virtual_time_s": null, + "measures": 256, + "clears": 16, + "clear_success": 16, + "total_requests": 272, + "move_distance_m": 55189.0, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "sixteen_cleared", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.832, + "valid": true, + "variant": "baseline" + }, + { + "scene_id": "q3-core-s104-n10", + "problem": 3, + "kind": "random", + "sources": 10, + "directional": 0, + "cleared": 10, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 3317.031, + "accounted_virtual_time_s": 3317.031, + "measures": 115, + "clears": 10, + "clear_success": 10, + "total_requests": 125, + "move_distance_m": 12950.2, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 0.662, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q3-core-s104-n10", + "problem": 3, + "kind": "random", + "sources": 10, + "directional": 0, + "cleared": 10, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 4915.856, + "accounted_virtual_time_s": 4915.856, + "measures": 105, + "clears": 10, + "clear_success": 10, + "total_requests": 115, + "move_distance_m": 21219.3, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.064, + "valid": true, + "variant": "seven" + }, + { + "scene_id": "q3-core-s104-n10", + "problem": 3, + "kind": "random", + "sources": 10, + "directional": 0, + "cleared": 10, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 15302.44, + "accounted_virtual_time_s": 15302.44, + "measures": 549, + "clears": 10, + "clear_success": 10, + "total_requests": 559, + "move_distance_m": 59887.2, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.19, + "valid": true, + "variant": "baseline" + }, + { + "scene_id": "q3-core-s104-n13", + "problem": 3, + "kind": "random", + "sources": 13, + "directional": 0, + "cleared": 13, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 3085.239, + "accounted_virtual_time_s": 3085.239, + "measures": 99, + "clears": 13, + "clear_success": 13, + "total_requests": 112, + "move_distance_m": 12176.2, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 0.752, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q3-core-s104-n13", + "problem": 3, + "kind": "random", + "sources": 13, + "directional": 0, + "cleared": 13, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 5437.547, + "accounted_virtual_time_s": 5437.547, + "measures": 97, + "clears": 13, + "clear_success": 13, + "total_requests": 110, + "move_distance_m": 24012.7, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.478, + "valid": true, + "variant": "seven" + }, + { + "scene_id": "q3-core-s104-n13", + "problem": 3, + "kind": "random", + "sources": 13, + "directional": 0, + "cleared": 13, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 16278.692, + "accounted_virtual_time_s": 16278.692, + "measures": 444, + "clears": 13, + "clear_success": 13, + "total_requests": 457, + "move_distance_m": 67868.5, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.559, + "valid": true, + "variant": "baseline" + }, + { + "scene_id": "q3-core-s104-n16", + "problem": 3, + "kind": "random", + "sources": 16, + "directional": 0, + "cleared": 16, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 3057.813, + "accounted_virtual_time_s": null, + "measures": 85, + "clears": 16, + "clear_success": 16, + "total_requests": 101, + "move_distance_m": 12379.1, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "sixteen_cleared", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 0.771, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q3-core-s104-n16", + "problem": 3, + "kind": "random", + "sources": 16, + "directional": 0, + "cleared": 16, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 5340.95, + "accounted_virtual_time_s": null, + "measures": 85, + "clears": 16, + "clear_success": 16, + "total_requests": 101, + "move_distance_m": 23799.8, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "sixteen_cleared", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.679, + "valid": true, + "variant": "seven" + }, + { + "scene_id": "q3-core-s104-n16", + "problem": 3, + "kind": "random", + "sources": 16, + "directional": 0, + "cleared": 16, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 12872.597, + "accounted_virtual_time_s": null, + "measures": 224, + "clears": 16, + "clear_success": 16, + "total_requests": 240, + "move_distance_m": 57378.0, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "sixteen_cleared", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 2.002, + "valid": true, + "variant": "baseline" + }, + { + "scene_id": "q3-core-s105-n10", + "problem": 3, + "kind": "random", + "sources": 10, + "directional": 0, + "cleared": 10, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 2933.088, + "accounted_virtual_time_s": 2933.088, + "measures": 108, + "clears": 10, + "clear_success": 10, + "total_requests": 118, + "move_distance_m": 11220.4, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 0.721, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q3-core-s105-n10", + "problem": 3, + "kind": "random", + "sources": 10, + "directional": 0, + "cleared": 10, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 4370.787, + "accounted_virtual_time_s": 4370.787, + "measures": 107, + "clears": 10, + "clear_success": 10, + "total_requests": 117, + "move_distance_m": 18433.9, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.078, + "valid": true, + "variant": "seven" + }, + { + "scene_id": "q3-core-s105-n10", + "problem": 3, + "kind": "random", + "sources": 10, + "directional": 0, + "cleared": 10, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 15247.673, + "accounted_virtual_time_s": 15247.673, + "measures": 579, + "clears": 10, + "clear_success": 10, + "total_requests": 589, + "move_distance_m": 58688.4, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.172, + "valid": true, + "variant": "baseline" + }, + { + "scene_id": "q3-core-s105-n13", + "problem": 3, + "kind": "random", + "sources": 13, + "directional": 0, + "cleared": 13, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 3645.289, + "accounted_virtual_time_s": 3645.289, + "measures": 122, + "clears": 13, + "clear_success": 13, + "total_requests": 135, + "move_distance_m": 14331.4, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 0.964, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q3-core-s105-n13", + "problem": 3, + "kind": "random", + "sources": 13, + "directional": 0, + "cleared": 13, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 6311.296, + "accounted_virtual_time_s": 6311.296, + "measures": 104, + "clears": 13, + "clear_success": 13, + "total_requests": 117, + "move_distance_m": 28171.5, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.657, + "valid": true, + "variant": "seven" + }, + { + "scene_id": "q3-core-s105-n13", + "problem": 3, + "kind": "random", + "sources": 13, + "directional": 0, + "cleared": 13, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 16509.351, + "accounted_virtual_time_s": 16509.351, + "measures": 485, + "clears": 13, + "clear_success": 13, + "total_requests": 498, + "move_distance_m": 67791.8, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.525, + "valid": true, + "variant": "baseline" + }, + { + "scene_id": "q3-core-s105-n16", + "problem": 3, + "kind": "random", + "sources": 16, + "directional": 0, + "cleared": 16, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 3663.707, + "accounted_virtual_time_s": null, + "measures": 114, + "clears": 16, + "clear_success": 16, + "total_requests": 130, + "move_distance_m": 14543.5, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "sixteen_cleared", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 0.815, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q3-core-s105-n16", + "problem": 3, + "kind": "random", + "sources": 16, + "directional": 0, + "cleared": 16, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 6204.343, + "accounted_virtual_time_s": null, + "measures": 97, + "clears": 16, + "clear_success": 16, + "total_requests": 113, + "move_distance_m": 27776.7, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "sixteen_cleared", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.546, + "valid": true, + "variant": "seven" + }, + { + "scene_id": "q3-core-s105-n16", + "problem": 3, + "kind": "random", + "sources": 16, + "directional": 0, + "cleared": 16, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 13889.015, + "accounted_virtual_time_s": null, + "measures": 292, + "clears": 16, + "clear_success": 16, + "total_requests": 308, + "move_distance_m": 60450.1, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "sixteen_cleared", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.937, + "valid": true, + "variant": "baseline" + } + ], + "aggregate": { + "variants": { + "optimal": { + "episodes": 18, + "valid_episodes": 18, + "cleared_ratio_mean": 1.0, + "cleared_matches_truth": 18, + "absent_misjudged_total": 0, + "virtual_time_mean_s": 3188.7341, + "virtual_time_median_s": 3111.2555, + "virtual_time_max_s": 3663.707, + "measures_mean": 111.1111, + "total_requests_mean": 124.1111, + "move_distance_mean_m": 12338.1167, + "fallback_clear_attempts_mean": 0.0, + "compute_wall_mean_s": 0.7669 + }, + "seven": { + "episodes": 18, + "valid_episodes": 18, + "cleared_ratio_mean": 1.0, + "cleared_matches_truth": 18, + "absent_misjudged_total": 0, + "virtual_time_mean_s": 5361.7066, + "virtual_time_median_s": 5367.4545, + "virtual_time_max_s": 6462.351, + "measures_mean": 100.8333, + "total_requests_mean": 113.8333, + "move_distance_mean_m": 23507.9833, + "fallback_clear_attempts_mean": 0.0, + "compute_wall_mean_s": 1.4294 + }, + "baseline": { + "episodes": 18, + "valid_episodes": 18, + "cleared_ratio_mean": 1.0, + "cleared_matches_truth": 18, + "absent_misjudged_total": 0, + "virtual_time_mean_s": 14935.6593, + "virtual_time_median_s": 15275.0565, + "virtual_time_max_s": 16691.406, + "measures_mean": 430.5556, + "total_requests_mean": 443.5556, + "move_distance_mean_m": 61550.25, + "fallback_clear_attempts_mean": 0.0, + "compute_wall_mean_s": 1.5417 + } + }, + "paired": { + "optimal_vs_baseline": { + "mean_relative_change": -0.784, + "median_relative_change": -0.8003, + "faster_scenes": 18, + "compared": 18, + "both_valid_scenes": 18 + }, + "seven_vs_baseline": { + "mean_relative_change": -0.6367, + "median_relative_change": -0.6693, + "faster_scenes": 18, + "compared": 18, + "both_valid_scenes": 18 + } + } + } +} diff --git a/project/results/q3.md b/project/results/q3.md new file mode 100644 index 0000000..5159d6c --- /dev/null +++ b/project/results/q3.md @@ -0,0 +1,75 @@ +# 问题三：全向闭环配对对比（core 基准集） + +## 逐场景明细 + +| scene | sources | variant | cleared | T(s) | 检测 | 请求 | 位移(m) | 后备清除 | 墙钟(s) | 有效 | +| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | +| q3-core-s100-n10 | 10 | optimal | 10/10 | 2563.0 | 109 | 119 | 9330.1 | 0 | 0.70 | ✔ | +| q3-core-s100-n10 | 10 | seven | 10/10 | 4465.5 | 102 | 112 | 19057.6 | 0 | 1.18 | ✔ | +| q3-core-s100-n10 | 10 | baseline | 10/10 | 15309.6 | 564 | 574 | 59457.9 | 0 | 1.16 | ✔ | +| q3-core-s100-n13 | 13 | optimal | 13/13 | 3120.8 | 114 | 127 | 11914.1 | 0 | 0.73 | ✔ | +| q3-core-s100-n13 | 13 | seven | 13/13 | 5216.0 | 96 | 109 | 22919.8 | 0 | 1.40 | ✔ | +| q3-core-s100-n13 | 13 | baseline | 13/13 | 16205.3 | 450 | 463 | 67311.6 | 0 | 1.46 | ✔ | +| q3-core-s100-n16 | 16 | optimal | 16/16 | 3618.1 | 113 | 129 | 14355.4 | 0 | 0.89 | ✔ | +| q3-core-s100-n16 | 16 | seven | 16/16 | 5978.8 | 96 | 112 | 26653.8 | 0 | 1.66 | ✔ | +| q3-core-s100-n16 | 16 | baseline | 16/16 | 13180.4 | 254 | 270 | 58011.9 | 0 | 1.85 | ✔ | +| q3-core-s101-n10 | 10 | optimal | 10/10 | 3101.7 | 119 | 129 | 11723.5 | 0 | 0.69 | ✔ | +| q3-core-s101-n10 | 10 | seven | 10/10 | 4498.1 | 107 | 117 | 19065.6 | 0 | 1.11 | ✔ | +| q3-core-s101-n10 | 10 | baseline | 10/10 | 15552.8 | 545 | 555 | 61248.9 | 0 | 1.15 | ✔ | +| q3-core-s101-n13 | 13 | optimal | 13/13 | 2943.3 | 112 | 125 | 11106.4 | 0 | 0.85 | ✔ | +| q3-core-s101-n13 | 13 | seven | 13/13 | 5390.3 | 101 | 114 | 23656.4 | 0 | 1.43 | ✔ | +| q3-core-s101-n13 | 13 | baseline | 13/13 | 16620.6 | 452 | 465 | 69338.1 | 0 | 1.60 | ✔ | +| q3-core-s101-n16 | 16 | optimal | 16/16 | 3560.0 | 99 | 115 | 14469.9 | 0 | 0.81 | ✔ | +| q3-core-s101-n16 | 16 | seven | 16/16 | 6462.4 | 92 | 108 | 29211.8 | 0 | 1.76 | ✔ | +| q3-core-s101-n16 | 16 | baseline | 16/16 | 13434.4 | 260 | 276 | 59121.8 | 0 | 1.96 | ✔ | +| q3-core-s102-n10 | 10 | optimal | 10/10 | 2916.0 | 125 | 135 | 10634.8 | 0 | 0.58 | ✔ | +| q3-core-s102-n10 | 10 | seven | 10/10 | 5411.3 | 118 | 128 | 23326.6 | 0 | 1.28 | ✔ | +| q3-core-s102-n10 | 10 | baseline | 10/10 | 15015.5 | 613 | 623 | 56517.5 | 0 | 1.28 | ✔ | +| q3-core-s102-n13 | 13 | optimal | 13/13 | 3039.5 | 122 | 135 | 11242.3 | 0 | 0.84 | ✔ | +| q3-core-s102-n13 | 13 | seven | 13/13 | 5209.5 | 112 | 125 | 22407.3 | 0 | 1.52 | ✔ | +| q3-core-s102-n13 | 13 | baseline | 13/13 | 16062.8 | 450 | 463 | 66603.8 | 0 | 1.54 | ✔ | +| q3-core-s102-n16 | 16 | optimal | 16/16 | 3266.2 | 119 | 135 | 12441.1 | 0 | 0.74 | ✔ | +| q3-core-s102-n16 | 16 | seven | 16/16 | 5549.9 | 97 | 113 | 24489.6 | 0 | 1.65 | ✔ | +| q3-core-s102-n16 | 16 | baseline | 16/16 | 13146.4 | 282 | 298 | 57012.1 | 0 | 1.71 | ✔ | +| q3-core-s103-n10 | 10 | optimal | 10/10 | 2847.8 | 112 | 122 | 10684.1 | 0 | 0.68 | ✔ | +| q3-core-s103-n10 | 10 | seven | 10/10 | 4877.3 | 110 | 120 | 20886.4 | 0 | 1.22 | ✔ | +| q3-core-s103-n10 | 10 | baseline | 10/10 | 14895.2 | 550 | 560 | 57815.9 | 0 | 1.27 | ✔ | +| q3-core-s103-n13 | 13 | optimal | 13/13 | 3339.9 | 114 | 127 | 13024.4 | 0 | 0.71 | ✔ | +| q3-core-s103-n13 | 13 | seven | 13/13 | 5344.6 | 102 | 115 | 23373.1 | 0 | 1.26 | ✔ | +| q3-core-s103-n13 | 13 | baseline | 13/13 | 16691.4 | 501 | 514 | 68212.0 | 0 | 1.56 | ✔ | +| q3-core-s103-n16 | 16 | optimal | 16/16 | 3378.8 | 99 | 115 | 13559.2 | 0 | 0.89 | ✔ | +| q3-core-s103-n16 | 16 | seven | 16/16 | 5526.4 | 87 | 103 | 24681.8 | 0 | 1.77 | ✔ | +| q3-core-s103-n16 | 16 | baseline | 16/16 | 12627.8 | 256 | 272 | 55189.0 | 0 | 1.83 | ✔ | +| q3-core-s104-n10 | 10 | optimal | 10/10 | 3317.0 | 115 | 125 | 12950.2 | 0 | 0.66 | ✔ | +| q3-core-s104-n10 | 10 | seven | 10/10 | 4915.9 | 105 | 115 | 21219.3 | 0 | 1.06 | ✔ | +| q3-core-s104-n10 | 10 | baseline | 10/10 | 15302.4 | 549 | 559 | 59887.2 | 0 | 1.19 | ✔ | +| q3-core-s104-n13 | 13 | optimal | 13/13 | 3085.2 | 99 | 112 | 12176.2 | 0 | 0.75 | ✔ | +| q3-core-s104-n13 | 13 | seven | 13/13 | 5437.5 | 97 | 110 | 24012.7 | 0 | 1.48 | ✔ | +| q3-core-s104-n13 | 13 | baseline | 13/13 | 16278.7 | 444 | 457 | 67868.5 | 0 | 1.56 | ✔ | +| q3-core-s104-n16 | 16 | optimal | 16/16 | 3057.8 | 85 | 101 | 12379.1 | 0 | 0.77 | ✔ | +| q3-core-s104-n16 | 16 | seven | 16/16 | 5340.9 | 85 | 101 | 23799.8 | 0 | 1.68 | ✔ | +| q3-core-s104-n16 | 16 | baseline | 16/16 | 12872.6 | 224 | 240 | 57378.0 | 0 | 2.00 | ✔ | +| q3-core-s105-n10 | 10 | optimal | 10/10 | 2933.1 | 108 | 118 | 11220.4 | 0 | 0.72 | ✔ | +| q3-core-s105-n10 | 10 | seven | 10/10 | 4370.8 | 107 | 117 | 18433.9 | 0 | 1.08 | ✔ | +| q3-core-s105-n10 | 10 | baseline | 10/10 | 15247.7 | 579 | 589 | 58688.4 | 0 | 1.17 | ✔ | +| q3-core-s105-n13 | 13 | optimal | 13/13 | 3645.3 | 122 | 135 | 14331.4 | 0 | 0.96 | ✔ | +| q3-core-s105-n13 | 13 | seven | 13/13 | 6311.3 | 104 | 117 | 28171.5 | 0 | 1.66 | ✔ | +| q3-core-s105-n13 | 13 | baseline | 13/13 | 16509.4 | 485 | 498 | 67791.8 | 0 | 1.52 | ✔ | +| q3-core-s105-n16 | 16 | optimal | 16/16 | 3663.7 | 114 | 130 | 14543.5 | 0 | 0.81 | ✔ | +| q3-core-s105-n16 | 16 | seven | 16/16 | 6204.3 | 97 | 113 | 27776.7 | 0 | 1.55 | ✔ | +| q3-core-s105-n16 | 16 | baseline | 16/16 | 13889.0 | 292 | 308 | 60450.1 | 0 | 1.94 | ✔ | + +## 逐方法汇总 + +| 方法 | 有效局 | 全清率 | 全清对数 | 缺席误判 | T 均值(s) | T 中位(s) | T 最大(s) | 检测均值 | 请求均值 | 位移均值(m) | 后备清除均值 | 墙钟均值(s) | +| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | +| optimal | 18/18 | 1.00 | 18 | 0 | 3188.7 | 3111.3 | 3663.7 | 111.1 | 124.1 | 12338.1 | 0.00 | 0.77 | +| seven | 18/18 | 1.00 | 18 | 0 | 5361.7 | 5367.5 | 6462.4 | 100.8 | 113.8 | 23508.0 | 0.00 | 1.43 | +| baseline | 18/18 | 1.00 | 18 | 0 | 14935.7 | 15275.1 | 16691.4 | 430.6 | 443.6 | 61550.2 | 0.00 | 1.54 | + +## 相对基线的配对变化（虚拟时间） + +| 配对 | 均值变化 | 中位变化 | 更快场景 | 双方均有效 | +| --- | --- | --- | --- | --- | +| optimal_vs_baseline | -78.4% | -80.0% | 18/18 | 18 | +| seven_vs_baseline | -63.7% | -66.9% | 18/18 | 18 | diff --git a/project/results/q4.json b/project/results/q4.json new file mode 100644 index 0000000..2e4cac4 --- /dev/null +++ b/project/results/q4.json @@ -0,0 +1,1082 @@ +{ + "question": 4, + "suite": "core+boundary", + "scenes": [ + { + "scene_id": "q4-core-s200-n10-d3", + "problem": 4, + "kind": "random", + "seed": 200, + "error_seed": 20261110, + "count": 10, + "directional": 3 + }, + { + "scene_id": "q4-core-s200-n13-d6", + "problem": 4, + "kind": "random", + "seed": 200, + "error_seed": 20261110, + "count": 13, + "directional": 6 + }, + { + "scene_id": "q4-core-s200-n16-d8", + "problem": 4, + "kind": "random", + "seed": 200, + "error_seed": 20261110, + "count": 16, + "directional": 8 + }, + { + "scene_id": "q4-core-s201-n10-d3", + "problem": 4, + "kind": "random", + "seed": 201, + "error_seed": 20261111, + "count": 10, + "directional": 3 + }, + { + "scene_id": "q4-core-s201-n13-d6", + "problem": 4, + "kind": "random", + "seed": 201, + "error_seed": 20261111, + "count": 13, + "directional": 6 + }, + { + "scene_id": "q4-core-s201-n16-d8", + "problem": 4, + "kind": "random", + "seed": 201, + "error_seed": 20261111, + "count": 16, + "directional": 8 + }, + { + "scene_id": "q4-core-s202-n10-d3", + "problem": 4, + "kind": "random", + "seed": 202, + "error_seed": 20261112, + "count": 10, + "directional": 3 + }, + { + "scene_id": "q4-core-s202-n13-d6", + "problem": 4, + "kind": "random", + "seed": 202, + "error_seed": 20261112, + "count": 13, + "directional": 6 + }, + { + "scene_id": "q4-core-s202-n16-d8", + "problem": 4, + "kind": "random", + "seed": 202, + "error_seed": 20261112, + "count": 16, + "directional": 8 + }, + { + "scene_id": "q4-boundary-n10-d5", + "problem": 4, + "kind": "boundary", + "seed": 0, + "error_seed": 20260910, + "count": 10, + "directional": 5 + }, + { + "scene_id": "q4-boundary-n16-d8", + "problem": 4, + "kind": "boundary", + "seed": 0, + "error_seed": 20260910, + "count": 16, + "directional": 8 + } + ], + "variants": [ + { + "label": "optimal", + "class": "build_loop" + }, + { + "label": "baseline_grid", + "class": "build_grid" + }, + { + "label": "baseline", + "class": "build_bayes" + } + ], + "config": { + "persistent_search": false, + "bearing_rounding_margin_deg": 0.005, + "q4_coverage_plan": "q4_mincover_v2" + }, + "rows": [ + { + "scene_id": "q4-core-s200-n10-d3", + "problem": 4, + "kind": "random", + "sources": 10, + "directional": 3, + "cleared": 10, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 8718.721, + "accounted_virtual_time_s": 8718.721, + "measures": 402, + "clears": 10, + "clear_success": 10, + "total_requests": 412, + "move_distance_m": 31508.6, + "fallback_clear_attempts": 0, + "coverage_points": 31, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 8.3, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q4-core-s200-n10-d3", + "problem": 4, + "kind": "random", + "sources": 10, + "directional": 3, + "cleared": 9, + "cleared_ratio": 0.9, + "cleared_matches_truth": false, + "absent_misjudged": 0, + "virtual_time_s": 16546.837, + "accounted_virtual_time_s": null, + "measures": 576, + "clears": 9, + "clear_success": 9, + "total_requests": 585, + "move_distance_m": 65379.2, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "unresolved_channels", + "exit_reason": "user_exit", + "anomaly_count": 3, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 2.807, + "valid": false, + "variant": "baseline_grid" + }, + { + "scene_id": "q4-core-s200-n10-d3", + "problem": 4, + "kind": "random", + "sources": 10, + "directional": 3, + "cleared": 10, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 3354.104, + "accounted_virtual_time_s": 3354.104, + "measures": 116, + "clears": 10, + "clear_success": 10, + "total_requests": 126, + "move_distance_m": 13100.5, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 3, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 0.665, + "valid": false, + "variant": "baseline" + }, + { + "scene_id": "q4-core-s200-n13-d6", + "problem": 4, + "kind": "random", + "sources": 13, + "directional": 6, + "cleared": 13, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 8808.415, + "accounted_virtual_time_s": 8808.415, + "measures": 332, + "clears": 15, + "clear_success": 13, + "total_requests": 347, + "move_distance_m": 33967.1, + "fallback_clear_attempts": 3, + "coverage_points": 31, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 2.824, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q4-core-s200-n13-d6", + "problem": 4, + "kind": "random", + "sources": 13, + "directional": 6, + "cleared": 7, + "cleared_ratio": 0.5385, + "cleared_matches_truth": false, + "absent_misjudged": 0, + "virtual_time_s": 18438.282, + "accounted_virtual_time_s": null, + "measures": 529, + "clears": 7, + "clear_success": 7, + "total_requests": 536, + "move_distance_m": 76651.4, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "unresolved_channels", + "exit_reason": "user_exit", + "anomaly_count": 18, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 8.205, + "valid": false, + "variant": "baseline_grid" + }, + { + "scene_id": "q4-core-s200-n13-d6", + "problem": 4, + "kind": "random", + "sources": 13, + "directional": 6, + "cleared": 11, + "cleared_ratio": 0.8462, + "cleared_matches_truth": false, + "absent_misjudged": 2, + "virtual_time_s": 3264.385, + "accounted_virtual_time_s": 3264.385, + "measures": 111, + "clears": 11, + "clear_success": 11, + "total_requests": 122, + "move_distance_m": 12761.9, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 1, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 0.8, + "valid": false, + "variant": "baseline" + }, + { + "scene_id": "q4-core-s200-n16-d8", + "problem": 4, + "kind": "random", + "sources": 16, + "directional": 8, + "cleared": 16, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 7629.157, + "accounted_virtual_time_s": null, + "measures": 267, + "clears": 16, + "clear_success": 16, + "total_requests": 283, + "move_distance_m": 29970.8, + "fallback_clear_attempts": 0, + "coverage_points": 31, + "stop_reason": "sixteen_cleared", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 3.269, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q4-core-s200-n16-d8", + "problem": 4, + "kind": "random", + "sources": 16, + "directional": 8, + "cleared": 10, + "cleared_ratio": 0.625, + "cleared_matches_truth": false, + "absent_misjudged": 0, + "virtual_time_s": 18871.328, + "accounted_virtual_time_s": null, + "measures": 526, + "clears": 10, + "clear_success": 10, + "total_requests": 536, + "move_distance_m": 78861.6, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "unresolved_channels", + "exit_reason": "user_exit", + "anomaly_count": 18, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 9.062, + "valid": false, + "variant": "baseline_grid" + }, + { + "scene_id": "q4-core-s200-n16-d8", + "problem": 4, + "kind": "random", + "sources": 16, + "directional": 8, + "cleared": 12, + "cleared_ratio": 0.75, + "cleared_matches_truth": false, + "absent_misjudged": 2, + "virtual_time_s": 4026.119, + "accounted_virtual_time_s": null, + "measures": 143, + "clears": 12, + "clear_success": 12, + "total_requests": 155, + "move_distance_m": 15645.6, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "unresolved_channels", + "exit_reason": "user_exit", + "anomaly_count": 9, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.863, + "valid": false, + "variant": "baseline" + }, + { + "scene_id": "q4-core-s201-n10-d3", + "problem": 4, + "kind": "random", + "sources": 10, + "directional": 3, + "cleared": 10, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 8513.972, + "accounted_virtual_time_s": 8513.972, + "measures": 380, + "clears": 11, + "clear_success": 10, + "total_requests": 391, + "move_distance_m": 31129.9, + "fallback_clear_attempts": 2, + "coverage_points": 31, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 2.067, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q4-core-s201-n10-d3", + "problem": 4, + "kind": "random", + "sources": 10, + "directional": 3, + "cleared": 7, + "cleared_ratio": 0.7, + "cleared_matches_truth": false, + "absent_misjudged": 0, + "virtual_time_s": 16779.683, + "accounted_virtual_time_s": null, + "measures": 624, + "clears": 7, + "clear_success": 7, + "total_requests": 631, + "move_distance_m": 65293.4, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "unresolved_channels", + "exit_reason": "user_exit", + "anomaly_count": 9, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 5.705, + "valid": false, + "variant": "baseline_grid" + }, + { + "scene_id": "q4-core-s201-n10-d3", + "problem": 4, + "kind": "random", + "sources": 10, + "directional": 3, + "cleared": 7, + "cleared_ratio": 0.7, + "cleared_matches_truth": false, + "absent_misjudged": 3, + "virtual_time_s": 2823.28, + "accounted_virtual_time_s": 2823.28, + "measures": 120, + "clears": 7, + "clear_success": 7, + "total_requests": 127, + "move_distance_m": 10391.4, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 0.711, + "valid": false, + "variant": "baseline" + }, + { + "scene_id": "q4-core-s201-n13-d6", + "problem": 4, + "kind": "random", + "sources": 13, + "directional": 6, + "cleared": 13, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 9183.015, + "accounted_virtual_time_s": 9183.015, + "measures": 325, + "clears": 13, + "clear_success": 13, + "total_requests": 338, + "move_distance_m": 36095.1, + "fallback_clear_attempts": 0, + "coverage_points": 31, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 2.497, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q4-core-s201-n13-d6", + "problem": 4, + "kind": "random", + "sources": 13, + "directional": 6, + "cleared": 8, + "cleared_ratio": 0.6154, + "cleared_matches_truth": false, + "absent_misjudged": 0, + "virtual_time_s": 19390.774, + "accounted_virtual_time_s": null, + "measures": 584, + "clears": 8, + "clear_success": 8, + "total_requests": 592, + "move_distance_m": 79678.9, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "unresolved_channels", + "exit_reason": "user_exit", + "anomaly_count": 15, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 4.4, + "valid": false, + "variant": "baseline_grid" + }, + { + "scene_id": "q4-core-s201-n13-d6", + "problem": 4, + "kind": "random", + "sources": 13, + "directional": 6, + "cleared": 11, + "cleared_ratio": 0.8462, + "cleared_matches_truth": false, + "absent_misjudged": 1, + "virtual_time_s": 4965.155, + "accounted_virtual_time_s": null, + "measures": 143, + "clears": 22, + "clear_success": 11, + "total_requests": 165, + "move_distance_m": 20260.8, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "unresolved_channels", + "exit_reason": "user_exit", + "anomaly_count": 11, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.115, + "valid": false, + "variant": "baseline" + }, + { + "scene_id": "q4-core-s201-n16-d8", + "problem": 4, + "kind": "random", + "sources": 16, + "directional": 8, + "cleared": 16, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 8129.395, + "accounted_virtual_time_s": null, + "measures": 263, + "clears": 16, + "clear_success": 16, + "total_requests": 279, + "move_distance_m": 32667.0, + "fallback_clear_attempts": 0, + "coverage_points": 31, + "stop_reason": "sixteen_cleared", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 3.504, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q4-core-s201-n16-d8", + "problem": 4, + "kind": "random", + "sources": 16, + "directional": 8, + "cleared": 9, + "cleared_ratio": 0.5625, + "cleared_matches_truth": false, + "absent_misjudged": 0, + "virtual_time_s": 19845.031, + "accounted_virtual_time_s": null, + "measures": 495, + "clears": 9, + "clear_success": 9, + "total_requests": 504, + "move_distance_m": 84765.2, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "unresolved_channels", + "exit_reason": "user_exit", + "anomaly_count": 21, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 10.224, + "valid": false, + "variant": "baseline_grid" + }, + { + "scene_id": "q4-core-s201-n16-d8", + "problem": 4, + "kind": "random", + "sources": 16, + "directional": 8, + "cleared": 13, + "cleared_ratio": 0.8125, + "cleared_matches_truth": false, + "absent_misjudged": 1, + "virtual_time_s": 4759.094, + "accounted_virtual_time_s": null, + "measures": 125, + "clears": 13, + "clear_success": 13, + "total_requests": 138, + "move_distance_m": 19835.5, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "unresolved_channels", + "exit_reason": "user_exit", + "anomaly_count": 9, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 2.122, + "valid": false, + "variant": "baseline" + }, + { + "scene_id": "q4-core-s202-n10-d3", + "problem": 4, + "kind": "random", + "sources": 10, + "directional": 3, + "cleared": 10, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 8803.261, + "accounted_virtual_time_s": 8803.261, + "measures": 420, + "clears": 10, + "clear_success": 10, + "total_requests": 430, + "move_distance_m": 31426.3, + "fallback_clear_attempts": 0, + "coverage_points": 31, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 2.36, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q4-core-s202-n10-d3", + "problem": 4, + "kind": "random", + "sources": 10, + "directional": 3, + "cleared": 7, + "cleared_ratio": 0.7, + "cleared_matches_truth": false, + "absent_misjudged": 0, + "virtual_time_s": 17219.971, + "accounted_virtual_time_s": null, + "measures": 669, + "clears": 7, + "clear_success": 7, + "total_requests": 676, + "move_distance_m": 66144.9, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "unresolved_channels", + "exit_reason": "user_exit", + "anomaly_count": 9, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 5.129, + "valid": false, + "variant": "baseline_grid" + }, + { + "scene_id": "q4-core-s202-n10-d3", + "problem": 4, + "kind": "random", + "sources": 10, + "directional": 3, + "cleared": 7, + "cleared_ratio": 0.7, + "cleared_matches_truth": false, + "absent_misjudged": 2, + "virtual_time_s": 3646.178, + "accounted_virtual_time_s": null, + "measures": 135, + "clears": 7, + "clear_success": 7, + "total_requests": 142, + "move_distance_m": 14105.9, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "unresolved_channels", + "exit_reason": "user_exit", + "anomaly_count": 3, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 0.683, + "valid": false, + "variant": "baseline" + }, + { + "scene_id": "q4-core-s202-n13-d6", + "problem": 4, + "kind": "random", + "sources": 13, + "directional": 6, + "cleared": 13, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 9630.406, + "accounted_virtual_time_s": 9630.406, + "measures": 347, + "clears": 20, + "clear_success": 13, + "total_requests": 367, + "move_distance_m": 37652.0, + "fallback_clear_attempts": 10, + "coverage_points": 31, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 3.11, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q4-core-s202-n13-d6", + "problem": 4, + "kind": "random", + "sources": 13, + "directional": 6, + "cleared": 10, + "cleared_ratio": 0.7692, + "cleared_matches_truth": false, + "absent_misjudged": 0, + "virtual_time_s": 16443.25, + "accounted_virtual_time_s": null, + "measures": 498, + "clears": 10, + "clear_success": 10, + "total_requests": 508, + "move_distance_m": 67316.3, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "unresolved_channels", + "exit_reason": "user_exit", + "anomaly_count": 9, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 1.839, + "valid": false, + "variant": "baseline_grid" + }, + { + "scene_id": "q4-core-s202-n13-d6", + "problem": 4, + "kind": "random", + "sources": 13, + "directional": 6, + "cleared": 13, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 4219.344, + "accounted_virtual_time_s": 4219.344, + "measures": 123, + "clears": 14, + "clear_success": 13, + "total_requests": 137, + "move_distance_m": 17136.7, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 6, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 0.809, + "valid": false, + "variant": "baseline" + }, + { + "scene_id": "q4-core-s202-n16-d8", + "problem": 4, + "kind": "random", + "sources": 16, + "directional": 8, + "cleared": 16, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 8001.547, + "accounted_virtual_time_s": null, + "measures": 267, + "clears": 38, + "clear_success": 16, + "total_requests": 305, + "move_distance_m": 31602.7, + "fallback_clear_attempts": 24, + "coverage_points": 31, + "stop_reason": "sixteen_cleared", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 3.954, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q4-core-s202-n16-d8", + "problem": 4, + "kind": "random", + "sources": 16, + "directional": 8, + "cleared": 12, + "cleared_ratio": 0.75, + "cleared_matches_truth": false, + "absent_misjudged": 0, + "virtual_time_s": 18345.164, + "accounted_virtual_time_s": null, + "measures": 452, + "clears": 12, + "clear_success": 12, + "total_requests": 464, + "move_distance_m": 78265.8, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "unresolved_channels", + "exit_reason": "user_exit", + "anomaly_count": 12, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 8.896, + "valid": false, + "variant": "baseline_grid" + }, + { + "scene_id": "q4-core-s202-n16-d8", + "problem": 4, + "kind": "random", + "sources": 16, + "directional": 8, + "cleared": 13, + "cleared_ratio": 0.8125, + "cleared_matches_truth": false, + "absent_misjudged": 0, + "virtual_time_s": 5054.382, + "accounted_virtual_time_s": null, + "measures": 152, + "clears": 13, + "clear_success": 13, + "total_requests": 165, + "move_distance_m": 20561.9, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "unresolved_channels", + "exit_reason": "user_exit", + "anomaly_count": 14, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 2.053, + "valid": false, + "variant": "baseline" + }, + { + "scene_id": "q4-boundary-n10-d5", + "problem": 4, + "kind": "boundary", + "sources": 10, + "directional": 5, + "cleared": 10, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 10269.542, + "accounted_virtual_time_s": 10269.542, + "measures": 488, + "clears": 52, + "clear_success": 10, + "total_requests": 540, + "move_distance_m": 36107.7, + "fallback_clear_attempts": 44, + "coverage_points": 31, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 2.632, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q4-boundary-n10-d5", + "problem": 4, + "kind": "boundary", + "sources": 10, + "directional": 5, + "cleared": 6, + "cleared_ratio": 0.6, + "cleared_matches_truth": false, + "absent_misjudged": 0, + "virtual_time_s": 17632.725, + "accounted_virtual_time_s": null, + "measures": 735, + "clears": 6, + "clear_success": 6, + "total_requests": 741, + "move_distance_m": 66308.6, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "unresolved_channels", + "exit_reason": "user_exit", + "anomaly_count": 12, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 5.084, + "valid": false, + "variant": "baseline_grid" + }, + { + "scene_id": "q4-boundary-n10-d5", + "problem": 4, + "kind": "boundary", + "sources": 10, + "directional": 5, + "cleared": 5, + "cleared_ratio": 0.5, + "cleared_matches_truth": false, + "absent_misjudged": 5, + "virtual_time_s": 3128.08, + "accounted_virtual_time_s": 3128.08, + "measures": 135, + "clears": 5, + "clear_success": 5, + "total_requests": 140, + "move_distance_m": 11530.4, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 0.525, + "valid": false, + "variant": "baseline" + }, + { + "scene_id": "q4-boundary-n16-d8", + "problem": 4, + "kind": "boundary", + "sources": 16, + "directional": 8, + "cleared": 16, + "cleared_ratio": 1.0, + "cleared_matches_truth": true, + "absent_misjudged": 0, + "virtual_time_s": 12081.148, + "accounted_virtual_time_s": null, + "measures": 421, + "clears": 205, + "clear_success": 16, + "total_requests": 626, + "move_distance_m": 44820.7, + "fallback_clear_attempts": 190, + "coverage_points": 31, + "stop_reason": "sixteen_cleared", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 3.575, + "valid": true, + "variant": "optimal" + }, + { + "scene_id": "q4-boundary-n16-d8", + "problem": 4, + "kind": "boundary", + "sources": 16, + "directional": 8, + "cleared": 9, + "cleared_ratio": 0.5625, + "cleared_matches_truth": false, + "absent_misjudged": 0, + "virtual_time_s": 20457.858, + "accounted_virtual_time_s": null, + "measures": 623, + "clears": 9, + "clear_success": 9, + "total_requests": 632, + "move_distance_m": 83969.3, + "fallback_clear_attempts": 0, + "coverage_points": 49, + "stop_reason": "unresolved_channels", + "exit_reason": "user_exit", + "anomaly_count": 21, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 8.856, + "valid": false, + "variant": "baseline_grid" + }, + { + "scene_id": "q4-boundary-n16-d8", + "problem": 4, + "kind": "boundary", + "sources": 16, + "directional": 8, + "cleared": 8, + "cleared_ratio": 0.5, + "cleared_matches_truth": false, + "absent_misjudged": 8, + "virtual_time_s": 3558.693, + "accounted_virtual_time_s": 3558.693, + "measures": 149, + "clears": 8, + "clear_success": 8, + "total_requests": 157, + "move_distance_m": 13173.5, + "fallback_clear_attempts": 0, + "coverage_points": 7, + "stop_reason": "all_resolved", + "exit_reason": "user_exit", + "anomaly_count": 0, + "virtual_recompute_mismatches": 0, + "compute_wall_s": 0.52, + "valid": false, + "variant": "baseline" + } + ], + "aggregate": { + "variants": { + "optimal": { + "episodes": 11, + "valid_episodes": 11, + "cleared_ratio_mean": 1.0, + "cleared_matches_truth": 11, + "absent_misjudged_total": 0, + "virtual_time_mean_s": 9069.8708, + "virtual_time_median_s": 8803.261, + "virtual_time_max_s": 12081.148, + "measures_mean": 355.6364, + "total_requests_mean": 392.5455, + "move_distance_mean_m": 34267.9909, + "fallback_clear_attempts_mean": 24.8182, + "compute_wall_mean_s": 3.4629 + }, + "baseline_grid": { + "episodes": 11, + "valid_episodes": 0, + "cleared_ratio_mean": 0.6657, + "cleared_matches_truth": 0, + "absent_misjudged_total": 0, + "virtual_time_mean_s": 18179.173, + "virtual_time_median_s": 18345.164, + "virtual_time_max_s": 20457.858, + "measures_mean": 573.7273, + "total_requests_mean": 582.2727, + "move_distance_mean_m": 73875.8727, + "fallback_clear_attempts_mean": 0.0, + "compute_wall_mean_s": 6.3825 + }, + "baseline": { + "episodes": 11, + "valid_episodes": 0, + "cleared_ratio_mean": 0.7698, + "cleared_matches_truth": 2, + "absent_misjudged_total": 24, + "virtual_time_mean_s": 3890.8013, + "virtual_time_median_s": 3646.178, + "virtual_time_max_s": 5054.382, + "measures_mean": 132.0, + "total_requests_mean": 143.0909, + "move_distance_mean_m": 15318.5545, + "fallback_clear_attempts_mean": 0.0, + "compute_wall_mean_s": 1.0787 + } + }, + "paired": { + "optimal_vs_baseline": { + "mean_relative_change": 1.4294, + "median_relative_change": 1.4144, + "faster_scenes": 0, + "compared": 11, + "both_valid_scenes": 0 + }, + "baseline_grid_vs_baseline": { + "mean_relative_change": 3.8111, + "median_relative_change": 3.7227, + "faster_scenes": 0, + "compared": 11, + "both_valid_scenes": 0 + } + } + } +} diff --git a/project/results/q4.md b/project/results/q4.md new file mode 100644 index 0000000..2ec0883 --- /dev/null +++ b/project/results/q4.md @@ -0,0 +1,56 @@ +# 问题四：混合源闭环配对对比（core+boundary 基准集） + +## 逐场景明细 + +| scene | sources | variant | cleared | T(s) | 检测 | 请求 | 位移(m) | 后备清除 | 墙钟(s) | 有效 | +| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | +| q4-boundary-n10-d5 | 10 | optimal | 10/10 | 10269.5 | 488 | 540 | 36107.7 | 44 | 2.63 | ✔ | +| q4-boundary-n10-d5 | 10 | baseline_grid | 6/10 | 17632.7 | 735 | 741 | 66308.6 | 0 | 5.08 | ✘ | +| q4-boundary-n10-d5 | 10 | baseline | 5/10 | 3128.1 | 135 | 140 | 11530.4 | 0 | 0.53 | ✘ | +| q4-boundary-n16-d8 | 16 | optimal | 16/16 | 12081.1 | 421 | 626 | 44820.7 | 190 | 3.58 | ✔ | +| q4-boundary-n16-d8 | 16 | baseline_grid | 9/16 | 20457.9 | 623 | 632 | 83969.3 | 0 | 8.86 | ✘ | +| q4-boundary-n16-d8 | 16 | baseline | 8/16 | 3558.7 | 149 | 157 | 13173.5 | 0 | 0.52 | ✘ | +| q4-core-s200-n10-d3 | 10 | optimal | 10/10 | 8718.7 | 402 | 412 | 31508.6 | 0 | 8.30 | ✔ | +| q4-core-s200-n10-d3 | 10 | baseline_grid | 9/10 | 16546.8 | 576 | 585 | 65379.2 | 0 | 2.81 | ✘ | +| q4-core-s200-n10-d3 | 10 | baseline | 10/10 | 3354.1 | 116 | 126 | 13100.5 | 0 | 0.67 | ✘ | +| q4-core-s200-n13-d6 | 13 | optimal | 13/13 | 8808.4 | 332 | 347 | 33967.1 | 3 | 2.82 | ✔ | +| q4-core-s200-n13-d6 | 13 | baseline_grid | 7/13 | 18438.3 | 529 | 536 | 76651.4 | 0 | 8.21 | ✘ | +| q4-core-s200-n13-d6 | 13 | baseline | 11/13 | 3264.4 | 111 | 122 | 12761.9 | 0 | 0.80 | ✘ | +| q4-core-s200-n16-d8 | 16 | optimal | 16/16 | 7629.2 | 267 | 283 | 29970.8 | 0 | 3.27 | ✔ | +| q4-core-s200-n16-d8 | 16 | baseline_grid | 10/16 | 18871.3 | 526 | 536 | 78861.6 | 0 | 9.06 | ✘ | +| q4-core-s200-n16-d8 | 16 | baseline | 12/16 | 4026.1 | 143 | 155 | 15645.6 | 0 | 1.86 | ✘ | +| q4-core-s201-n10-d3 | 10 | optimal | 10/10 | 8514.0 | 380 | 391 | 31129.9 | 2 | 2.07 | ✔ | +| q4-core-s201-n10-d3 | 10 | baseline_grid | 7/10 | 16779.7 | 624 | 631 | 65293.4 | 0 | 5.71 | ✘ | +| q4-core-s201-n10-d3 | 10 | baseline | 7/10 | 2823.3 | 120 | 127 | 10391.4 | 0 | 0.71 | ✘ | +| q4-core-s201-n13-d6 | 13 | optimal | 13/13 | 9183.0 | 325 | 338 | 36095.1 | 0 | 2.50 | ✔ | +| q4-core-s201-n13-d6 | 13 | baseline_grid | 8/13 | 19390.8 | 584 | 592 | 79678.9 | 0 | 4.40 | ✘ | +| q4-core-s201-n13-d6 | 13 | baseline | 11/13 | 4965.2 | 143 | 165 | 20260.8 | 0 | 1.11 | ✘ | +| q4-core-s201-n16-d8 | 16 | optimal | 16/16 | 8129.4 | 263 | 279 | 32667.0 | 0 | 3.50 | ✔ | +| q4-core-s201-n16-d8 | 16 | baseline_grid | 9/16 | 19845.0 | 495 | 504 | 84765.2 | 0 | 10.22 | ✘ | +| q4-core-s201-n16-d8 | 16 | baseline | 13/16 | 4759.1 | 125 | 138 | 19835.5 | 0 | 2.12 | ✘ | +| q4-core-s202-n10-d3 | 10 | optimal | 10/10 | 8803.3 | 420 | 430 | 31426.3 | 0 | 2.36 | ✔ | +| q4-core-s202-n10-d3 | 10 | baseline_grid | 7/10 | 17220.0 | 669 | 676 | 66144.9 | 0 | 5.13 | ✘ | +| q4-core-s202-n10-d3 | 10 | baseline | 7/10 | 3646.2 | 135 | 142 | 14105.9 | 0 | 0.68 | ✘ | +| q4-core-s202-n13-d6 | 13 | optimal | 13/13 | 9630.4 | 347 | 367 | 37652.0 | 10 | 3.11 | ✔ | +| q4-core-s202-n13-d6 | 13 | baseline_grid | 10/13 | 16443.2 | 498 | 508 | 67316.3 | 0 | 1.84 | ✘ | +| q4-core-s202-n13-d6 | 13 | baseline | 13/13 | 4219.3 | 123 | 137 | 17136.7 | 0 | 0.81 | ✘ | +| q4-core-s202-n16-d8 | 16 | optimal | 16/16 | 8001.5 | 267 | 305 | 31602.7 | 24 | 3.95 | ✔ | +| q4-core-s202-n16-d8 | 16 | baseline_grid | 12/16 | 18345.2 | 452 | 464 | 78265.8 | 0 | 8.90 | ✘ | +| q4-core-s202-n16-d8 | 16 | baseline | 13/16 | 5054.4 | 152 | 165 | 20561.9 | 0 | 2.05 | ✘ | + +## 逐方法汇总 + +| 方法 | 有效局 | 全清率 | 全清对数 | 缺席误判 | T 均值(s) | T 中位(s) | T 最大(s) | 检测均值 | 请求均值 | 位移均值(m) | 后备清除均值 | 墙钟均值(s) | +| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | +| optimal | 11/11 | 1.00 | 11 | 0 | 9069.9 | 8803.3 | 12081.1 | 355.6 | 392.5 | 34268.0 | 24.82 | 3.46 | +| baseline_grid | 0/11 | 0.67 | 0 | 0 | 18179.2 | 18345.2 | 20457.9 | 573.7 | 582.3 | 73875.9 | 0.00 | 6.38 | +| baseline | 0/11 | 0.77 | 2 | 24 | 3890.8 | 3646.2 | 5054.4 | 132.0 | 143.1 | 15318.6 | 0.00 | 1.08 | + +## 相对基线的配对变化（虚拟时间） + +| 配对 | 均值变化 | 中位变化 | 更快场景 | 双方均有效 | +| --- | --- | --- | --- | --- | +| optimal_vs_baseline | +142.9% | +141.4% | 0/11 | 0 | +| baseline_grid_vs_baseline | +381.1% | +372.3% | 0/11 | 0 | + +> 注：optimal_vs_baseline、baseline_grid_vs_baseline 存在未通过有效性判定的配对；其虚拟时间仅作参考，基线未完成全清任务时不构成「更快」证据（以「双方均有效」列为准）。 diff --git a/project/results/summary.md b/project/results/summary.md new file mode 100644 index 0000000..27dba77 --- /dev/null +++ b/project/results/summary.md @@ -0,0 +1,50 @@ +# 1-4 问最优 vs 基线：对比总览 + +本节所有数字由 `uv run python -m project.run` 在同机同口径下生成， +逐问明细见 `q1.md` … `q4.md`。 + +| 问 | 核心指标 | 最优实现 | 基线实现 | +| --- | --- | --- | --- | +| 1 | 直径平均误差 / 覆盖准确率 | 0.00 m / 100% | 4.58 m / 52% | +| 2 | 保证接收率 / 最坏后验均值 | 100% / 73.9 m | 100% / 340.7 m | +| 3 | 全清率 / T 均值（相对基线） | 100% / 3189 s (-78%) | 100% / 14936 s | +| 4 | 全清率 / 缺席误判（问题三策略搬用） | 100% / 0 | 77% / 24 | + +## 方法映射 + +| 问 | 最优实现 | 基线实现 | 独立参考 | +| --- | --- | --- | --- | +| 1 | 半平面交 + 顶点对直径 + MEC | 网格采样 + bbox 对角线代理 | 大框半平面裁剪 + 精确直径/MEC | +| 2 | 保证接收盘内最小最坏后验半径 | 垂直 1000 m / MEC 圆心 | 保证接收盘内网格枚举 | +| 3 | bayes（粒子滤波 + 信息增益 + 滚动调度） | grid（49 点网格）/ seven（七点批量） | 冻结基准集 + 逐微秒计时复算 | +| 4 | directional（联合信念 + 后备清除） | bayes / grid 直接搬用 | 冻结基准集 + 真值全清校验 | + +## 目录结构 + +```text +project/ +├── common.py 公共层：方法描述/指标聚合/结果落盘/闭环装配 +├── q1/ 问题一：直径与直径圆覆盖 +│ ├── optimal.py 生产实现：半平面交 + 顶点对直径 + MEC +│ ├── baseline.py 基线：网格采样 + bbox 对角线代理 +│ ├── reference.py 参考：大框半平面裁剪 + 精确直径/MEC +│ ├── cases.py 固定示例（examples/q1）+ 随机交会算例 +│ └── compare.py 同案配对对比 +├── q2/ 问题二：第二检测点选择 +│ ├── optimal.py 生产实现：保证接收盘内最小最坏后验半径 +│ ├── baseline.py 基线：垂直 1000 m / MEC 圆心 +│ ├── reference.py 参考：保证接收盘内网格枚举 +│ ├── region.py K1 统一构造 +│ ├── cases.py 随机首次示向度算例 +│ └── compare.py +├── q3/ 问题三：全向闭环 +│ ├── optimal.py bayes（生产默认策略） +│ ├── baseline.py grid（49 点网格）/ seven（七点批量） +│ └── compare.py +├── q4/ 问题四：混合源闭环 +│ ├── optimal.py directional（定向扩展） +│ ├── baseline.py bayes / grid 直接搬用 +│ └── compare.py +├── run.py 统一入口（本文件） +└── results/ 自动生成：q1.md/json … q4.md/json + summary.md +``` diff --git a/project/run.py b/project/run.py new file mode 100644 index 0000000..b8b5ee3 --- /dev/null +++ b/project/run.py @@ -0,0 +1,148 @@ +"""统一入口：一次跑完 1-4 问的"最优 vs 基线"对比并生成 results/。 + +用法（仓库根目录）:: + + uv run python -m project.run # 四问全部 + uv run python -m project.run --question 3 # 只跑第三问 + uv run python -m project.run --quick # 缩小算例/基准集规模 +""" + +from __future__ import annotations + +import argparse +import time + +from project.common import RESULTS_DIR, markdown_table, write_text +from project.q1 import compare as q1_compare +from project.q2 import compare as q2_compare +from project.q3 import compare as q3_compare +from project.q4 import compare as q4_compare + +RUNNERS = { + 1: q1_compare.run, + 2: q2_compare.run, + 3: q3_compare.run, + 4: q4_compare.run, +} + +STRUCTURE = """\ +project/ +├── common.py 公共层：方法描述/指标聚合/结果落盘/闭环装配 +├── q1/ 问题一：直径与直径圆覆盖 +│ ├── optimal.py 生产实现：半平面交 + 顶点对直径 + MEC +│ ├── baseline.py 基线：网格采样 + bbox 对角线代理 +│ ├── reference.py 参考：大框半平面裁剪 + 精确直径/MEC +│ ├── cases.py 固定示例（examples/q1）+ 随机交会算例 +│ └── compare.py 同案配对对比 +├── q2/ 问题二：第二检测点选择 +│ ├── optimal.py 生产实现：保证接收盘内最小最坏后验半径 +│ ├── baseline.py 基线：垂直 1000 m / MEC 圆心 +│ ├── reference.py 参考：保证接收盘内网格枚举 +│ ├── region.py K1 统一构造 +│ ├── cases.py 随机首次示向度算例 +│ └── compare.py +├── q3/ 问题三：全向闭环 +│ ├── optimal.py bayes（生产默认策略） +│ ├── baseline.py grid（49 点网格）/ seven（七点批量） +│ └── compare.py +├── q4/ 问题四：混合源闭环 +│ ├── optimal.py directional（定向扩展） +│ ├── baseline.py bayes / grid 直接搬用 +│ └── compare.py +├── run.py 统一入口（本文件） +└── results/ 自动生成：q1.md/json … q4.md/json + summary.md +""" + + +def _q1_headline(payload: dict) -> list[str]: + agg = payload["aggregate_random"] + return ["1", "直径平均误差 / 覆盖准确率", + f"{agg['diameter_mae_optimal_m']:.2f} m / " + f"{agg['coverage_accuracy_optimal']*100:.0f}%", + f"{agg['diameter_mae_baseline_m']:.2f} m / " + f"{agg['coverage_accuracy_baseline']*100:.0f}%"] + + +def _q2_headline(payload: dict) -> list[str]: + agg = payload["aggregate"] + opt = agg["optimal"] + base = agg["baseline_mec"] + return ["2", "保证接收率 / 最坏后验均值", + f"{opt['guaranteed_rate']*100:.0f}% / " + f"{opt['worst_posterior_mean_m']:.1f} m", + f"{base['guaranteed_rate']*100:.0f}% / " + f"{base['worst_posterior_mean_m']:.1f} m"] + + +def _q3_headline(payload: dict) -> list[str]: + agg = payload["aggregate"]["variants"] + opt, base = agg["optimal"], agg["baseline"] + paired = payload["aggregate"]["paired"].get("optimal_vs_baseline", {}) + return ["3", "全清率 / T 均值（相对基线）", + f"{opt['cleared_ratio_mean']*100:.0f}% / " + f"{opt['virtual_time_mean_s']:.0f} s " + f"({paired.get('mean_relative_change', 0)*100:+.0f}%)", + f"{base['cleared_ratio_mean']*100:.0f}% / " + f"{base['virtual_time_mean_s']:.0f} s"] + + +def _q4_headline(payload: dict) -> list[str]: + agg = payload["aggregate"]["variants"] + opt, base = agg["optimal"], agg["baseline"] + return ["4", "全清率 / 缺席误判（问题三策略搬用）", + f"{opt['cleared_ratio_mean']*100:.0f}% / " + f"{opt['absent_misjudged_total']}", + f"{base['cleared_ratio_mean']*100:.0f}% / " + f"{base['absent_misjudged_total']}"] + + +def _write_summary(payloads: dict[int, dict]) -> None: + lines = ["# 1-4 问最优 vs 基线：对比总览", "", + "本节所有数字由 `uv run python -m project.run` 在同机同口径下生成，", + "逐问明细见 `q1.md` … `q4.md`。", ""] + rows = [] + if 1 in payloads: + rows.append(_q1_headline(payloads[1])) + if 2 in payloads: + rows.append(_q2_headline(payloads[2])) + if 3 in payloads: + rows.append(_q3_headline(payloads[3])) + if 4 in payloads: + rows.append(_q4_headline(payloads[4])) + lines.append(markdown_table(["问", "核心指标", "最优实现", "基线实现"], rows)) + lines += ["", "## 方法映射", "", + "| 问 | 最优实现 | 基线实现 | 独立参考 |", + "| --- | --- | --- | --- |", + "| 1 | 半平面交 + 顶点对直径 + MEC | 网格采样 + bbox 对角线代理 | 大框半平面裁剪 + 精确直径/MEC |", + "| 2 | 保证接收盘内最小最坏后验半径 | 垂直 1000 m / MEC 圆心 | 保证接收盘内网格枚举 |", + "| 3 | bayes（粒子滤波 + 信息增益 + 滚动调度） | grid（49 点网格）/ seven（七点批量） | 冻结基准集 + 逐微秒计时复算 |", + "| 4 | directional（联合信念 + 后备清除） | bayes / grid 直接搬用 | 冻结基准集 + 真值全清校验 |", + "", "## 目录结构", "", "```text", STRUCTURE.rstrip(), "```", ""] + write_text(RESULTS_DIR / "summary.md", "\n".join(lines)) + + +def main(argv=None) -> int: + parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + parser.add_argument("--question", choices=("1", "2", "3", "4", "all"), + default="all") + parser.add_argument("--quick", action="store_true", + help="缩小随机算例数/冻结基准集规模") + args = parser.parse_args(argv) + + selected = [1, 2, 3, 4] if args.question == "all" else [int(args.question)] + payloads: dict[int, dict] = {} + for question in selected: + start = time.perf_counter() + print(f"[Q{question}] 运行对比 …", flush=True) + payloads[question] = RUNNERS[question](quick=args.quick) + print(f"[Q{question}] 完成，用时 {time.perf_counter() - start:.1f}s", + flush=True) + if selected == [1, 2, 3, 4]: + _write_summary(payloads) + print(f"总览已写入 {RESULTS_DIR / 'summary.md'}") + print(f"结果目录：{RESULTS_DIR}") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main())