@mark1russell7/highways 0.3.0 → 0.4.1

package/package.json

@@ -9,7 +9,7 @@
     "directory": "packages/core"
   },
   "homepage": "https://mark1russell7.github.io/highways/",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "type": "module",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -38,9 +38,12 @@
     "build": "tsdown",
     "test": "vitest run",
     "bench": "node scripts/bench.ts",
+    "ideas": "node scripts/ideas.ts",
     "bench:join": "node scripts/bench-join.ts",
     "profile": "node scripts/profile.ts",
     "levels": "node scripts/levels.ts",
+    "screen": "node scripts/screen.ts",
+    "screen:inputs": "node scripts/screen-inputs.ts",
     "test:watch": "vitest",
     "typecheck": "tsc -p tsconfig.json && tsc -p tsconfig.test.json"
   }

package/src/bench/compare.ts

@@ -1,9 +1,12 @@
 import type { CurveSegment } from "../curves/model.ts";
+import { polylineLength } from "../geom.ts";
 import type { Graph, Result } from "../model.ts";
 import type { Section } from "../sections.ts";
+import { runKey, segmentsOf } from "../segments.ts";
 import { STRATEGIES } from "../strategies/builtins.ts";
-import { asRouter, getStrategy, listStrategies, type Registry, type Step } from "../strategies/model.ts";
+import { asRouter, getStrategy, listStrategies, type LaneBoard, type Registry, type Step } from "../strategies/model.ts";
 import { peakCurvature } from "./curves.ts";
+import { measureLevelFaults, sumFaults } from "./links.ts";
 import { paretoFront, type Objective } from "./measures/pareto.ts";
 import { boardUnit } from "./measures/routes.ts";
 import { changeGraph, routeStability } from "./measures/stability.ts";
@@ -20,8 +23,30 @@ function medianOf(values: readonly number[]): number {
   return a === b ? a : (a + b) / 2;
 }
 
-/** The steps that `compareStep` compares. The step `room` takes a packed board, not a graph, so it is not in the list. */
-export type CompareStep = Exclude<Step, "room">;
+/**
+ * This function gives the measures of the level links of a result: the links through a box (`Z3.through`) and the length of all links (`Z3.length`).
+ * A result without a level with groups gives no measure.
+ */
+function levelLinkMeasures(result: Result): Record<string, number> {
+  const levels = (result.levels ?? []).filter((l) => l.items.some((i) => i.nodes.length > 1));
+  if (levels.length === 0) return {};
+  const length = levels.reduce((sum, l) => sum + l.links.reduce((s, k) => s + polylineLength(k.points), 0), 0);
+  return { "Z3.through": sumFaults(measureLevelFaults(result)).through, "Z3.length": length };
+}
+
+/** This function gives the lanes of a result with each shared segment open. A result without shared segments gives `undefined`. */
+function laneBoard(result: Result, lanes: { readonly width: number; readonly maxWidth?: number }): LaneBoard | undefined {
+  const graph = segmentsOf(result);
+  const open = new Set(graph.segments.filter((s) => s.count > 1).map((s) => runKey(s.edges)));
+  if (open.size === 0) return undefined;
+  return { graph, open, width: lanes.width, ...(lanes.maxWidth === undefined ? {} : { maxWidth: lanes.maxWidth }) };
+}
+
+/**
+ * The steps that `compareStep` compares. The step `room` takes a packed board, not a graph, so it is not in the list.
+ * The step `highway` gives a plan, not routes. The screen routes each plan with `follow` and compares it as a router.
+ */
+export type CompareStep = Exclude<Step, "room" | "highway">;
 
 /** The steps that `compareStep` compares, in the order of the pipeline. */
 export const COMPARE_STEPS: readonly CompareStep[] = ["group", "router", "curve"];
@@ -34,6 +59,11 @@ export interface CompareOptions {
   readonly options?: Readonly<Record<string, object>>;
   /** The router whose routes the step `curve` draws. The default is `corners`, as in `runSuite`. */
   readonly curveRouter?: string;
+  /**
+   * With this value, the step `curve` opens each shared segment of the routes of `curveRouter`, and each curve draws the lanes of `laneRoutes`.
+   * So the curve `highway` bends the lanes of a bundle as one. Without it, each curve draws the routes. A router without shared segments gives the routes in both cases.
+   */
+  readonly lanes?: { readonly width: number; readonly maxWidth?: number };
   /** The seed of the small change of the graph for the stability measures (Z10 and G9). The default is 1. */
   readonly seed?: number;
   /** The route stability (Z10) routes a changed graph again, so the function measures it only up to this number of nodes. The default is 1000. */
@@ -50,7 +80,10 @@ export interface CompareRow {
   readonly violations: number;
   /** The time of the step, in milliseconds. For the step `router`, it is the median of two routes. */
   readonly ms: number;
-  /** The measures, by the keys of `runSuite`, and `ms`. The step `router` adds `ink`, and the step `curve` adds `C5.peak`. */
+  /**
+   * The measures, by the keys of `runSuite`, and `ms`. The step `router` adds `ink`, and the step `curve` adds `C5.peak`.
+   * A router with zoom levels also gets `Z3.through` and `Z3.length`, the measures of its level links.
+   */
   readonly values: Readonly<Record<string, number>>;
   /** The reason when the strategy did not run, for example a graph over its `maxNodes`. */
   readonly skipped?: string;
@@ -79,7 +112,7 @@ export interface StepComparison {
 
 /**
  * This function runs each strategy of one step on one graph and measures it with the measures of `runSuite`. Then it gives the Pareto front.
- * The step `router` routes the graph with each router. The step `curve` draws the routes of `curveRouter` with each curve.
+ * The step `router` routes the graph with each router. The step `curve` draws the routes of `curveRouter` with each curve, or their lanes with the option `lanes`.
  * The step `group` routes the graph with `sections` on the tree of each grouping rule.
  *
  * The same graph and the same options give the same measures. Only the times change.
@@ -98,7 +131,7 @@ export function compareStep(step: CompareStep, graph: Graph, options: CompareOpt
       if (graph.nodes.length > (strategy.maxNodes ?? Infinity)) return { step, strategy: strategy.name, violations: 0, ms: 0, values: {}, skipped: `over ${strategy.maxNodes} nodes` };
       const router = asRouter(strategy, own[strategy.name]);
       const { row, result } = benchRun(router, name, graph, 2);
-      const values: Record<string, number> = { ...routeMeasures(graph, result, row), ink: row.quality.ink, ms: row.ms };
+      const values: Record<string, number> = { ...routeMeasures(graph, result, row), ...levelLinkMeasures(result), ink: row.quality.ink, ms: row.ms };
       if (change) {
         const s = routeStability(graph, result, router.route(change.graph), { seed });
         values["Z10.mean"] = s.mean;
@@ -111,11 +144,13 @@ export function compareStep(step: CompareStep, graph: Graph, options: CompareOpt
     const router = asRouter(getStrategy(registry, "router", options.curveRouter ?? "corners"));
     const result = router.route(graph);
     const u = boardUnit(graph);
+    const lanes = options.lanes && laneBoard(result, options.lanes);
     const runs = curveRuns(graph, result, listStrategies(registry, "curve"), {
       ...at,
       smooth: new Set(["rounded", "arc", "spline", "smooth", "clothoid", "highway"]),
       normals: new Set(["spline"]),
       curveOptions: own,
+      ...(lanes ? { lanes } : {}),
     });
     rows = runs.map(({ row, drawn, edges }): CompareRow => {
       const peaks = drawn.map((d) => peakCurvature(d) * u);

package/src/bench/measures/bundles.ts

@@ -1,7 +1,8 @@
-import { dist, polylineLength } from "../../geom.ts";
+import { dist, polylineLength, type Point } from "../../geom.ts";
 import { rng } from "../../fixtures.ts";
-import type { Graph, Route } from "../../model.ts";
+import type { Graph, Result, Route } from "../../model.ts";
 import { drawnSegments, segmentKey } from "./routes.ts";
+import { quantile } from "./stats.ts";
 
 /**
  * This function gives the share of the ink that shared segments save (B1 of MEAS0): `inkSaved = 1 - ink(S) / Σ_e L(r_e)`.
@@ -117,3 +118,101 @@ export function ambiguity(graph: Graph, routes: readonly Route[], options: Ambig
   });
   return { value: all ? wrong / all : 0, estimated: !exact };
 }
+
+/** The drawn segments of each route, as keys, in the order of its points. A segment shorter than the grain of `segmentKey` has no key. */
+function routeKeys(routes: readonly Route[]): { readonly keys: Map<string, string[]>; readonly users: Map<string, Set<string>> } {
+  const keys = new Map<string, string[]>();
+  const users = new Map<string, Set<string>>();
+  for (const r of routes) {
+    const own: string[] = [];
+    for (let i = 1; i < r.points.length; i++) {
+      const k = segmentKey(r.points[i - 1]!, r.points[i]!);
+      if (k === undefined) continue;
+      own.push(k);
+      let set = users.get(k);
+      if (!set) users.set(k, (set = new Set()));
+      set.add(r.edge);
+    }
+    keys.set(r.edge, own);
+  }
+  return { keys, users };
+}
+
+/**
+ * This function gives the bundled share of a result (B2 of MEAS0): `count(e : e is in a run or a bundle) / m`.
+ * An edge is also in a bundle when its route shares a drawn segment with the route of another edge. Thus a router without `runs` and `bundles` gets a value too.
+ * The scale is 0 to 1. A higher value is better only in context. The cost is linear.
+ */
+export function bundledShare(result: Result): number {
+  const routes = result.routes;
+  if (routes.length === 0) return 0;
+  const shared = new Set<string>();
+  for (const run of result.runs ?? []) for (const e of run.edges) shared.add(e);
+  for (const b of result.bundles ?? []) if (b.edges.length > 1) for (const e of b.edges) shared.add(e);
+  const { keys, users } = routeKeys(routes);
+  for (const [edge, own] of keys) if (own.some((k) => (users.get(k)?.size ?? 0) > 1)) shared.add(edge);
+  let count = 0;
+  for (const r of routes) if (shared.has(r.edge)) count++;
+  return count / routes.length;
+}
+
+/** The bundle stretch of the routes against base routes (B3 of MEAS0). */
+export interface BundleStretch {
+  /** The median of `st(e) = L(r_e) / L(r*_e)`. A value of 1 is the length of the base route. Lower is better. */
+  readonly median: number;
+  /** The `0.95` quantile of `st(e)`: the tail of long detours that the bundles add. */
+  readonly q95: number;
+  /** The number of edges with a route in both lists and a base route longer than 1 unit. */
+  readonly edges: number;
+}
+
+/**
+ * This function gives the bundle stretch (B3 of MEAS0): `st(e) = L(r_e) / L(r*_e)` for each edge, with `r*_e` the base route of the edge.
+ * The base routes are the routes of `corners` on the same input. An edge without a base route, or with a base route of 1 unit or less, does not count.
+ * The cost is an extra run of the base router, and then linear.
+ */
+export function bundleStretch(routes: readonly Route[], base: readonly Route[]): BundleStretch {
+  const baseLength = new Map<string, number>();
+  for (const r of base) baseLength.set(r.edge, polylineLength(r.points));
+  const st: number[] = [];
+  for (const r of routes) {
+    const b = baseLength.get(r.edge);
+    if (b === undefined || b <= 1 || r.points.length < 2) continue;
+    st.push(polylineLength(r.points) / b);
+  }
+  if (st.length === 0) return { median: 1, q95: 1, edges: 0 };
+  return { median: quantile(st, 0.5), q95: quantile(st, 0.95), edges: st.length };
+}
+
+/**
+ * This function gives the merge angle of the routes (B6 of MEAS0): the largest turn of a lane where it joins or leaves a run, in degrees.
+ * A run is a drawn segment that the routes of two edges or more share. A route joins or leaves a run at a vertex where the edges on its segment change.
+ * One of the two segments at that vertex has two edges or more. The turn is the angle between the two segments.
+ * Routes without a shared segment give 0. The scale is 0 to 180 degrees, and lower is better. The cost is linear.
+ */
+export function mergeAngle(routes: readonly Route[]): number {
+  const { users } = routeKeys(routes);
+  const sig = new Map<string, string>();
+  for (const [k, set] of users) sig.set(k, [...set].sort().join("\u0000"));
+  let max = 0;
+  for (const r of routes) {
+    // The vertices of the route, with each segment that has no key dropped.
+    let prev: { readonly k: string; readonly a: Point; readonly b: Point } | undefined;
+    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;
+      if (prev && sig.get(prev.k) !== sig.get(k) && ((users.get(prev.k)?.size ?? 0) > 1 || (users.get(k)?.size ?? 0) > 1)) {
+        const ux = prev.b.x - prev.a.x;
+        const uy = prev.b.y - prev.a.y;
+        const vx = b.x - a.x;
+        const vy = b.y - a.y;
+        const turn = Math.abs(Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy));
+        max = Math.max(max, (turn * 180) / Math.PI);
+      }
+      prev = { k, a, b };
+    }
+  }
+  return max;
+}

package/src/bench/measures/index.ts

@@ -7,3 +7,4 @@ export * from "./groups.ts";
 export * from "./stability.ts";
 export * from "./room.ts";
 export * from "./pareto.ts";
+export * from "./order.ts";

package/src/bench/measures/order.ts

@@ -0,0 +1,97 @@
+import type { Graph, Result, Route } from "../../model.ts";
+import { shuffleEdges } from "../../order/index.ts";
+import { sameData } from "../run.ts";
+import { inkSaved } from "./bundles.ts";
+import { crossingAngles, detourSpread, drawnSegments } from "./routes.ts";
+import { quantile } from "./stats.ts";
+
+/** The order fragility of a router on one graph (W3 of MEAS3, from WILD-056). */
+export interface OrderFragility {
+  /** The number of random orders. */
+  readonly orders: number;
+  /** `IQR / median` of the crossings (R1) over the orders. A value of 0 is a router that the order does not move. */
+  readonly crossings: number;
+  /** `IQR / median` of the median detour (R5) over the orders. */
+  readonly detour: number;
+  /** `IQR / median` of the ink saved (B1) over the orders. */
+  readonly inkSaved: number;
+  /** `IQR / median` of the ink over the orders. */
+  readonly ink: number;
+  /** The share of the orders whose routes differ from the routes of the input order. A value of 0 is a router that is free of the order. */
+  readonly changed: number;
+  /**
+   * The crossings of the input order divided by the fewest crossings over the orders (the price of anarchy of WILD-056).
+   * A value of 1 is a default order as good as the best random order. It is `NaN` when the best order has 0 crossings and the input order has more.
+   */
+  readonly poa: number;
+}
+
+/** The options of `orderFragility`. */
+export interface OrderFragilityOptions {
+  /** The number of random orders of the edges. The default is 20. */
+  readonly orders?: number;
+  /** The seed of the first order. The order `k` has the seed `seed + k`. The default is 1. */
+  readonly seed?: number;
+  /** The result of the input order, when the caller has it. Without it, the function routes the input order one time more. */
+  readonly base?: Result;
+}
+
+/**
+ * This function gives `IQR / median` of the values. Values with a median of 0 give `IQR / mean`, and values that are all 0 give 0.
+ * An IQR below `1e-9` of the median is rounding noise of the sums, so it gives 0.
+ */
+function spread(values: readonly number[]): number {
+  const iqr = quantile(values, 0.75) - quantile(values, 0.25);
+  const mid = Math.abs(quantile(values, 0.5));
+  if (iqr <= 1e-9 * Math.max(1, mid)) return 0;
+  if (mid > 0) return iqr / mid;
+  const mean = values.reduce((s, v) => s + Math.abs(v), 0) / values.length;
+  return mean > 0 ? iqr / mean : 0;
+}
+
+/** This function gives the routes by the id of the edge, in the order of the ids, so two orders of the input compare. */
+function byEdge(routes: readonly Route[]): Route[] {
+  return [...routes].sort((a, b) => (a.edge < b.edge ? -1 : a.edge > b.edge ? 1 : 0));
+}
+
+/**
+ * This function measures the order fragility of a router on one graph (W3, from WILD-056).
+ * It routes the graph with `orders` random orders of the edges.
+ * It gives the spread `IQR / median` of the crossings, the detour, the ink saved and the ink.
+ * It also gives the share of orders that change a route, and the price of anarchy of the crossings.
+ * The cost is `orders` extra runs of the router.
+ */
+export function orderFragility(graph: Graph, route: (graph: Graph) => Result, options: OrderFragilityOptions = {}): OrderFragility {
+  const orders = Math.max(1, Math.floor(options.orders ?? 20));
+  const seed = options.seed ?? 1;
+  const base = options.base ?? route(graph);
+  const baseRoutes = byEdge(base.routes);
+  const crossings: number[] = [];
+  const detour: number[] = [];
+  const saved: number[] = [];
+  const ink: number[] = [];
+  let changed = 0;
+  for (let k = 0; k < orders; k++) {
+    // The measures read the routes in the order of the edge ids, so the order of the output does not move them.
+    const routes = byEdge(route(shuffleEdges(graph, seed + k)).routes);
+    const segs = drawnSegments(routes);
+    crossings.push(crossingAngles(segs).crossings);
+    detour.push(detourSpread(routes).median);
+    saved.push(inkSaved(routes));
+    let length = 0;
+    for (const [a, b] of segs) length += Math.hypot(b.x - a.x, b.y - a.y);
+    ink.push(length);
+    if (!sameData(routes, baseRoutes)) changed++;
+  }
+  const own = crossingAngles(drawnSegments(baseRoutes)).crossings;
+  const best = Math.min(...crossings);
+  return {
+    orders,
+    crossings: spread(crossings),
+    detour: spread(detour),
+    inkSaved: spread(saved),
+    ink: spread(ink),
+    changed: changed / orders,
+    poa: best > 0 ? own / best : own === 0 ? 1 : Number.NaN,
+  };
+}

package/src/bench/room.ts

@@ -2,7 +2,7 @@ import type { Box } from "../geom.ts";
 import { levelLinks } from "../levels.ts";
 import type { Graph, LevelLink, Node, Result, Router } from "../model.ts";
 import { makeRoom, openGaps, roomLinks, type RoomOptions } from "../room/index.ts";
-import { gapLanes, LANE_ORDERS, type LaneOrder } from "../room/lanes.ts";
+import { gapLaneCounts, gapLanes, LANE_ORDERS, LANE_TRACKS, type LaneOrder, type LaneTracks } from "../room/lanes.ts";
 import { levelPairs, levelRoom, type LevelRoomOptions } from "../room/levels/index.ts";
 import { buildSections, levelCut, treeDepth, type SectionOptions } from "../sections.ts";
 import { sectionsRouter } from "../routers/sections.ts";
@@ -70,14 +70,7 @@ export function measureBoard(graph: Graph, spacing: number, order?: LaneOrder):
   );
   const drawn = order ? gapLanes(graph.nodes, level, { spacing, order }) : level;
   const boxes = new Map(graph.nodes.map((n) => [n.id, n.box]));
-  // `measureQuality` reads routes of edges, so each link of the far view stands for the first edge of its pair.
-  const edgeOf = new Map<string, string>();
-  for (const e of graph.edges) {
-    const key = `${e.source.node}\u0000${e.target.node}`;
-    if (!edgeOf.has(key)) edgeOf.set(key, e.id);
-  }
-  const asRoutes: Result = { routes: drawn.map((l) => ({ edge: edgeOf.get(`${l.source}\u0000${l.target}`)!, points: l.points })) };
-  const q = measureQuality(graph, asRoutes);
+  const q = farQuality(graph, drawn);
   const routed = sectionsRouter({ name: "sections" }).route(graph);
   const segments = segmentsOf(routed);
   const open = new Set(segments.segments.filter((s) => s.count > 1).map((s) => runKey(s.edges)));
@@ -91,6 +84,26 @@ export function measureBoard(graph: Graph, spacing: number, order?: LaneOrder):
   };
 }
 
+/** This function gives the links of the far view of a board: `levelLinks` with each node as one item. */
+function farLinks(graph: Graph): LevelLink[] {
+  const items = graph.nodes.map((n) => ({ id: n.id, box: n.box, nodes: [n.id] }));
+  return levelLinks(
+    items,
+    roomLinks(graph).map((l) => ({ source: l.source, target: l.target, count: l.count ?? 1 })),
+  );
+}
+
+/** This function measures the links of the far view with `measureQuality`. Each link stands for the first edge of its pair, because `measureQuality` reads routes of edges. */
+function farQuality(graph: Graph, drawn: readonly LevelLink[]): ReturnType<typeof measureQuality> {
+  const edgeOf = new Map<string, string>();
+  for (const e of graph.edges) {
+    const key = `${e.source.node}\u0000${e.target.node}`;
+    if (!edgeOf.has(key)) edgeOf.set(key, e.id);
+  }
+  const asRoutes: Result = { routes: drawn.map((l) => ({ edge: edgeOf.get(`${l.source}\u0000${l.target}`)!, points: l.points })) };
+  return measureQuality(graph, asRoutes);
+}
+
 /**
  * This function measures a packed board, the board with each gap open to the gutter only, and the board that each room strategy opens.
  * The options are the same for each strategy, except `method`. The default strategies are the methods `routes` and `lines` of `roomDemand`.
@@ -395,3 +408,107 @@ export function formatBendRoom(rows: readonly BendRoomRow[]): string {
   );
   return [head, line, ...body].join("\n");
 }
+
+/** One row of `benchTracks` (EDA-004): the lanes of the far view of one board with one lane rule of `gapLanes`. */
+export interface TrackBenchRow {
+  readonly fixture: string;
+  /** The board: `given` (the board as it is) or `open` (the board that `makeRoom` opens at gutter 8 and spacing 4). */
+  readonly board: string;
+  readonly tracks: LaneTracks;
+  /** The number of gaps with at least one piece. */
+  readonly gaps: number;
+  /** The sum of the lanes of the gaps. */
+  readonly lanes: number;
+  /** The sum of the densities of the gaps: the most pieces that overlap at one place. No rule gives fewer lanes. */
+  readonly density: number;
+  /** The number of gaps whose lanes are nearer than `spacing`, because the gap is too narrow for its lanes. */
+  readonly squeezed: number;
+  /** The crossings of the links of the far view (`measureQuality`). */
+  readonly crossings: number;
+  /** The ink of the links of the far view. */
+  readonly ink: number;
+  /** R12: the length of parallel legs of two links nearer than `spacing`, as a share of the ink. */
+  readonly separation: number;
+  /** The number of links of the far view that go through a box. */
+  readonly through: number;
+}
+
+/**
+ * This function gives R12 (lane separation) of the links. Two legs of two links are near when they are parallel and nearer than `near`.
+ * R12 is the length of the near legs, as a share of the ink.
+ * It reads only the legs on an axis. The links of the far view have no other legs.
+ */
+export function laneSeparation(links: readonly LevelLink[], near: number): number {
+  let ink = 0;
+  let close = 0;
+  for (const across of ["x", "y"] as const) {
+    const along = across === "x" ? "y" : "x";
+    const legs: { link: number; at: number; lo: number; hi: number }[] = [];
+    links.forEach((l, li) => {
+      for (let i = 1; i < l.points.length; i++) {
+        const a = l.points[i - 1]!;
+        const b = l.points[i]!;
+        if (Math.abs(a[across] - b[across]) > 1e-6 || Math.abs(a[along] - b[along]) <= 1e-6) continue;
+        legs.push({ link: li, at: a[across], lo: Math.min(a[along], b[along]), hi: Math.max(a[along], b[along]) });
+      }
+    });
+    legs.sort((p, q) => p.at - q.at);
+    for (let i = 0; i < legs.length; i++) {
+      const P = legs[i]!;
+      ink += P.hi - P.lo;
+      for (let j = i + 1; j < legs.length && legs[j]!.at - P.at < near; j++) {
+        const Q = legs[j]!;
+        if (Q.link !== P.link) close += Math.max(0, Math.min(P.hi, Q.hi) - Math.max(P.lo, Q.lo));
+      }
+    }
+  }
+  return ink > 0 ? close / ink : 0;
+}
+
+/**
+ * This function measures each lane rule of `gapLanes` (EDA-004) on the board as it is, and on the board that `makeRoom` opens.
+ * The lane order is `crossings` for each rule. The lanes are `spacing` apart where the gap has room.
+ */
+export function benchTracks(fixture: string, graph: Graph, spacing: number = 4, rules: readonly LaneTracks[] = LANE_TRACKS): TrackBenchRow[] {
+  const open = makeRoom(graph.nodes, roomLinks(graph), { gutter: 8, spacing, method: "routes" }).items;
+  const rows: TrackBenchRow[] = [];
+  for (const [board, nodes] of [
+    ["given", graph.nodes],
+    ["open", open],
+  ] as const) {
+    const g: Graph = { nodes, edges: graph.edges };
+    const level = farLinks(g);
+    const boxes = new Map(nodes.map((n) => [n.id, n.box]));
+    for (const tracks of rules) {
+      const options = { spacing, order: "crossings" as const, tracks };
+      const counts = gapLaneCounts(nodes, level, options);
+      const drawn = gapLanes(nodes, level, options);
+      const q = farQuality(g, drawn);
+      rows.push({
+        fixture,
+        board,
+        tracks,
+        gaps: counts.length,
+        lanes: counts.reduce((s, c) => s + c.lanes, 0),
+        density: counts.reduce((s, c) => s + c.density, 0),
+        squeezed: counts.filter((c) => c.width / (c.lanes + 1) < spacing - 1e-9).length,
+        crossings: q.crossings,
+        ink: q.ink,
+        separation: laneSeparation(drawn, spacing),
+        through: measureLinks(boxes, drawn).through,
+      });
+    }
+  }
+  return rows;
+}
+
+/** This function writes the rows of `benchTracks` as a Markdown table. */
+export function formatTracks(rows: readonly TrackBenchRow[]): string {
+  const head = "| fixture | board | tracks | gaps | lanes | density | squeezed | crossings | ink | R12 | through |";
+  const line = "|---|---|---|---:|---:|---:|---:|---:|---:|---:|---:|";
+  const body = rows.map(
+    (r) =>
+      `| ${r.fixture} | ${r.board} | ${r.tracks} | ${r.gaps} | ${r.lanes} | ${r.density} | ${r.squeezed} | ${r.crossings} | ${Math.round(r.ink)} | ${r.separation.toFixed(4)} | ${r.through} |`,
+  );
+  return [head, line, ...body].join("\n");
+}