@mark1russell7/highways 0.1.5 → 0.3.0

package/src/bench/room.ts

@@ -1,11 +1,15 @@
+import type { Box } from "../geom.ts";
 import { levelLinks } from "../levels.ts";
-import type { Graph, Node, Result } from "../model.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 { levelPairs, levelRoom, type LevelRoomOptions } from "../room/levels/index.ts";
+import { buildSections, levelCut, treeDepth, type SectionOptions } from "../sections.ts";
 import { sectionsRouter } from "../routers/sections.ts";
 import { laneRoutes, runKey, segmentsOf } from "../segments.ts";
 import { roomStrategies } from "../strategies/builtins.ts";
 import type { Strategy } from "../strategies/model.ts";
+import { benchHighways, type HighwayMeasures } from "./curves.ts";
 import { measureLinks, measureRouteFaults, type LinkFaults } from "./links.ts";
 import { measureQuality } from "./quality.ts";
 
@@ -37,7 +41,7 @@ export interface RoomBenchRow {
 }
 
 /** This function gives the area of the bounding box of the nodes. */
-function areaOf(nodes: readonly Node[]): number {
+function areaOf(nodes: readonly { readonly box: Box }[]): number {
   let x0 = Infinity;
   let y0 = Infinity;
   let x1 = -Infinity;
@@ -188,3 +192,206 @@ export function formatRoom(rows: readonly RoomBenchRow[]): string {
   });
   return [head, line, ...body].join("\n");
 }
+
+/** One row of the benchmark of the room of the zoom levels: one level with groups of one board. */
+export interface LevelRoomRow {
+  readonly fixture: string;
+  /** The board: `packed`, `gutter` (each level open to the gutter only), `routes` (the room of the nodes alone), `levels` or `levels each`. */
+  readonly board: string;
+  readonly depth: number;
+  /** The number of items of the level. */
+  readonly items: number;
+  /** The number of links of the level. */
+  readonly links: number;
+  /** The area of the bounding box of the items of the level, as a share of the area of the packed board. */
+  readonly area: number;
+  /** The number of level links that go through a box that is not one of their ends. */
+  readonly through: number;
+  /** The crossings of the level links, with a lane for each link in each gap (`gapLanes` with the order `crossings`). */
+  readonly crossings: number;
+  /** The crossings of the level links without lanes. The links of a gap share one line, so this count hides crossings. */
+  readonly sharedCrossings: number;
+  /** The mean detour of the level links. */
+  readonly detour: number;
+  /** The worst detour of the level links. */
+  readonly worstDetour: number;
+  /** The number of pairs of items of the level whose order or alignment on an axis is not the order of the packed board. */
+  readonly order: number;
+  /** The number of pairs of items of the level before whose order or alignment on an axis changes at this level. */
+  readonly levelOrder: number;
+  /**
+   * The mean shift of an item against its parent from the level before, in gutters. The shift compares the place of the item in its parent
+   * at this level with its place in its parent at the level before. The value 0 means that the item moves with its parent.
+   */
+  readonly shift: number;
+  /** The largest shift of an item against its parent, in gutters. */
+  readonly worstShift: number;
+  /** The time to open the board of all levels, in milliseconds. It is 0 for the packed board. */
+  readonly ms: number;
+}
+
+/** One board of the benchmark of the room of the zoom levels. It has a name and the nodes at each depth, from 0 to the level with each node alone. */
+interface LevelBoards {
+  readonly name: string;
+  readonly nodes: readonly (readonly Node[])[];
+  readonly ms: number;
+}
+
+/** This function gives the sign of `d`, with 0 for a value nearer to 0 than `snap`. */
+const sign = (d: number, snap: number): number => (Math.abs(d) <= snap ? 0 : Math.sign(d));
+
+/**
+ * This function counts the pairs of boxes whose order or alignment on an axis is not the same in `a` and in `b`.
+ * The order of two boxes is the order of their left (or top) edges. The cost is quadratic in the number of boxes.
+ */
+export function orderChanges(a: readonly Box[], b: readonly Box[], snap: number = 0.5): number {
+  let n = 0;
+  for (const axis of ["x", "y"] as const)
+    for (let i = 0; i < a.length; i++)
+      for (let j = i + 1; j < a.length; j++) if (sign(a[i]![axis] - a[j]![axis], snap) !== sign(b[i]![axis] - b[j]![axis], snap)) n++;
+  return n;
+}
+
+const middle = (b: Box): { x: number; y: number } => ({ x: b.x + b.w / 2, y: b.y + b.h / 2 });
+
+/**
+ * This function measures the room of the zoom levels of a board. The rows of each board give each level with groups, from depth 1.
+ * The boards are the packed board, the fair baseline with each level open to the gutter only, and the room of the nodes alone (`makeRoom`).
+ * Then come two boards of `levelRoom` with the options. The board `levels` uses the board of the nearest level for each level.
+ * The board `levels each` has a board for each level.
+ *
+ * The links of each level are `levelLinks` with their defaults. Each link gets a lane of `spacing` in each gap.
+ */
+export function benchLevelRoom(fixture: string, graph: Graph, options: LevelRoomOptions = {}, sections: SectionOptions = {}): LevelRoomRow[] {
+  const gutter = options.gutter ?? 8;
+  const spacing = options.spacing ?? 4;
+  const snap = options.snap ?? 0.5;
+  const root = buildSections(graph.nodes, sections);
+  const deepest = treeDepth(root);
+  const links = roomLinks(graph);
+  const all = (nodes: readonly Node[]): (readonly Node[])[] => Array.from({ length: deepest + 2 }, () => nodes);
+  const timed = (name: string, make: () => (readonly Node[])[]): LevelBoards => {
+    const t0 = now();
+    const nodes = make();
+    return { name, nodes, ms: now() - t0 };
+  };
+  const boards: LevelBoards[] = [
+    { name: "packed", nodes: all(graph.nodes), ms: 0 },
+    timed("gutter", () => levelRoom(graph.nodes, links, root, { ...options, spacing: 0, maxGrowth: Infinity, passes: 1, board: "each" }).levels.map((l) => l.nodes)),
+    timed("routes", () => all(makeRoom(graph.nodes, links, { ...options, method: "routes" }).items)),
+    timed("levels", () => levelRoom(graph.nodes, links, root, { ...options, board: "shared" }).levels.map((l) => l.nodes)),
+    timed("levels each", () => levelRoom(graph.nodes, links, root, { ...options, board: "each" }).levels.map((l) => l.nodes)),
+  ];
+  const indexOf = new Map(graph.nodes.map((n, i) => [n.id, i]));
+  const area0 = areaOf(graph.nodes);
+  const rows: LevelRoomRow[] = [];
+  for (const board of boards) {
+    for (let d = 1; d <= deepest; d++) {
+      const here = board.nodes[d]!;
+      const before = board.nodes[d - 1]!;
+      const cut = levelCut(here, root, d);
+      const pairs = levelPairs(cut.items, cut.owner, indexOf, links);
+      const boxes = new Map(cut.items.map((i) => [i.id, i.box]));
+      const shared = levelLinks(cut.items, pairs);
+      const drawn = gapLanes(cut.items, shared, { spacing, order: "crossings", snap });
+      const asGraph: Graph = { nodes: cut.items, edges: pairs.map((p, i) => ({ id: `l${i}`, source: { node: p.source }, target: { node: p.target } })) };
+      const asRoutes = (list: readonly LevelLink[]): Result => ({ routes: list.map((l, i) => ({ edge: `l${i}`, points: l.points })) });
+      const q = measureQuality(asGraph, asRoutes(drawn));
+      const faults = measureLinks(boxes, drawn);
+      // The level before: its items at its own places, and the same items at the places of this level.
+      const parentsThen = levelCut(before, root, d - 1);
+      const parentsNow = levelCut(here, root, d - 1);
+      const childrenThen = levelCut(before, root, d);
+      let shift = 0;
+      let worstShift = 0;
+      cut.items.forEach((c, k) => {
+        const parent = parentsThen.owner[indexOf.get(c.nodes[0]!)!]!;
+        const at = middle(c.box);
+        const was = middle(childrenThen.items[k]!.box);
+        const parentAt = middle(parentsNow.items[parent]!.box);
+        const parentWas = middle(parentsThen.items[parent]!.box);
+        const s = Math.hypot(at.x - parentAt.x - (was.x - parentWas.x), at.y - parentAt.y - (was.y - parentWas.y)) / gutter;
+        shift += s;
+        worstShift = Math.max(worstShift, s);
+      });
+      rows.push({
+        fixture,
+        board: board.name,
+        depth: d,
+        items: cut.items.length,
+        links: pairs.length,
+        area: area0 > 0 ? areaOf(cut.items) / area0 : 1,
+        through: faults.through,
+        crossings: q.crossings,
+        sharedCrossings: measureQuality(asGraph, asRoutes(shared)).crossings,
+        detour: q.detour,
+        worstDetour: faults.worstDetour,
+        order: orderChanges(
+          levelCut(graph.nodes, root, d).items.map((i) => i.box),
+          cut.items.map((i) => i.box),
+          snap,
+        ),
+        levelOrder: orderChanges(
+          parentsThen.items.map((i) => i.box),
+          parentsNow.items.map((i) => i.box),
+          snap,
+        ),
+        shift: cut.items.length ? shift / cut.items.length : 0,
+        worstShift,
+        ms: board.ms,
+      });
+    }
+  }
+  return rows;
+}
+
+/** This function writes the rows of `benchLevelRoom` as a Markdown table. */
+export function formatLevelRoom(rows: readonly LevelRoomRow[]): string {
+  const head = "| fixture | board | depth | items | links | area | through | crossings | shared crossings | detour | worst detour | order | level order | shift | worst shift | ms |";
+  const line = "|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|";
+  const body = rows.map(
+    (r) =>
+      `| ${r.fixture} | ${r.board} | ${r.depth} | ${r.items} | ${r.links} | ${r.area.toFixed(3)} | ${r.through} | ${r.crossings} | ${r.sharedCrossings} | ${r.detour.toFixed(3)} | ${r.worstDetour.toFixed(2)} | ${r.order} | ${r.levelOrder} | ${r.shift.toFixed(2)} | ${r.worstShift.toFixed(2)} | ${r.ms.toFixed(1)} |`,
+  );
+  return [head, line, ...body].join("\n");
+}
+
+/** One row of `benchBendRoom`: the lanes of the bundles of one router on one open board, after `highwayCurves`. */
+export interface BendRoomRow extends HighwayMeasures {
+  readonly router: string;
+  readonly fixture: string;
+  /** The board: `room` opens the gaps for the links only, and `room + bends` also opens them for the bends of the bundles. */
+  readonly board: "room" | "room + bends";
+  /** The area of the bounding box of the boxes, as a share of the area of the board before the room. */
+  readonly area: number;
+}
+
+/**
+ * This function measures the room for the bends of the bundles (HWC-D). It opens the board two times with `makeRoom`, without and with the option `bends`.
+ * The option `bends` gets the router and the lane options of the curves. Then the router routes each open board, and `benchHighways` curves its bundles with `highway`.
+ */
+export function benchBendRoom(router: Router, fixture: string, graph: Graph, options: RoomOptions = { gutter: 8, spacing: 4 }): BendRoomRow[] {
+  const lanes = { spacing: 4, maxWidth: 16, minRadius: 4 };
+  const links = roomLinks(graph);
+  const area0 = areaOf(graph.nodes);
+  const boards = [
+    ["room", makeRoom(graph.nodes, links, options).items],
+    ["room + bends", makeRoom(graph.nodes, links, { ...options, bends: { router, edges: graph.edges, ...lanes } }).items],
+  ] as const;
+  return boards.map(([board, nodes]) => {
+    const [, highway] = benchHighways(router, fixture, { nodes, edges: graph.edges }, { spacing: lanes.spacing, maxWidth: lanes.maxWidth, minRadius: lanes.minRadius });
+    const { router: name, fixture: _f, curve: _c, ms: _ms, ...measures } = highway!;
+    return { router: name, fixture, board, area: area0 > 0 ? areaOf(nodes) / area0 : 1, ...measures };
+  });
+}
+
+/** This function writes the rows of `benchBendRoom` as a Markdown table. The spacing error is a percent of the spacing. */
+export function formatBendRoom(rows: readonly BendRoomRow[]): string {
+  const head = "| router | fixture | board | area | bundles | worst spacing | min radius | under min | through |";
+  const line = "|---|---|---|---:|---:|---:|---:|---:|---:|";
+  const body = rows.map(
+    (r) =>
+      `| ${r.router} | ${r.fixture} | ${r.board} | ${r.area.toFixed(3)} | ${r.bundles} | ${(r.worstSpacing * 100).toFixed(1)}% | ${r.minRadius === Infinity ? "-" : r.minRadius.toFixed(2)} | ${r.underMin} | ${r.through} |`,
+  );
+  return [head, line, ...body].join("\n");
+}

package/src/bench/run.ts

@@ -25,12 +25,28 @@ export interface BenchRow {
   readonly faults: LinkFaults;
   /** The faults of each zoom level with groups (`measureLevelFaults`). The list is empty for a router without levels. */
   readonly levelFaults: readonly LevelFaults[];
+  /** The routes of this cell took longer than the cell limit. The cell did not start more routes. A row within the limit has no such field. */
+  readonly overLimit?: OverLimit;
+}
+
+/** The record of a cell over its time limit. */
+export interface OverLimit {
+  /** The cell limit, in milliseconds. */
+  readonly limit: number;
+  /** The number of routes that the cell finished. With one route, the cell did not check "same twice". */
+  readonly runs: number;
 }
 
 /** The options of a benchmark run. */
 export interface BenchOptions {
   /** The number of timed routes of each fixture by each router. The default is 3. */
   readonly repeat?: number;
+  /**
+   * The time limit of one cell (one router on one fixture), in milliseconds. The default is no limit.
+   * After the routes of a cell pass the limit, the cell starts no more routes, and its row gets `overLimit`.
+   * A route that runs does not stop.
+   */
+  readonly cellLimit?: number;
 }
 
 /** This function routes each fixture with each router, checks the hard rules and measures the quality. */
@@ -38,7 +54,7 @@ export function runBenchmark(routers: readonly Router[], fixtures: readonly Fixt
   const rows: BenchRow[] = [];
   for (const spec of fixtures) {
     const graph = makeFixture(spec);
-    for (const router of routers) if (graph.nodes.length <= (router.maxNodes ?? Infinity)) rows.push(benchOne(router, spec.name, graph, options.repeat ?? 3));
+    for (const router of routers) if (graph.nodes.length <= (router.maxNodes ?? Infinity)) rows.push(benchOne(router, spec.name, graph, options.repeat ?? 3, options.cellLimit));
   }
   return rows;
 }
@@ -67,22 +83,41 @@ export function sameData(a: unknown, b: unknown): boolean {
   return true;
 }
 
-/** This function routes one graph with one router and measures the result. */
-export function benchOne(router: Router, fixture: string, graph: Graph, repeat = 3): BenchRow {
+/**
+ * This function routes one graph with one router and measures the result. It routes at least two times, for the rule "same twice".
+ * After the routes pass `cellLimit` milliseconds, it starts no more routes and marks the row with `overLimit`.
+ */
+export function benchOne(router: Router, fixture: string, graph: Graph, repeat = 3, cellLimit: number = Infinity): BenchRow {
+  return benchRun(router, fixture, graph, repeat, cellLimit).row;
+}
+
+/** One run of `benchRun`: the row of the benchmark and the result that the row measures. */
+export interface BenchRun {
+  readonly row: BenchRow;
+  readonly result: Result;
+}
+
+/** This function does the work of `benchOne` and also gives the result, so more measures can read it without a second route. */
+export function benchRun(router: Router, fixture: string, graph: Graph, repeat = 3, cellLimit: number = Infinity): BenchRun {
   const times: number[] = [];
   let first: Result | undefined;
   let deterministic = true;
+  let spent = 0;
   for (let i = 0; i < Math.max(2, repeat); i++) {
     const t0 = now();
     const r = router.route(graph);
-    times.push(now() - t0);
+    const t = now() - t0;
+    times.push(t);
+    spent += t;
     if (!first) first = r;
     else if (i === 1 && !sameData(r, first)) deterministic = false;
+    if (spent > cellLimit) break;
   }
+  const runs = times.length;
   times.sort((a, b) => a - b);
   const result = first!;
   const all = checkProperties(graph, result, 1_000_000);
-  return {
+  const row: BenchRow = {
     router: router.name,
     fixture,
     nodes: graph.nodes.length,
@@ -94,17 +129,38 @@ export function benchOne(router: Router, fixture: string, graph: Graph, repeat =
     quality: measureQuality(graph, result),
     faults: measureRouteFaults(graph, result),
     levelFaults: measureLevelFaults(result),
+    ...(spent > cellLimit ? { overLimit: { limit: cellLimit, runs } } : {}),
+  };
+  return { row, result };
+}
+
+/**
+ * This function puts rows in the order of one benchmark run: by fixture, then by router, each in the order of its list.
+ * A name that is not in its list goes after the names of the list. Rows with the same place keep their order.
+ * The workflow `Bench` uses it to join the rows of its parts.
+ */
+export function orderRows(rows: readonly BenchRow[], routers: readonly string[], fixtures: readonly string[]): BenchRow[] {
+  const place = (list: readonly string[], name: string): number => {
+    const i = list.indexOf(name);
+    return i < 0 ? list.length : i;
   };
+  return rows
+    .map((row, i) => ({ row, i, f: place(fixtures, row.fixture), r: place(routers, row.router) }))
+    .sort((a, b) => a.f - b.f || a.r - b.r || a.i - b.i)
+    .map((x) => x.row);
 }
 
-/** This function writes the rows as a Markdown table. */
+/** This function writes the rows as a Markdown table. A cell over its limit shows "over the limit" after its time, and a dash for "same twice" when it did not check it. */
 export function formatTable(rows: readonly BenchRow[]): string {
   const head = "| router | fixture | nodes | edges | ms | same twice | violations | ink | crossings | bends | inflections | clearance | tight | detour | plug angle |";
   const line = "|---|---|---:|---:|---:|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|";
   const f = (v: number, d = 2): string => (Number.isInteger(v) ? String(v) : v.toFixed(d));
   const body = rows.map((r) => {
     const q = r.quality;
-    return `| ${r.router} | ${r.fixture} | ${r.nodes} | ${r.edges} | ${f(r.ms, 1)} | ${r.deterministic ? "yes" : "NO"} | ${r.violations} | ${Math.round(q.ink)} | ${q.crossingsEstimated ? "≈" : ""}${q.crossings} | ${f(q.bends)} | ${f(q.inflections)} | ${f(q.clearance, 1)} | ${f(q.tight)} | ${f(q.detour)} | ${f(q.plugAngle, 1)} |`;
+    const over = r.overLimit;
+    const ms = over ? `${f(r.ms, 1)} over the limit` : f(r.ms, 1);
+    const same = over && over.runs < 2 ? "-" : r.deterministic ? "yes" : "NO";
+    return `| ${r.router} | ${r.fixture} | ${r.nodes} | ${r.edges} | ${ms} | ${same} | ${r.violations} | ${Math.round(q.ink)} | ${q.crossingsEstimated ? "≈" : ""}${q.crossings} | ${f(q.bends)} | ${f(q.inflections)} | ${f(q.clearance, 1)} | ${f(q.tight)} | ${f(q.detour)} | ${f(q.plugAngle, 1)} |`;
   });
   return [head, line, ...body].join("\n");
 }
@@ -115,17 +171,36 @@ export function formatTable(rows: readonly BenchRow[]): string {
  */
 export function formatFaults(rows: readonly BenchRow[]): string {
   const head =
-    "| router | fixture | through | out and back | worst detour | outside | level links | level overlaps | level through | level out and back | level worst detour | level outside |";
-  const line = "|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|";
+    "| router | fixture | through | out and back | worst detour | outside | level links | level overlaps | level through | level unavoidable | level avoidable | level out and back | level worst detour | level outside |";
+  const line = "|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|";
   const body = rows.map((r) => {
     const f = r.faults;
     const cells = [r.router, r.fixture, f.through, f.backtrack, f.worstDetour.toFixed(2), f.outside];
-    if (r.levelFaults.length === 0) cells.push("-", "-", "-", "-", "-", "-");
+    if (r.levelFaults.length === 0) cells.push("-", "-", "-", "-", "-", "-", "-", "-");
     else {
       const l = sumFaults(r.levelFaults);
-      cells.push(l.links, r.levelFaults.reduce((s, x) => s + x.overlaps, 0), l.through, l.backtrack, l.worstDetour.toFixed(2), l.outside);
+      cells.push(l.links, r.levelFaults.reduce((s, x) => s + x.overlaps, 0), l.through, l.unavoidable, l.avoidable, l.backtrack, l.worstDetour.toFixed(2), l.outside);
     }
     return `| ${cells.join(" | ")} |`;
   });
   return [head, line, ...body].join("\n");
 }
+
+/** A row with the faults of each zoom level, as `formatLevels` reads it: a router or a setting on one fixture. */
+export interface LevelRow {
+  readonly router: string;
+  readonly fixture: string;
+  readonly levelFaults: readonly LevelFaults[];
+}
+
+/** This function writes the faults of each zoom level with groups as a Markdown table, one line for each level. */
+export function formatLevels(rows: readonly LevelRow[]): string {
+  const head = "| router | fixture | depth | items | groups | overlaps | links | through | unavoidable | avoidable | out and back | worst detour | outside |";
+  const line = "|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|";
+  const body = rows.flatMap((r) =>
+    r.levelFaults.map((l) =>
+      [r.router, r.fixture, l.depth, l.items, l.groups, l.overlaps, l.links, l.through, l.unavoidable, l.avoidable, l.backtrack, l.worstDetour.toFixed(2), l.outside].join(" | "),
+    ),
+  );
+  return [head, line, ...body.map((b) => `| ${b} |`)].join("\n");
+}

package/src/bench/sections.ts

@@ -0,0 +1,121 @@
+import type { Graph, Result } from "../model.ts";
+import { sectionsRouter, type SectionsOptions } from "../routers/sections.ts";
+import { groupStrategies } from "../strategies/builtins.ts";
+import type { Strategy } from "../strategies/model.ts";
+import { sameData } from "./run.ts";
+import { measureLevelFaults, measureRouteFaults, sumFaults, type LinkFaults } from "./links.ts";
+
+// The core runs in any host, so it reads the clock without the types of Node or the browser.
+const now = (): number => (globalThis as { performance?: { now(): number } }).performance?.now() ?? Date.now();
+
+/** The options of one setting of the router `sections`, without the name. */
+export type SectionsSettingOptions = Omit<SectionsOptions, "name" | "maxNodes">;
+
+/** One setting of a sweep of the router `sections`. */
+export interface SectionsSetting {
+  /** The name of the setting in the column `setting`. */
+  readonly name: string;
+  readonly options: SectionsSettingOptions;
+}
+
+/** One row of a sweep of the router `sections`: one setting on one board, and the measures of its routes and of its zoom levels. */
+export interface SectionsBenchRow {
+  readonly fixture: string;
+  readonly setting: string;
+  /** The faults of the routes of the edges (`measureRouteFaults`). */
+  readonly faults: LinkFaults;
+  /** The sum of the faults of the levels with groups (`measureLevelFaults` and `sumFaults`). */
+  readonly levelFaults: LinkFaults;
+  /** The sum of the overlaps of the levels with groups. */
+  readonly overlaps: number;
+  /** The number of routes that go through hubs: the routes that are not the same as the direct route of their edge. */
+  readonly hubRoutes: number;
+  /** The number of shared stretches of way of the result (`runs`). */
+  readonly runs: number;
+  /** The number of zoom levels, with the last level of single nodes. */
+  readonly levels: number;
+  /** The number of items of the far view: the first level with more than one item. */
+  readonly farItems: number;
+  /** The time of one route, in milliseconds. */
+  readonly ms: number;
+}
+
+/** This function gives the number of items of the first level with more than one item, or 0 for a result without levels. */
+function farItems(result: Result): number {
+  return result.levels?.find((l) => l.items.length > 1)?.items.length ?? 0;
+}
+
+/**
+ * This function measures the router `sections` on one board with each setting. The first row is the fair baseline: the defaults, with no option.
+ * The direct routes come from the hub limit 0, so `hubRoutes` counts the routes that use the hubs.
+ */
+export function sweepSections(fixture: string, graph: Graph, settings: readonly SectionsSetting[]): SectionsBenchRow[] {
+  const all: SectionsSetting[] = [{ name: "defaults", options: {} }, ...settings];
+  return all.map((s) => {
+    const direct = sectionsRouter({ ...s.options, name: "direct", stretch: 0, stretchPad: 0 }).route(graph);
+    const t0 = now();
+    const result = sectionsRouter({ ...s.options, name: s.name }).route(graph);
+    const ms = now() - t0;
+    const levelFaults = measureLevelFaults(result);
+    return {
+      fixture,
+      setting: s.name,
+      faults: measureRouteFaults(graph, result),
+      levelFaults: sumFaults(levelFaults),
+      overlaps: levelFaults.reduce((n, f) => n + f.overlaps, 0),
+      hubRoutes: result.routes.filter((r, i) => !sameData(r.points, direct.routes[i]?.points)).length,
+      runs: result.runs?.length ?? 0,
+      levels: result.levels?.length ?? 0,
+      farItems: farItems(result),
+      ms,
+    };
+  });
+}
+
+/** The values of the hub limit (`stretch`) of the sweep of CUSTOM. The default is 2. */
+export const STRETCH_SWEEP: readonly number[] = [1.25, 1.5, 2, 3, Infinity];
+
+/** This function gives the settings of the sweep of the hub limit: one setting for each value of `stretch`. */
+export function stretchSettings(values: readonly number[] = STRETCH_SWEEP): SectionsSetting[] {
+  return values.map((stretch) => ({ name: `stretch ${stretch}`, options: { stretch } }));
+}
+
+/** The values of `hubSlack` of the sweep of CUSTOM. The default is 80. */
+export const SLACK_SWEEP: readonly number[] = [0, 40, 80, 160, Infinity];
+
+/** This function gives the settings of the sweep of the slack of the hubs: one setting for each value of `hubSlack`. */
+export function slackSettings(values: readonly number[] = SLACK_SWEEP): SectionsSetting[] {
+  return values.map((hubSlack) => ({ name: `hubSlack ${hubSlack}`, options: { hubSlack } }));
+}
+
+/** The values of the section limit (`cap`) of the sweep of CUSTOM. The default is 8. */
+export const CAP_SWEEP: readonly number[] = [4, 6, 8, 12, 16];
+
+/** This function gives the settings of the sweep of the section limit: one setting for each value of `cap`. */
+export function capSettings(values: readonly number[] = CAP_SWEEP): SectionsSetting[] {
+  return values.map((cap) => ({ name: `cap ${cap}`, options: { cap } }));
+}
+
+/**
+ * This function gives one setting for each grouping rule: the router `sections` with the strategy as its option `group`.
+ * The map `options` gives the options of a strategy by its name.
+ */
+export function groupSettings(
+  strategies: readonly Strategy<"group">[] = Object.values(groupStrategies),
+  options: Readonly<Record<string, object>> = {},
+): SectionsSetting[] {
+  return strategies.map((group) => ({ name: `group ${group.name}`, options: { group, ...(options[group.name] ? { groupOptions: options[group.name] } : {}) } }));
+}
+
+/** This function writes the rows of `sweepSections` as a Markdown table. */
+export function formatSections(rows: readonly SectionsBenchRow[]): string {
+  const head =
+    "| fixture | setting | through | out and back | worst detour | outside | hub routes | runs | levels | far items | level through | level out and back | level outside | level overlaps | ms |";
+  const line = "|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|";
+  const body = rows.map((r) => {
+    const f = r.faults;
+    const l = r.levelFaults;
+    return `| ${r.fixture} | ${r.setting} | ${f.through} | ${f.backtrack} | ${f.worstDetour.toFixed(2)} | ${f.outside} | ${r.hubRoutes} | ${r.runs} | ${r.levels} | ${r.farItems} | ${l.through} | ${l.backtrack} | ${l.outside} | ${r.overlaps} | ${r.ms.toFixed(1)} |`;
+  });
+  return [head, line, ...body].join("\n");
+}