@mark1russell7/highways 0.4.0 → 0.4.1

package/package.json

@@ -9,7 +9,7 @@
     "directory": "packages/core"
   },
   "homepage": "https://mark1russell7.github.io/highways/",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "type": "module",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -38,6 +38,7 @@
     "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",

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");
+}

package/src/bench/screen/measures.ts

@@ -49,6 +49,18 @@ const ROWS: readonly Row[] = [
   // The bundles.
   ["B1.inkSaved", "B1", "route.bundle.ink-saved", "0 to 1", "higher", false],
   ["B4.ambiguity", "B4", "route.bundle.ambiguity", "0 to 1", "lower", false],
+  // B2, B3 and B6 score the shared ways of the routes for a fixed placement, as B1 does. B3 compares with the routes of `corners` on the same input.
+  ["B2.share", "B2", "route.bundle.share", "0 to 1", "higher", false],
+  ["B3.median", "B3", "route.bundle.stretch.median", "ratio", "lower", false],
+  ["B3.q95", "B3", "route.bundle.stretch.q95", "ratio", "lower", false],
+  ["B6.max", "B6", "route.bundle.merge-angle.max", "degrees", "lower", false],
+  // The order fragility (W3 of MEAS3, from WILD-056): the spread of a measure over random orders of the edges. The placement can move it.
+  ["W3.crossings", "W3", "route.order.crossings", "IQR over the median", "lower", true],
+  ["W3.detour", "W3", "route.order.detour", "IQR over the median", "lower", true],
+  ["W3.inkSaved", "W3", "route.order.ink-saved", "IQR over the median", "lower", true],
+  ["W3.ink", "W3", "route.order.ink", "IQR over the median", "lower", true],
+  ["W3.changed", "W3", "route.order.changed", "0 to 1", "lower", true],
+  ["W3.poa", "W3", "route.order.poa", "ratio", "lower", true],
   // The stability after the small change of `changeGraph`, and against the run on the base input of a variant.
   ["Z10.mean", "Z10", "route.stability.mean", "units of the board", "lower", false],
   ["Z10.max", "Z10", "route.stability.max", "units of the board", "lower", false],

package/src/bench/screen/screen.ts

@@ -1,8 +1,12 @@
 import { highwayRouterStrategy } from "../../highways/router.ts";
-import type { Graph, Result } from "../../model.ts";
+import type { Graph, Result, Route } from "../../model.ts";
+import { stableOrderStrategy } from "../../order/index.ts";
+import { repairStrategy } from "../../repair/index.ts";
 import { STRATEGIES } from "../../strategies/builtins.ts";
-import { createRegistry, getStrategy, listStrategies, STEPS, type AnyStrategy, type Registry, type Strategy } from "../../strategies/model.ts";
+import { asRouter, createRegistry, getStrategy, listStrategies, register, STEPS, type AnyStrategy, type Registry, type Strategy } from "../../strategies/model.ts";
 import { compareStep, type CompareRow, type CompareStep, type StepComparison } from "../compare.ts";
+import { bundledShare, bundleStretch, mergeAngle } from "../measures/bundles.ts";
+import { orderFragility } from "../measures/order.ts";
 import { paretoFront, type Objective } from "../measures/pareto.ts";
 import { routeStability } from "../measures/stability.ts";
 import { quantile } from "../measures/stats.ts";
@@ -26,6 +30,15 @@ export const SCREEN_STEPS: readonly ScreenStep[] = ["group", "router", "highway"
 /** The routers that the screen of the step `highway` also runs by default. They are the baselines of the note on highways. */
 export const HIGHWAY_BASE_ROUTERS: readonly string[] = ["corners", "shared", "trunks"];
 
+/**
+ * A wrapper of each router of a screen. `stable` routes the edges in the stable order of WILD-053 (`stableOrderStrategy`).
+ * `repair` runs the repair step of RULE-046 after the router (`repairStrategy`).
+ */
+export type ScreenWrap = "stable" | "repair";
+
+/** The wrappers of `ScreenWrap`. */
+export const SCREEN_WRAPS: readonly ScreenWrap[] = ["stable", "repair"];
+
 /** The hard rules of the routes of a router, or of a plan after `follow`. */
 const ROUTE_RULES: readonly string[] = ["complete", "ends-at-plugs", "fixed-plugs", "no-pass-through", "counts-sum", "link-ends", "bundle-trunk", "run-shared", "same-twice"];
 
@@ -59,8 +72,18 @@ export interface ScreenOptions {
    * The default is `HIGHWAY_BASE_ROUTERS`. The other steps do not read it.
    */
   readonly baseRouters?: readonly string[];
-  /** The seed of the small change of the stability measures. The default is 1. */
+  /** The seed of the small change of the stability measures, and of the first random order of `shuffles`. The default is 1. */
   readonly seed?: number;
+  /**
+   * The wrappers of each router of the steps `router` and `highway`. Each wrapper `w` adds the router `<name>+<w>` as a new strategy, beside the router `<name>`.
+   * The default is none. The steps `group` and `curve` do not read it.
+   */
+  readonly wrap?: readonly ScreenWrap[];
+  /**
+   * The number of random orders of the edges for the order fragility (W3, from WILD-056). Each router routes each input this number of times more.
+   * The default is 0: no measure of the order fragility. The steps `group` and `curve` do not read it.
+   */
+  readonly shuffles?: number;
   /** The commit of the code, for the records. */
   readonly commit?: string;
   /** The predictions of the run. Each record names the first prediction with its strategy, its set and its input. */
@@ -175,8 +198,11 @@ function screenRegistry(step: ScreenStep, strategies: readonly (Strategy<ScreenS
 /** This function tells if a step of the screen gives routes. The step `router` gives routes, and the step `highway` gives routes after `follow`. */
 const givesRoutes = (step: ScreenStep): step is "router" | "highway" => step === "router" || step === "highway";
 
-/** This function gives the values of a row of `compareStep`, with the measures of `measureQuality` for a router. */
-function rowValues(step: ScreenStep, graph: Graph, row: CompareRow): Record<string, number> {
+/**
+ * This function gives the values of a row of `compareStep`, with the measures of `measureQuality` for a router.
+ * A router also gets the bundled share (B2), the merge angle (B6) and the bundle stretch (B3) against the routes `base` of `corners`.
+ */
+function rowValues(step: ScreenStep, graph: Graph, row: CompareRow, base: () => readonly Route[]): Record<string, number> {
   const values: Record<string, number> = { ...row.values };
   delete values["ms"];
   if (givesRoutes(step) && row.result) {
@@ -186,6 +212,11 @@ function rowValues(step: ScreenStep, graph: Graph, row: CompareRow): Record<stri
     values["R8.tight"] = q.tight;
     values["R10.plugAngle"] = q.plugAngle;
     values["R15.inflections"] = q.inflections;
+    values["B2.share"] = bundledShare(row.result);
+    const st = bundleStretch(row.result.routes, base());
+    values["B3.median"] = st.median;
+    values["B3.q95"] = st.q95;
+    values["B6.max"] = mergeAngle(row.result.routes);
   }
   return values;
 }
@@ -208,6 +239,20 @@ function rowRules(step: ScreenStep, graph: Graph, row: CompareRow, again: Compar
   return { hard: { ...countRules(rules, []), "same-twice": deterministic ? 0 : 1 }, deterministic };
 }
 
+/** This function adds the router `<name>+<w>` for each router of the registry and each wrapper `w`. It gives the new registry and the new names. */
+function wrapRouters(registry: Registry, wraps: readonly ScreenWrap[]): { registry: Registry; added: string[] } {
+  const routers = listStrategies(registry, "router");
+  const added: AnyStrategy[] = [];
+  for (const w of wraps) for (const s of routers) added.push((w === "stable" ? stableOrderStrategy(s) : repairStrategy(s)) as AnyStrategy);
+  return { registry: added.length === 0 ? registry : register(registry, ...added), added: added.map((s) => s.name) };
+}
+
+/** This function gives the name of a router without the suffix of a wrapper, for example `shared` for `shared+repair`. */
+export function unwrappedName(name: string): string {
+  for (const w of SCREEN_WRAPS) if (name.endsWith(`+${w}`)) return name.slice(0, -(w.length + 1));
+  return name;
+}
+
 /** This function keeps the finite values and gives them the names of a record. */
 function named(values: Readonly<Record<string, number>>): Record<string, number> {
   const out: Record<string, number> = {};
@@ -232,14 +277,23 @@ export function screen(step: ScreenStep, strategies: readonly (Strategy<ScreenSt
   const candidates = screened.candidates;
   // The step `highway` runs as the step `router`. Each highway strategy with `follow` is a router, after the base routers.
   const base = step === "highway" ? (options.baseRouters ?? HIGHWAY_BASE_ROUTERS).map((name) => getStrategy(STRATEGIES, "router", name)) : [];
-  const registry =
+  const unwrapped =
     step === "highway"
       ? createRegistry([...base, ...listStrategies(screened.registry, "highway").map((s) => highwayRouterStrategy(s))] as readonly AnyStrategy[])
       : screened.registry;
+  const wrapped = givesRoutes(step) ? wrapRouters(unwrapped, options.wrap ?? []) : { registry: unwrapped, added: [] };
+  const registry = wrapped.registry;
+  for (const name of wrapped.added) candidates.add(name);
   const compareAs: CompareStep = step === "highway" ? "router" : step;
   const baseNames = new Set(base.map((s) => s.name));
-  const stepOf = (name: string): ScreenStep => (baseNames.has(name) ? "router" : step);
-  const own = options.options ?? {};
+  const stepOf = (name: string): ScreenStep => (baseNames.has(unwrappedName(name)) ? "router" : step);
+  // A wrapped router gets the options of its router, unless the call gives its own.
+  const own: Record<string, object> = { ...options.options };
+  for (const name of wrapped.added) {
+    const from = options.options?.[unwrappedName(name)];
+    if (own[name] === undefined && from !== undefined) own[name] = from;
+  }
+  const shuffles = givesRoutes(step) ? Math.max(0, Math.floor(options.shuffles ?? 0)) : 0;
   const seed = options.seed ?? 1;
   const log = options.log ?? ((): void => {});
   const families = options.families;
@@ -259,6 +313,10 @@ export function screen(step: ScreenStep, strategies: readonly (Strategy<ScreenSt
     comparisons.push(cmp);
     log(`${input.id}: ${graph.nodes.length} nodes, ${graph.edges.length} edges, ${cmp.rows.map((r) => `${r.strategy} ${r.ms.toFixed(0)}`).join(", ")}`);
     if (bases.has(input.id)) kept.set(input.id, { graph, results: new Map(cmp.rows.flatMap((r) => (r.result ? [[r.strategy, r.result] as const] : []))) });
+    // The routes of `corners` on the input: the base of the bundle stretch (B3). The row of `corners` gives them, or one more run.
+    let cornersRoutes: readonly Route[] | undefined;
+    const cornersBase = (): readonly Route[] =>
+      (cornersRoutes ??= (cmp.rows.find((r) => r.strategy === "corners" && r.result)?.result ?? asRouter(getStrategy(STRATEGIES, "router", "corners")).route(graph)).routes);
     cmp.rows.forEach((row, i) => {
       const strategy = byName.get(row.strategy)!;
       const head = {
@@ -282,7 +340,13 @@ export function screen(step: ScreenStep, strategies: readonly (Strategy<ScreenSt
         return;
       }
       const { hard, deterministic } = rowRules(step, graph, row, again?.rows[i]);
-      const record = { ...head, measures: named(rowValues(step, graph, row)), hard, tolerance: { through: TOLERANCE }, deterministic, ms: row.ms, ...tail };
+      const values = rowValues(step, graph, row, cornersBase);
+      if (shuffles > 0 && row.result) {
+        const router = asRouter(strategy as Strategy<"router">, own[row.strategy]);
+        const f = orderFragility(graph, (g) => router.route(g), { orders: shuffles, seed, base: row.result });
+        Object.assign(values, { "W3.crossings": f.crossings, "W3.detour": f.detour, "W3.inkSaved": f.inkSaved, "W3.ink": f.ink, "W3.changed": f.changed, "W3.poa": f.poa });
+      }
+      const record = { ...head, measures: named(values), hard, tolerance: { through: TOLERANCE }, deterministic, ms: row.ms, ...tail };
       records.push(record);
       if (givesRoutes(step) && input.base !== undefined && row.result) variants.push({ record, base: input.base, result: row.result });
     });

package/src/index.ts

@@ -29,3 +29,5 @@ export * from "./strategies/index.ts";
 export * from "./bench/compare.ts";
 export * from "./bench/screen/index.ts";
 export * from "./highways/index.ts";
+export * from "./order/index.ts";
+export * from "./repair/index.ts";

package/src/order/index.ts

@@ -0,0 +1,65 @@
+import { fnv1a32 } from "../bench/screen/hash.ts";
+import { rng } from "../fixtures.ts";
+import type { Edge, Graph, Result, Router } from "../model.ts";
+import { defineStrategy, type Strategy } from "../strategies/model.ts";
+
+/** This function compares two edges by the hash of their ids, and then by their ids. Thus the order of two edges does not depend on the input. */
+function byHash(a: { readonly h: number; readonly e: Edge }, b: { readonly h: number; readonly e: Edge }): number {
+  if (a.h !== b.h) return a.h - b.h;
+  return a.e.id < b.e.id ? -1 : a.e.id > b.e.id ? 1 : 0;
+}
+
+/**
+ * This function gives the graph with its edges in the stable order of WILD-053: by the FNV-1a hash of the id, then by the id.
+ * The nodes and the edges do not change. Two orders of the same edges give the same graph.
+ * The hash spreads the edges, so the stable order does not favor the edges of one node or one collection.
+ */
+export function stableOrder(graph: Graph): Graph {
+  const edges = graph.edges.map((e) => ({ h: fnv1a32(e.id), e })).sort(byHash).map((x) => x.e);
+  return { ...graph, edges };
+}
+
+/** This function gives the graph with its edges in a random order of the seed. The same graph and seed always give the same order. */
+export function shuffleEdges(graph: Graph, seed: number): Graph {
+  const edges = [...graph.edges];
+  const r = rng(seed);
+  for (let i = edges.length - 1; i > 0; i--) {
+    const j = Math.floor(r() * (i + 1));
+    [edges[i], edges[j]] = [edges[j]!, edges[i]!];
+  }
+  return { ...graph, edges };
+}
+
+/**
+ * This function routes the graph in the stable order of `stableOrder`, with the function `route`.
+ * The routes come back in the order of the input edges, so the caller sees no change of order.
+ * The bundles, the runs and the levels come from the stable order. Thus each order of the input gives the same data.
+ */
+export function routeInStableOrder(graph: Graph, route: (graph: Graph) => Result): Result {
+  const result = route(stableOrder(graph));
+  const index = new Map(graph.edges.map((e, i) => [e.id, i] as const));
+  const at = (edge: string): number => index.get(edge) ?? Number.MAX_SAFE_INTEGER;
+  const routes = [...result.routes].sort((a, b) => at(a.edge) - at(b.edge));
+  return { ...result, routes };
+}
+
+/** This function gives a router that routes each graph in the stable order of WILD-053. It keeps the name and the `maxNodes` of the router. */
+export function withStableOrder(router: Router): Router {
+  return { ...router, route: (graph: Graph): Result => routeInStableOrder(graph, (g) => router.route(g)) };
+}
+
+/**
+ * This function gives a router strategy that runs `strategy` in the stable order of WILD-053. The output does not depend on the order of the input edges.
+ * The new strategy has the name `<name>+stable`, and the options and the schema of `strategy`. The strategy `strategy` does not change.
+ */
+export function stableOrderStrategy<O extends object>(strategy: Strategy<"router", O>): Strategy<"router", O> {
+  return defineStrategy<"router", O>({
+    step: "router",
+    name: `${strategy.name}+stable`,
+    describe: `${strategy.describe} The edges go in a stable order: by a hash of their ids.`,
+    defaults: { ...strategy.defaults } as O,
+    ...(strategy.schema === undefined ? {} : { schema: strategy.schema }),
+    ...(strategy.maxNodes === undefined ? {} : { maxNodes: strategy.maxNodes }),
+    run: (graph: Graph, options: Readonly<O>): Result => routeInStableOrder(graph, (g) => strategy.run(g, options)),
+  });
+}