在线演示

浏览器内的交互式演示——可视化基准结构与求解器结果，并用 WebAssembly Python 在线运行求解器。无需安装，无需服务器。

这些演示完全在你的浏览器中运行。Visualize 标签页绘制对公开安全的预览证据——一张求解器排行榜，动画化的收敛与探索-利用图表，可扩展性、种子稳定性与鲁棒性分析图表，以及任意基准实例的结构特征化。Run live 标签页在 WebAssembly 沙箱（Pyodide）中执行真实的 Python：编辑求解器并重新运行，无需安装任何东西。 Analyze 标签页运行一个完整的带种子实验，并以效应量和自助法（bootstrap）置信区间比较两个求解器——与完整工具包所采用的证据规范相同。

此处的一切都是说明性的、对公开安全的预览材料。完整工具包以研究规模运行同类的基准测试、求解与分析——从快速开始起步，或浏览基准目录。

Solver leaderboard

Best makespan per solver on the smoke benchmark set (lower is better). Bundled demo evidence — not a comparative ranking.

Convergence trajectory

How each iterative solver’s best-so-far objective improves over iterations — the anytime curve.

Per-iteration best-so-far objective for a native iterative cohort on a smoke instance (lower is better) — hover, or focus the chart and use the arrow keys, to read each solver’s incumbent. Public-safe preview from a real seeded run; the full platform traces convergence at research scale.

Exploration–exploitation balance

Population diversity over iterations — high while the search explores, falling as it exploits and converges.

Mean population diversity by iteration for the native population solver on a smoke instance — high while the search explores, falling as it exploits and converges. Hover, or focus the chart and use the arrow keys, to read the diversity. Public-safe preview from a real seeded run.

Scalability (size response)

Makespan across a doubling task-count ladder — how each solver scales as the problem grows.

Makespan across a doubling task-count ladder (16–96 tasks) for a dispatching baseline and a native metaheuristic on one Edge–Fog–Cloud family — reading the size response is the scalability curve a results section reports. Hover, or focus the chart and use the arrow keys, to read each solver’s makespan; the native search holds a slim edge that widens with size. Public-safe preview from real seeded solves.

Seed stability

Coefficient of variation across the seed set — how consistently each solver reaches its result.

Each solver’s seed coefficient of variation (makespan standard deviation over the seed set, divided by the mean) — lower is more stable. A deterministic solver reads zero. Hover or focus a bar to read it. Public-safe aggregate from a seed-replicated smoke campaign.

Robustness (tail risk)

CVaR of the worst per-problem makespan-ratio tail — ranking solvers by deployment-relevant risk, not the mean.

Each solver’s conditional value-at-risk (CVaR) of the worst tail of its makespan ratios (each run’s makespan over the problem’s best across the field) over the seed set — lower is more robust, ranking by deployment-relevant tail risk rather than the mean. Hover or focus a bar to read it. Public-safe aggregate from the same seed-replicated smoke campaign.

Benchmark characterization

Pick an instance to see its structural fingerprint.

Benchmark instance

heterogeneity

1.00

objective conflict

1.00

load skew

0.83

uncertainty

0.67

compatibility sparsity

0.67

opportunity density

0.50

solver sensitivity

0.45

dynamism

0.10

overload

0.04

contention

0.04

communication pressure

0.00

dependency depth

0.00

setup intensity

0.00

Each benchmark is characterized by quantitative metrics in [0, 1]. These structural features are what make the catalog construct-based rather than tag-based.

This runs real Python in your browser via WebAssembly (Pyodide) — no server, no install. It is a light illustrative solver; the full toolkit runs the same kinds of computation at research scale.

solver.py

# A self-contained scheduling scenario that mirrors the toolkit's
# benchmark -> solve -> analyze workflow: generate a heterogeneous instance,
# run three dispatching heuristics, and compare their makespans.
# Edit anything and re-run — it executes in your browser.
import random

random.seed(20260527)  # deterministic, like the toolkit's recorded seeds
n_tasks, n_machines = 9, 3

# Heterogeneous benchmark instance: task i has a different duration per machine.
exec_time = {
    (i, m): random.randint(2, 9)
    for i in range(n_tasks)
    for m in range(n_machines)
}

def makespan(order, pick):
    loads = [0] * n_machines
    for i in order:
        m = pick(i, loads)
        loads[m] += exec_time[(i, m)]
    return max(loads)

lpt = sorted(range(n_tasks), key=lambda i: -min(exec_time[(i, m)] for m in range(n_machines)))
least_loaded = lambda i, loads: min(range(n_machines), key=lambda m: loads[m] + exec_time[(i, m)])

solvers = {
    "min-load-greedy": (range(n_tasks), least_loaded),
    "LPT + min-load":  (lpt,            least_loaded),
    "fastest-machine": (range(n_tasks), lambda i, loads: min(range(n_machines), key=lambda m: exec_time[(i, m)])),
}

results = {name: makespan(order, pick) for name, (order, pick) in solvers.items()}
best = min(results, key=results.get)

print(f"Instance: {n_tasks} tasks x {n_machines} heterogeneous machines\n")
print(f"{'solver':18} makespan")
print("-" * 30)
for name, mk in sorted(results.items(), key=lambda kv: kv[1]):
    print(f"{name:18} {mk:>5}{'   <- best' if name == best else ''}")
print(f"\nBest here: {best}. Capability, not a universal claim — the full")
print("toolkit runs fair, seeded, statistically-compared campaigns.")

Output

Press Run to execute the solver in your browser.

A complete experiment-then-analysis scenario: it runs two solvers across many seeded instances and compares them the way the toolkit reports evidence — with a Cliff’s-delta effect size and a bootstrap confidence interval, never a bare p-value. Runs live in your browser; edit the budget or the solvers and re-run.

experiment.py

# A complete benchmark -> solve -> ANALYZE scenario, reported the way the
# toolkit reports evidence: run two dispatching heuristics across many seeded
# instances, then compare them with an effect size AND a bootstrap confidence
# interval — never a bare p-value. Edit anything and re-run; it runs in your browser.
import random, statistics

SEEDS = 40                    # independent seeded instances (a real run budget)
N_TASKS, N_MACHINES = 12, 3

def instance(seed):
    rng = random.Random(seed)
    return {(i, m): rng.randint(2, 9)
            for i in range(N_TASKS) for m in range(N_MACHINES)}

def makespan(et, order, pick):
    loads = [0] * N_MACHINES
    for i in order:
        m = pick(i, loads, et)
        loads[m] += et[(i, m)]
    return max(loads)

def least_loaded(i, loads, et):
    return min(range(N_MACHINES), key=lambda m: loads[m] + et[(i, m)])

def lpt_order(et):            # longest-processing-time first
    return sorted(range(N_TASKS),
                  key=lambda i: -min(et[(i, m)] for m in range(N_MACHINES)))

A, B = "LPT + min-load", "arrival-order + min-load"
a, b = [], []
for s in range(SEEDS):
    et = instance(20260000 + s)
    a.append(makespan(et, lpt_order(et), least_loaded))
    b.append(makespan(et, range(N_TASKS), least_loaded))

# Cliff's delta: (#(A>B) - #(A<B)) / (n*m). Negative => A tends to be smaller (better).
gt = sum(x > y for x in a for y in b)
lt = sum(x < y for x in a for y in b)
delta = (gt - lt) / (len(a) * len(b))
mag = next(lbl for thr, lbl in
           [(0.147, "negligible"), (0.33, "small"), (0.474, "medium"), (2.0, "large")]
           if abs(delta) < thr)

# Bootstrap 95% CI on the mean paired difference A - B (percentile method).
diffs = [x - y for x, y in zip(a, b)]
boot_rng = random.Random(7)
boot = sorted(statistics.fmean(boot_rng.choices(diffs, k=len(diffs)))
              for _ in range(2000))
lo, hi = boot[int(0.025 * len(boot))], boot[int(0.975 * len(boot)) - 1]

print(f"{SEEDS} seeded instances - {N_TASKS} tasks x {N_MACHINES} machines\n")
print(f"mean makespan  {A:24} {statistics.fmean(a):6.2f}")
print(f"mean makespan  {B:24} {statistics.fmean(b):6.2f}\n")
print(f"Cliff's delta (A vs B):  {delta:+.3f}  ({mag} effect)")
print(f"95% bootstrap CI of mean(A - B):  [{lo:+.2f}, {hi:+.2f}]")
credible = ("excludes 0 - the advantage is statistically credible"
            if (lo < 0) == (hi < 0) else "spans 0 - no credible difference")
print(f"  the interval {credible}.\n")
print("Reported with an effect size AND a confidence interval, never a bare")
print("p-value. The full platform adds Holm-corrected Wilcoxon / Friedman tests")
print("across the whole catalog.")

Output

Press Run to execute the solver in your browser.