@mark1russell7/highways 0.4.2 → 0.5.1

package/src/bench/exact/solve.ts

@@ -0,0 +1,129 @@
+import { follow } from "../../highways/follow.ts";
+import type { HighwayPlan } from "../../highways/model.ts";
+import type { Graph, Route } from "../../model.ts";
+import { STRATEGIES } from "../../strategies/builtins.ts";
+import { asRouter, getStrategy } from "../../strategies/model.ts";
+import { inkSaved } from "../measures/bundles.ts";
+import { maxStretch } from "../screen/gap.ts";
+import { exactModel, type ExactRule } from "./index.ts";
+
+/**
+ * The part of a persistent model of the package `highs` that `solveExact` uses.
+ * The library does not import `highs`. The caller gives the loaded runtime, so `highs` stays a devDependency.
+ */
+export interface HighsModelLike {
+  readonly options: { set(values: Readonly<Record<string, string | number | boolean>>): unknown };
+  readonly info: { get(name: string): number | bigint };
+  run(): unknown;
+  getModelStatus(): number;
+  getObjectiveValue(): number;
+  getSolution(): { readonly colValue: ArrayLike<number> };
+  getDimensions(): { readonly numCols: number };
+  getColName(index: number): string;
+  dispose(): void;
+}
+
+/** The part of the loaded runtime of the package `highs` that `solveExact` uses. */
+export interface HighsLike {
+  createModel(source: { readonly format: "lp"; readonly data: string }): HighsModelLike;
+  readonly constants: { readonly modelStatus: { readonly optimal: number; readonly timeLimit: number } };
+}
+
+/** The result of one solve of the exact model. */
+export interface ExactSolve {
+  /** The model status of HiGHS, for example `optimal` or `time-limit`. */
+  readonly status: string;
+  /** This value is `true` when HiGHS proved the optimum, with a relative MIP gap of 0. */
+  readonly proven: boolean;
+  /** The objective of the best solution, or `null` without a solution. */
+  readonly objective: number | null;
+  /** The dual bound of HiGHS at the end of the solve, or `null` when HiGHS gives none. */
+  readonly bound: number | null;
+  /** The relative MIP gap of HiGHS at the end of the solve: `|objective - bound| / |objective|`. It is `null` without a solution. */
+  readonly mipGap: number | null;
+  /** The time of the solve, in seconds, without the time to make the model. */
+  readonly seconds: number;
+  /** The size of the model: the edges with a way in the stretch limit, the binary variables and the constraints. */
+  readonly edges: number;
+  readonly binaries: number;
+  readonly rows: number;
+  /** The plan of the best solution. It is empty without a solution. */
+  readonly plan: HighwayPlan;
+  /** The ink saved (B1) of the model itself: `1 - (the ink of the open links) / (the length of the ways)`. It is `null` without a solution. */
+  readonly modelB1: number | null;
+}
+
+/** This function gives a finite number of the info of HiGHS, or `null`. */
+function infoNumber(model: HighsModelLike, name: string): number | null {
+  try {
+    const v = Number(model.info.get(name));
+    return Number.isFinite(v) ? v : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * This function makes the exact model of a graph and solves it with HiGHS.
+ * The relative MIP gap is 0, and the time limit is `seconds`.
+ * It gives the status, the proof, the bound, the gap, the time and the plan of the best solution.
+ */
+export function solveExact(highs: HighsLike, graph: Graph, o: { readonly stretch: number; readonly rule: ExactRule; readonly seconds: number }): ExactSolve {
+  const model = exactModel(graph, { stretch: o.stretch, rule: o.rule });
+  const size = { edges: model.edges, binaries: model.columns, rows: model.rows };
+  const m = highs.createModel({ format: "lp", data: model.lp });
+  try {
+    m.options.set({ time_limit: o.seconds, output_flag: false, mip_rel_gap: 0 });
+    const start = Date.now();
+    m.run();
+    const seconds = (Date.now() - start) / 1000;
+    const code = m.getModelStatus();
+    const statuses = highs.constants.modelStatus;
+    const status = code === statuses.optimal ? "optimal" : code === statuses.timeLimit ? "time-limit" : `status-${code}`;
+    // The value 2 of `primal_solution_status` is a feasible solution.
+    const found = infoNumber(m, "primal_solution_status") === 2;
+    if (!found) return { status, proven: false, objective: null, bound: infoNumber(m, "mip_dual_bound"), mipGap: null, seconds, ...size, plan: { highways: [] }, modelB1: null };
+    const values = m.getSolution().colValue;
+    const byName = new Map<string, number>();
+    const cols = m.getDimensions().numCols;
+    for (let i = 0; i < cols; i++) byName.set(m.getColName(i), values[i]!);
+    const value = (name: string): number => byName.get(name) ?? 0;
+    const plan = model.decode(value);
+    // The ink is the sum of the lengths of the open links (`y`), and the length of the ways is the sum of the lengths of the arcs (`x`).
+    let ink = 0;
+    let ways = 0;
+    for (const [name, len] of model.lengths) {
+      if (value(name) <= 0.5) continue;
+      if (name.startsWith("y")) ink += len;
+      else ways += len;
+    }
+    const mipGap = infoNumber(m, "mip_gap");
+    return {
+      status,
+      proven: code === statuses.optimal,
+      objective: m.getObjectiveValue(),
+      bound: infoNumber(m, "mip_dual_bound"),
+      mipGap: code === statuses.optimal ? (mipGap ?? 0) : mipGap,
+      seconds,
+      ...size,
+      plan,
+      modelB1: ways > 0 ? Math.max(0, 1 - ink / ways) : 0,
+    };
+  } finally {
+    m.dispose();
+  }
+}
+
+/** The routes of a plan after `follow`, with the ink saved (B1) and the largest bundle stretch (B3) against the routes of `corners`. */
+export interface PlanMeasures {
+  readonly routes: readonly Route[];
+  readonly b1: number;
+  readonly b3max: number;
+}
+
+/** This function routes a plan with `follow`, and gives B1 and the largest B3 of the routes. The base of B3 is the router `corners`. */
+export function planMeasures(graph: Graph, plan: HighwayPlan): PlanMeasures {
+  const routes = follow(graph, plan).routes;
+  const corners = asRouter(getStrategy(STRATEGIES, "router", "corners")).route(graph).routes;
+  return { routes, b1: inkSaved(routes), b3max: maxStretch(routes, corners) };
+}

package/src/bench/measures/index.ts

@@ -9,3 +9,4 @@ export * from "./room.ts";
 export * from "./pareto.ts";
 export * from "./order.ts";
 export * from "./highways.ts";
+export * from "./lanes.ts";

package/src/bench/measures/lanes.ts

@@ -0,0 +1,304 @@
+import { dist, frechet, pointSegmentDistance, segmentsCross, type Point } from "../../geom.ts";
+import { Grid } from "../../grid.ts";
+import type { Graph, Result, Route } from "../../model.ts";
+import { laneRoutes, runKey, segmentsOf, type SegmentGraph } from "../../segments.ts";
+import { measureRouteFaults } from "../links.ts";
+import { segmentKey } from "./routes.ts";
+import { quantile } from "./stats.ts";
+
+/**
+ * The lane width of the lane measures, in units of the board. The room bench opens the lanes at the same width (`spacing` of `measureBoard`).
+ * R12 also uses it as the smallest correct distance between two parallel legs.
+ */
+export const MEASURE_LANE_WIDTH = 4;
+
+/** The routes of a result with each shared segment open: one lane for each edge. */
+export interface OpenLanes {
+  /** The segments of the result. The shared segments are the runs and the trunks of the bundles. */
+  readonly graph: SegmentGraph;
+  /** The lane route of each edge, from `laneRoutes`. Without a shared segment, the lane routes are the routes. */
+  readonly lanes: readonly Route[];
+  /** The distance between two lanes. */
+  readonly width: number;
+}
+
+/** This function opens each shared segment of a result: each edge of a run or of a trunk gets its own lane, `width` apart. */
+export function openLanes(result: Result, width: number = MEASURE_LANE_WIDTH): OpenLanes {
+  const graph = segmentsOf(result);
+  const open = new Set(graph.segments.filter((s) => s.count > 1).map((s) => runKey(s.edges)));
+  return { graph, lanes: laneRoutes(graph, open, width), width };
+}
+
+/** One drawn segment and the sorted ids of the edges that draw it. */
+interface Leg {
+  readonly a: Point;
+  readonly b: Point;
+  readonly edges: string;
+}
+
+/** This function gives each drawn segment of the routes one time, with the edges that draw it. A segment shorter than the grain of `segmentKey` is not a leg. */
+function legsOf(routes: readonly Route[]): Leg[] {
+  const byKey = new Map<string, { a: Point; b: Point; edges: Set<string> }>();
+  for (const r of routes) {
+    for (let i = 1; i < r.points.length; i++) {
+      const a = r.points[i - 1]!;
+      const b = r.points[i]!;
+      const k = segmentKey(a, b);
+      if (k === undefined) continue;
+      const leg = byKey.get(k);
+      if (leg) leg.edges.add(r.edge);
+      else byKey.set(k, { a, b, edges: new Set([r.edge]) });
+    }
+  }
+  return [...byKey.values()].map((l) => ({ a: l.a, b: l.b, edges: [...l.edges].sort().join("\u0000") }));
+}
+
+/** This function gives the distance between the segments `ab` and `cd`. It is 0 when they cross or touch. */
+function segmentDistance(a: Point, b: Point, c: Point, d: Point): number {
+  if (segmentsCross(a, b, c, d)) return 0;
+  return Math.min(pointSegmentDistance(a, c, d), pointSegmentDistance(b, c, d), pointSegmentDistance(c, a, b), pointSegmentDistance(d, a, b));
+}
+
+/** This function gives the length of the union of intervals. */
+function unionLength(intervals: [number, number][]): number {
+  intervals.sort((p, q) => p[0] - q[0]);
+  let sum = 0;
+  let lo = Number.NEGATIVE_INFINITY;
+  let hi = Number.NEGATIVE_INFINITY;
+  for (const [a, b] of intervals) {
+    if (a > hi) {
+      if (hi > lo) sum += hi - lo;
+      lo = a;
+      hi = b;
+    } else hi = Math.max(hi, b);
+  }
+  if (hi > lo) sum += hi - lo;
+  return sum;
+}
+
+/**
+ * This function gives the lane separation of the routes (R12 of MEAS0): the share of the ink that runs too near a parallel leg of other edges.
+ *
+ * A leg is a drawn segment of `S`, and a leg that several routes share counts one time, as in B1. Two legs are near when four things are true.
+ * The sets of their edges are different. They are within `maxAngle` degrees of parallel. Their projections overlap. Their distance is less than `near`.
+ *
+ * `ns = Σ_s length(the part of s that the projections of its near legs cover) / ink(S)`. Each part counts one time, so the scale is 0 to 1.
+ * Lower is better. Routes without ink give 0. A grid of buckets finds the near legs, so the cost is `n log n` for an even density.
+ */
+export function routeSeparation(routes: readonly Route[], near: number = MEASURE_LANE_WIDTH, maxAngle = 5): number {
+  const legs = legsOf(routes);
+  let ink = 0;
+  for (const l of legs) ink += dist(l.a, l.b);
+  if (ink <= 0) return 0;
+  const grid = new Grid<number>(Math.max(16, 4 * near));
+  legs.forEach((l, i) => grid.addSegment(i, l.a, l.b));
+  const sin = Math.sin((maxAngle * Math.PI) / 180);
+  let close = 0;
+  legs.forEach((s, i) => {
+    const length = dist(s.a, s.b);
+    const ux = (s.b.x - s.a.x) / length;
+    const uy = (s.b.y - s.a.y) / length;
+    const cover: [number, number][] = [];
+    grid.querySegment(s.a, s.b, near, (j) => {
+      const t = legs[j]!;
+      if (j === i || t.edges === s.edges) return;
+      const tx = t.b.x - t.a.x;
+      const ty = t.b.y - t.a.y;
+      const tl = Math.hypot(tx, ty);
+      if (Math.abs(ux * ty - uy * tx) > sin * tl) return;
+      const p = (t.a.x - s.a.x) * ux + (t.a.y - s.a.y) * uy;
+      const q = (t.b.x - s.a.x) * ux + (t.b.y - s.a.y) * uy;
+      const lo = Math.max(0, Math.min(p, q));
+      const hi = Math.min(length, Math.max(p, q));
+      if (hi - lo <= 1e-9 || segmentDistance(s.a, s.b, t.a, t.b) >= near) return;
+      cover.push([lo, hi]);
+    });
+    close += unionLength(cover);
+  });
+  return Math.min(1, close / ink);
+}
+
+/**
+ * This function gives the orthogonality of the routes (R14 of MEAS0): `orth = Σ L(legs within maxAngle degrees of an axis) / Σ_e L(r_e)`.
+ * Each route counts its own legs, also on a shared segment. The scale is 0 to 1, and higher is better for an orthogonal style.
+ * Routes without length give 1. The cost is linear.
+ */
+export function orthogonality(routes: readonly Route[], maxAngle = 1): number {
+  const tan = Math.tan((maxAngle * Math.PI) / 180);
+  let total = 0;
+  let straight = 0;
+  for (const r of routes) {
+    for (let i = 1; i < r.points.length; i++) {
+      const dx = Math.abs(r.points[i]!.x - r.points[i - 1]!.x);
+      const dy = Math.abs(r.points[i]!.y - r.points[i - 1]!.y);
+      const l = Math.hypot(dx, dy);
+      total += l;
+      if (Math.min(dx, dy) <= tan * Math.max(dx, dy)) straight += l;
+    }
+  }
+  return total > 0 ? straight / total : 1;
+}
+
+/**
+ * This function counts the lane crossings of the segments of a result (B5 of MEAS0): the pairs of edges whose lane order flips.
+ * Along the route of each edge `e`, it takes the shared segments in order. On each one, another edge `f` is on the left or on the right of `e`, in the way of `e`.
+ *
+ * A pair `(e, f)` counts one time when the side of `f` changes from one shared segment of both edges to the next one.
+ * Lower is better. A result without shared segments gives 0. The cost is the sum of the squares of the edge counts of the shared segments.
+ */
+export function laneCrossings(graph: SegmentGraph): number {
+  const shared = new Map(graph.segments.filter((s) => s.count > 1).map((s) => [s.id, s] as const));
+  const flipped = new Set<string>();
+  for (const path of graph.paths) {
+    const side = new Map<string, number>();
+    for (const ref of path.segments) {
+      const s = shared.get(ref.segment);
+      if (!s) continue;
+      s.edges.forEach((f, lane) => {
+        if (f === path.edge) return;
+        const now = Math.sign(lane - ref.lane) * (ref.reverse ? -1 : 1);
+        const before = side.get(f);
+        if (before !== undefined && before !== now) flipped.add(path.edge < f ? `${path.edge}\u0000${f}` : `${f}\u0000${path.edge}`);
+        side.set(f, now);
+      });
+    }
+  }
+  return flipped.size;
+}
+
+/** This function adds the key of each cell of side `u` that the segment `ab` touches, with an exact walk over the cells (Amanatides and Woo, 1987). */
+function touchCells(a: Point, b: Point, u: number, cells: Set<string>): void {
+  let i = Math.floor(a.x / u);
+  let j = Math.floor(a.y / u);
+  const iEnd = Math.floor(b.x / u);
+  const jEnd = Math.floor(b.y / u);
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const sx = Math.sign(dx);
+  const sy = Math.sign(dy);
+  const deltaX = dx !== 0 ? u / Math.abs(dx) : Number.POSITIVE_INFINITY;
+  const deltaY = dy !== 0 ? u / Math.abs(dy) : Number.POSITIVE_INFINITY;
+  let maxX = dx !== 0 ? ((sx > 0 ? (i + 1) * u : i * u) - a.x) / dx : Number.POSITIVE_INFINITY;
+  let maxY = dy !== 0 ? ((sy > 0 ? (j + 1) * u : j * u) - a.y) / dy : Number.POSITIVE_INFINITY;
+  cells.add(`${i},${j}`);
+  while (i !== iEnd || j !== jEnd) {
+    // At a corner of four cells, the walk steps on both axes, so it does not touch the two side cells.
+    const moveX = j === jEnd || (i !== iEnd && maxX <= maxY);
+    const moveY = i === iEnd || (j !== jEnd && maxY <= maxX);
+    if (moveX) {
+      i += sx;
+      maxX += deltaX;
+    }
+    if (moveY) {
+      j += sy;
+      maxY += deltaY;
+    }
+    cells.add(`${i},${j}`);
+  }
+}
+
+/**
+ * This function gives the occupied area of the routes (B7 of MEAS0): `moa = cells that S touches / cells that the straight lines touch`.
+ * The cells are squares of side `unit` from the origin, and `unit` is `u` of the board (`boardUnit`). The straight line of an edge joins the two ends of its route.
+ * The scale is a ratio, and lower is better. Routes without a straight line give 1. The cost is linear in the cells.
+ */
+export function occupiedArea(routes: readonly Route[], unit: number): number {
+  const u = unit > 0 ? unit : 1;
+  const drawn = new Set<string>();
+  const straight = new Set<string>();
+  for (const r of routes) {
+    const p = r.points;
+    if (p.length < 2) continue;
+    for (let i = 1; i < p.length; i++) touchCells(p[i - 1]!, p[i]!, u, drawn);
+    touchCells(p[0]!, p[p.length - 1]!, u, straight);
+  }
+  return straight.size > 0 ? drawn.size / straight.size : 1;
+}
+
+/** The run profile of a result (B8 of MEAS0). */
+export interface RunProfile {
+  /** The number of shared segments: the runs and the trunks of the bundles with two edges or more. */
+  readonly runs: number;
+  /** The median of the edges of each shared segment. It is 0 without a shared segment. */
+  readonly median: number;
+  /** The most edges of one shared segment. It is 0 without a shared segment. */
+  readonly max: number;
+}
+
+/** This function gives the run profile of a result (B8 of MEAS0): the shared segments, and the median and the most edges of each. The cost is linear. */
+export function runProfile(graph: SegmentGraph): RunProfile {
+  const counts = graph.segments.filter((s) => s.count > 1).map((s) => s.count);
+  if (counts.length === 0) return { runs: 0, median: 0, max: 0 };
+  return { runs: counts.length, median: quantile(counts, 0.5), max: Math.max(...counts) };
+}
+
+/** The lane fidelity of a result (B9 of MEAS0). */
+export interface LaneFidelity {
+  /** The median of `lf(e)` over the edges with a shared segment. */
+  readonly median: number;
+  /** The largest `lf(e)`. */
+  readonly max: number;
+  /** The number of edges with a shared segment. */
+  readonly edges: number;
+}
+
+/**
+ * This function gives the lane fidelity (B9 of MEAS0): `lf(e) = frechet(lane(e), r_e) / (width · k / 2)` for each edge `e` with a shared segment.
+ * `lane(e)` is the lane route of `openLanes`, `r_e` is the route, and `k` is the edge count of the widest shared segment of `e`.
+ * `frechet` is the discrete Fréchet distance of the points. A value of 1 or less is correct, and lower is better.
+ * It gives `undefined` when no edge has a shared segment. The cost is quadratic in the points of each route.
+ */
+export function laneFidelity(routes: readonly Route[], open: OpenLanes): LaneFidelity | undefined {
+  const count = new Map(open.graph.segments.map((s) => [s.id, s.count] as const));
+  const lanes = new Map(open.lanes.map((r) => [r.edge, r.points] as const));
+  const own = new Map(routes.map((r) => [r.edge, r.points] as const));
+  const values: number[] = [];
+  for (const path of open.graph.paths) {
+    let k = 0;
+    for (const ref of path.segments) k = Math.max(k, count.get(ref.segment) ?? 0);
+    const lane = lanes.get(path.edge);
+    const route = own.get(path.edge);
+    if (k < 2 || !lane || !route || open.width <= 0) continue;
+    values.push(frechet(lane, route) / ((open.width * k) / 2));
+  }
+  if (values.length === 0) return undefined;
+  return { median: quantile(values, 0.5), max: Math.max(...values), edges: values.length };
+}
+
+/**
+ * This function counts the lane routes that go through a box that is not one of their ends (M4 of MEAS0).
+ * It is the count `laneThrough` of the room bench (`measureBoard`), for the lanes of any result. Lower is better. The cost is `n log n`.
+ */
+export function lanesThrough(graph: Graph, open: OpenLanes): number {
+  return measureRouteFaults(graph, { routes: open.lanes }).through;
+}
+
+/**
+ * This function gives the area of a result (M1 of MEAS0) for a router: the growth of the board that the open lanes need.
+ * The value is the area of the bounding box of the boxes and the lane routes. The function divides it by the area of the bounding box of the boxes.
+ *
+ * It is the room form `area(open) / area(packed)` with the boxes as they are. The scale is a ratio of 1 or more, and lower is better.
+ * A board without area gives 1. The cost is linear.
+ */
+export function laneArea(graph: Graph, open: OpenLanes): number {
+  let x0 = Number.POSITIVE_INFINITY;
+  let y0 = Number.POSITIVE_INFINITY;
+  let x1 = Number.NEGATIVE_INFINITY;
+  let y1 = Number.NEGATIVE_INFINITY;
+  for (const n of graph.nodes) {
+    x0 = Math.min(x0, n.box.x);
+    y0 = Math.min(y0, n.box.y);
+    x1 = Math.max(x1, n.box.x + n.box.w);
+    y1 = Math.max(y1, n.box.y + n.box.h);
+  }
+  const packed = (x1 - x0) * (y1 - y0);
+  if (!(packed > 0)) return 1;
+  for (const r of open.lanes)
+    for (const p of r.points) {
+      x0 = Math.min(x0, p.x);
+      y0 = Math.min(y0, p.y);
+      x1 = Math.max(x1, p.x);
+      y1 = Math.max(y1, p.y);
+    }
+  return ((x1 - x0) * (y1 - y0)) / packed;
+}

package/src/bench/measures/levels.ts

@@ -1,5 +1,5 @@
-import { center, dist } from "../../geom.ts";
-import type { Graph, Level } from "../../model.ts";
+import { center, dist, pointBoxDistance, polylineLength, type Box, type Point } from "../../geom.ts";
+import type { Graph, Level, Route } from "../../model.ts";
 import { kendallTau } from "./stats.ts";
 
 /** This function gives the levels in the order of their depth, from the far view to the near view. */
@@ -101,3 +101,87 @@ export function orderStability(graph: Graph, levels: readonly Level[]): number {
   }
   return n ? sum / n : 1;
 }
+
+/** This function gives the points of a polyline at most `step` apart: each vertex, and evenly spaced points on each longer segment. */
+function samplePolyline(p: readonly Point[], step: number): Point[] {
+  const out: Point[] = [];
+  for (let i = 0; i < p.length; i++) {
+    const b = p[i]!;
+    if (i > 0) {
+      const a = p[i - 1]!;
+      const n = Math.ceil(dist(a, b) / step);
+      for (let k = 1; k < n; k++) out.push({ x: a.x + ((b.x - a.x) * k) / n, y: a.y + ((b.y - a.y) * k) / n });
+    }
+    out.push(b);
+  }
+  return out;
+}
+
+/** This function gives the Hausdorff distance between two sets of points. Both sets have one point or more. */
+function hausdorff(a: readonly Point[], b: readonly Point[]): number {
+  const directed = (p: readonly Point[], q: readonly Point[]): number => {
+    let worst = 0;
+    for (const x of p) {
+      let best = Number.POSITIVE_INFINITY;
+      for (const y of q) best = Math.min(best, dist(x, y));
+      worst = Math.max(worst, best);
+    }
+    return worst;
+  };
+  return Math.max(directed(a, b), directed(b, a));
+}
+
+/** The number of points of the sample of one polyline for the link agreement, at most. */
+const AGREEMENT_SAMPLES = 64;
+
+/**
+ * This function gives the link agreement of the levels with groups (Z9 of MEAS0).
+ * `la = mean over links of hausdorff(link, routes of its edges outside the two items) / u`, with `u` the argument `unit`.
+ * The edges of a link are the edges between a node of one item and a node of the other item, in either direction.
+ *
+ * The function samples each polyline at points `u / 4` apart, with at most 64 points for each polyline. It keeps the points outside the boxes of the two items.
+ * A link without such points on both sides does not count. It gives `undefined` when no link counts.
+ * The value has no unit, and lower is better. The cost is quadratic in the points of each link.
+ */
+export function linkAgreement(graph: Graph, levels: readonly Level[], routes: readonly Route[], unit: number): number | undefined {
+  const u = unit > 0 ? unit : 1;
+  const endsOf = new Map(graph.edges.map((e) => [e.id, [e.source.node, e.target.node] as const]));
+  const sample = (p: readonly Point[], boxes: readonly Box[]): Point[] => {
+    const step = Math.max(u / 4, polylineLength(p) / AGREEMENT_SAMPLES);
+    return samplePolyline(p, step).filter((q) => boxes.every((b) => pointBoxDistance(q, b) > 0));
+  };
+  let sum = 0;
+  let n = 0;
+  for (const level of levels) {
+    if (!level.items.some((i) => i.nodes.length > 1)) continue;
+    const itemOf = itemIndex(level);
+    const indexOf = new Map(level.items.map((it, i) => [it.id, i] as const));
+    // The edges between each pair of items, by the key of the pair.
+    const between = new Map<string, Route[]>();
+    for (const r of routes) {
+      const ends = endsOf.get(r.edge);
+      if (!ends) continue;
+      const i = itemOf.get(ends[0]);
+      const j = itemOf.get(ends[1]);
+      if (i === undefined || j === undefined || i === j) continue;
+      const key = i < j ? `${i},${j}` : `${j},${i}`;
+      const list = between.get(key);
+      if (list) list.push(r);
+      else between.set(key, [r]);
+    }
+    for (const link of level.links) {
+      const i = indexOf.get(link.source);
+      const j = indexOf.get(link.target);
+      if (i === undefined || j === undefined || i === j) continue;
+      const mine = between.get(i < j ? `${i},${j}` : `${j},${i}`);
+      if (!mine) continue;
+      const boxes = [level.items[i]!.box, level.items[j]!.box];
+      const a = sample(link.points, boxes);
+      const b = mine.flatMap((r) => sample(r.points, boxes));
+      if (a.length === 0 || b.length === 0) continue;
+      sum += hausdorff(a, b) / u;
+      n++;
+    }
+  }
+  return n > 0 ? sum / n : undefined;
+}

package/src/bench/screen/activation.ts

@@ -0,0 +1,3 @@
+// The activation test of a screen (ACTIVATION): did the idea of a candidate run on the input?
+// `outputHash`, `outputGroups` and `exercised` come from `@mark1russell7/layout-contract` (PORTFOLIO-FIT). `docs/PROMOTION.md` gives the rules.
+export { exercised, outputGroups, outputHash, type ExerciseEvidence, type HashOptions, type OutputGroup } from "@mark1russell7/layout-contract";

package/src/bench/screen/bounds.ts

@@ -0,0 +1,140 @@
+import { quantile } from "../measures/stats.ts";
+import { GAP_BASELINES, type ExactOptimum, type GapRule } from "./gap.ts";
+
+/**
+ * The interval of the optimum B1 of one solve (EXACT-BOUNDS). The low end is the B1 of the best solution of HiGHS.
+ * The high end comes from the dual bound. For a proven optimum, the two ends are equal.
+ */
+export interface OptimumInterval {
+  readonly lo: number;
+  readonly hi: number;
+  readonly proven: boolean;
+}
+
+/**
+ * This function gives the interval of the optimum B1 of a solve, or `undefined` without a solution.
+ * The high end is `1 - (1 - b1) × bound / objective`. It supposes that the ink of the optimum is at least `bound / objective` times the ink of the best solution,
+ * with routes of the same length. The objective of the model is the ink plus a small cost of the length, so the ratio is a ratio of the ink.
+ * Without a positive bound, the high end is 1.
+ */
+export function optimumInterval(o: ExactOptimum): OptimumInterval | undefined {
+  if (o.b1 === null || o.objective === null) return undefined;
+  if (o.proven) return { lo: o.b1, hi: o.b1, proven: true };
+  const ratio = o.bound !== null && o.bound > 0 && o.objective > 0 ? Math.min(1, o.bound / o.objective) : 0;
+  return { lo: o.b1, hi: Math.min(1, Math.max(o.b1, 1 - (1 - o.b1) * ratio)), proven: false };
+}
+
+/** The interval of the gap closed of one run against an interval of the optimum. */
+export interface GapInterval {
+  readonly lo: number;
+  readonly hi: number;
+  readonly mid: number;
+  readonly width: number;
+}
+
+/**
+ * This function gives the interval of the gap closed `(b1 - base) / (optimum - base)` over the interval of the optimum.
+ * For a run above the baseline, the high end of the optimum gives the low end of the gap closed. The low end of the optimum gives the high end.
+ * It gives `undefined` when the low end of the optimum is at the baseline or below it, because then the gap closed has no limit.
+ */
+export function gapInterval(b1: number, base: number, optimum: { readonly lo: number; readonly hi: number }): GapInterval | undefined {
+  const dLo = optimum.lo - base;
+  const dHi = optimum.hi - base;
+  if (!(dLo > 1e-9)) return undefined;
+  const a = (b1 - base) / dHi;
+  const b = (b1 - base) / dLo;
+  const lo = Math.min(a, b);
+  const hi = Math.max(a, b);
+  return { lo, hi, mid: (lo + hi) / 2, width: hi - lo };
+}
+
+/** The values of one run that the bounds read: B1, the largest stretch of the model and the flag of mixed collections. */
+export interface BoundsRun {
+  readonly b1: number;
+  readonly stretch: number;
+  readonly mixed: boolean;
+}
+
+/** The gap closed of one strategy at one size, one rule and one cap, over the inputs. */
+export interface BoundsRow {
+  readonly strategy: string;
+  /** The number of inputs, and the number of inputs where the run has a value. */
+  readonly inputs: number;
+  readonly values: number;
+  /** The medians over the inputs with a value: the midpoint, the low end, the high end and the width of the interval. */
+  readonly mid: number;
+  readonly lo: number;
+  readonly hi: number;
+  readonly width: number;
+}
+
+/** The gap closed of each strategy at one size, one rule and one cap, sorted by the median of the midpoint. */
+export interface BoundsCell {
+  readonly nodes: number;
+  readonly rule: GapRule;
+  readonly cap: number;
+  /** The counts of the solves: the inputs, the proven optima, the solves with a bound only, and the solves without a solution. */
+  readonly inputs: number;
+  readonly proven: number;
+  readonly bounded: number;
+  readonly none: number;
+  /** The median width of the interval of the optimum B1, over the solves with a solution. */
+  readonly optimumWidth: number;
+  readonly rows: readonly BoundsRow[];
+}
+
+/**
+ * This function gives the gap closed of each strategy for each size, rule and cap of the optima.
+ * A run has a value when it obeys the rule and when its stretch is at or below the cap. The solve must also have a solution.
+ * The rule `collection` refuses a run with a shared segment that holds edges of two collections.
+ * The baseline of each rule is the run of `GAP_BASELINES` on the same input, with the prefix `hw:` for a highway strategy.
+ * The rows sort by the median of the midpoint, from high to low. A strategy with a value on fewer than half of the inputs comes after the others.
+ */
+export function boundsCells(runs: ReadonlyMap<string, ReadonlyMap<string, BoundsRun>>, optima: readonly ExactOptimum[]): BoundsCell[] {
+  const keys = [...new Set(optima.map((o) => `${o.nodes}|${o.rule}|${o.cap}`))];
+  const cells: BoundsCell[] = [];
+  const baseName = (rule: GapRule): string => (rule === "all" ? `hw:${GAP_BASELINES.all}` : GAP_BASELINES.collection);
+  for (const key of keys) {
+    const [n, rule, c] = key.split("|") as [string, GapRule, string];
+    const nodes = Number(n);
+    const cap = Number(c);
+    const mine = optima.filter((o) => o.nodes === nodes && o.rule === rule && o.cap === cap && runs.has(o.input));
+    const intervals = new Map(mine.flatMap((o) => (optimumInterval(o) ? [[o.input, optimumInterval(o)!] as const] : [])));
+    const names = [...new Set(mine.flatMap((o) => [...runs.get(o.input)!.keys()]))].sort();
+    const rows: BoundsRow[] = names.map((strategy) => {
+      const vs: GapInterval[] = [];
+      for (const o of mine) {
+        const row = runs.get(o.input)!;
+        const r = row.get(strategy);
+        const base = row.get(baseName(rule));
+        const opt = intervals.get(o.input);
+        if (r === undefined || base === undefined || opt === undefined) continue;
+        if ((rule === "collection" && r.mixed) || r.stretch > cap + 1e-9) continue;
+        const g = gapInterval(r.b1, base.b1, opt);
+        if (g !== undefined) vs.push(g);
+      }
+      const med = (f: (g: GapInterval) => number): number => quantile(vs.map(f), 0.5);
+      return { strategy, inputs: mine.length, values: vs.length, mid: med((g) => g.mid), lo: med((g) => g.lo), hi: med((g) => g.hi), width: med((g) => g.width) };
+    });
+    const few = (r: BoundsRow): number => (2 * r.values < r.inputs || r.values === 0 ? 1 : 0);
+    rows.sort((a, b) => few(a) - few(b) || (Number.isNaN(b.mid) ? -Infinity : b.mid) - (Number.isNaN(a.mid) ? -Infinity : a.mid) || (a.strategy < b.strategy ? -1 : 1));
+    const widths = [...intervals.values()].map((i) => i.hi - i.lo);
+    cells.push({
+      nodes,
+      rule,
+      cap,
+      inputs: mine.length,
+      proven: mine.filter((o) => o.proven).length,
+      bounded: mine.filter((o) => !o.proven && intervals.has(o.input)).length,
+      none: mine.filter((o) => !intervals.has(o.input)).length,
+      optimumWidth: quantile(widths, 0.5),
+      rows,
+    });
+  }
+  return cells.sort((a, b) => a.nodes - b.nodes || (a.rule < b.rule ? -1 : a.rule > b.rule ? 1 : 0) || a.cap - b.cap);
+}
+
+/** This function gives the strategies that rank in a cell: the first `k` rows with a value on at least half of the inputs. */
+export function topOf(cell: BoundsCell, k = 5): BoundsRow[] {
+  return cell.rows.filter((r) => r.values > 0 && 2 * r.values >= r.inputs).slice(0, k);
+}