@mark1russell7/highways 0.9.3 → 0.9.5

package/src/routers/adam/index.ts

@@ -0,0 +1,294 @@
+import { checkProperties } from "../../bench/properties.ts";
+import { measureQuality } from "../../bench/quality.ts";
+import { rng } from "../../fixtures.ts";
+import { segmentsCross, type Box, type Point } from "../../geom.ts";
+import { outerGraph, type Graph, type GroupRule, type Result, type Route, type Router } from "../../model.ts";
+import { defineStrategy, type Strategy } from "../../strategies/model.ts";
+import type { OptionSchema } from "../../strategies/options.ts";
+import { sharedRouter } from "../shared.ts";
+import { byCollection } from "../trunks.ts";
+
+/** The options of the router `adam` (RULE-020: Adam with a seeded sample of pairs). */
+export interface AdamOptions {
+  /** The first step size `eta0`, in units of `clearance`, from 0.01 to 1. The step size falls to a tenth of it at the last step. The default is 0.1. */
+  readonly eta: number;
+  /** The number of other legs that each leg samples at each step, from 4 to 32. The default is 8. */
+  readonly samples: number;
+  /** The number of steps: the budget of the search, from 100 to 2000. The default is 200. */
+  readonly steps: number;
+  /** The seed of the samples, a whole number from 0. The same seed gives the same routes. The default is 1. */
+  readonly seed: number;
+  /** A leg nearer than this distance to another leg or to a box gets a push, from 4 to 32. The default is 8. */
+  readonly clearance: number;
+}
+
+/** The default options of the router `adam`. */
+export const ADAM_DEFAULTS: Readonly<AdamOptions> = Object.freeze({ eta: 0.1, samples: 8, steps: 200, seed: 1, clearance: 8 });
+
+/** The declarations of the options of the router `adam` (RULE-020). */
+export const ADAM_SCHEMA: OptionSchema<AdamOptions> = {
+  eta: { type: "number", min: 0.01, max: 1, step: 0.01, marks: [0.01, 0.1, 1], default: 0.1, describe: "The first step size, in units of the clearance. It falls to a tenth at the last step." },
+  samples: { type: "integer", min: 4, max: 32, step: 1, marks: [4, 8, 16, 32], default: 8, describe: "The number of other legs that each leg samples at each step." },
+  steps: { type: "integer", min: 100, max: 2000, step: 100, marks: [100, 200, 500, 2000], default: 200, describe: "The number of steps: the budget of the search." },
+  seed: { type: "integer", min: 0, max: 1_000_000, step: 1, marks: [1, 2, 3], default: 1, describe: "The seed of the samples. The same seed gives the same routes." },
+  clearance: { type: "number", min: 4, max: 32, step: 1, marks: [4, 8, 16, 32], default: 8, describe: "A leg nearer than this distance to another leg or to a box gets a push." },
+};
+
+/** The moment factors of Adam (Kingma and Ba 2015), as the record gives them. */
+const BETA1 = 0.9;
+const BETA2 = 0.999;
+const EPS = 1e-8;
+
+/** The weight of the push from a box, against the push from a leg. */
+const BOX_WEIGHT = 4;
+
+/** The weight of the term that holds a leg near its first place. */
+const HOLD = 0.05;
+
+/** A free leg of a route. No end of it is an end of its route or a point of another route. No run or trunk holds it. */
+interface Leg {
+  readonly route: number;
+  /** The index of the first point of the leg in its route. */
+  readonly k: number;
+  /** The unit normal of the leg. The leg moves along it. */
+  readonly nx: number;
+  readonly ny: number;
+  /** The boxes near the leg. */
+  readonly boxes: readonly Box[];
+}
+
+/** This function gives the point of the segment `ab` nearest to `p`. */
+function nearestOn(p: Point, a: Point, b: Point): Point {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const l2 = dx * dx + dy * dy;
+  const t = l2 > 0 ? Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / l2)) : 0;
+  return { x: a.x + t * dx, y: a.y + t * dy };
+}
+
+/** This function gives the point of a box nearest to `p`. A point in the box gives the nearest point of its border. */
+function nearestOfBox(p: Point, b: Box): Point {
+  const qx = Math.max(b.x, Math.min(b.x + b.w, p.x));
+  const qy = Math.max(b.y, Math.min(b.y + b.h, p.y));
+  if (qx !== p.x || qy !== p.y) return { x: qx, y: qy };
+  const sides = [p.x - b.x, b.x + b.w - p.x, p.y - b.y, b.y + b.h - p.y];
+  const m = Math.min(...sides);
+  if (m === sides[0]) return { x: b.x, y: p.y };
+  if (m === sides[1]) return { x: b.x + b.w, y: p.y };
+  if (m === sides[2]) return { x: p.x, y: b.y };
+  return { x: p.x, y: b.y + b.h };
+}
+
+/** This function gives the crossings of the route `a` with itself and with the routes of `others`. It skips the route with the index `skip`. */
+function crossingsOf(a: readonly Point[], others: readonly (readonly Point[])[], skip: number): number {
+  const [ax0, ay0, ax1, ay1] = boundsOf(a);
+  let n = 0;
+  for (let i = 1; i < a.length; i++) for (let k = i + 2; k < a.length; k++) if (segmentsCross(a[i - 1]!, a[i]!, a[k - 1]!, a[k]!)) n++;
+  others.forEach((b, j) => {
+    if (j === skip) return;
+    const [bx0, by0, bx1, by1] = boundsOf(b);
+    if (bx0 > ax1 || bx1 < ax0 || by0 > ay1 || by1 < ay0) return;
+    for (let i = 1; i < a.length; i++) for (let k = 1; k < b.length; k++) if (segmentsCross(a[i - 1]!, a[i]!, b[k - 1]!, b[k]!)) n++;
+  });
+  return n;
+}
+
+/** The bounds of each polyline, once for each polyline object. */
+const BOUNDS = new WeakMap<readonly Point[], readonly [number, number, number, number]>();
+
+/** This function gives the bounds of a polyline: the least x and y, and the largest x and y. */
+function boundsOf(p: readonly Point[]): readonly [number, number, number, number] {
+  let b = BOUNDS.get(p);
+  if (b) return b;
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const q of p) {
+    x0 = Math.min(x0, q.x);
+    y0 = Math.min(y0, q.y);
+    x1 = Math.max(x1, q.x);
+    y1 = Math.max(y1, q.y);
+  }
+  b = [x0, y0, x1, y1];
+  BOUNDS.set(p, b);
+  return b;
+}
+
+/**
+ * This function moves the free legs of the routes of `result` with Adam (RULE-020, after Kingma and Ba 2015, and the SGD layouts of Zheng, Pawar and Goodman 2019).
+ * A leg is free when its two points are inside its route, and no other route, run or trunk holds them. The variable of a leg is a shift along its normal.
+ * The energy of a leg is `Σ (1 - d / c)²` over a seeded sample of `samples` other legs nearer than `c`. The near boxes add the same term times 4.
+ * A term `0.05 × (t / c)²` holds each leg near its first place. The step size falls from `eta` to a tenth of it, with only `+`, `*` and `/`.
+ * A moved route goes back to its first points when it has more crossings than before, or a break of a hard rule.
+ * When the output still has more crossings than the routes of `shared`, it is the routes of `shared`.
+ */
+export function adamRoutes(input: Graph, result: Result, options: Partial<AdamOptions> = {}): Result {
+  const o = { ...ADAM_DEFAULTS, ...options };
+  const c = Math.max(1e-6, o.clearance);
+  const graph = outerGraph(input);
+  const first = result.routes.map((r) => r.points);
+  const pinned = new Set<string>();
+  const keyOf = (p: Point): string => `${p.x},${p.y}`;
+  for (const run of result.runs ?? []) for (const p of run.points) pinned.add(keyOf(p));
+  for (const b of result.bundles ?? []) for (const p of b.trunk) pinned.add(keyOf(p));
+  // A point of two routes or more stays, so two routes that share a leg keep it as one drawn leg.
+  const owners = new Map<string, number>();
+  first.forEach((pts, route) => {
+    for (const p of pts) {
+      const k = keyOf(p);
+      const o = owners.get(k);
+      if (o === undefined) owners.set(k, route);
+      else if (o !== route) pinned.add(k);
+    }
+  });
+  const boxes = graph.nodes.map((n) => n.box);
+  const legs: Leg[] = [];
+  first.forEach((pts, route) => {
+    for (let k = 1; k + 2 < pts.length; k++) {
+      const a = pts[k]!;
+      const b = pts[k + 1]!;
+      if (pinned.has(keyOf(a)) || pinned.has(keyOf(b))) continue;
+      const dx = b.x - a.x;
+      const dy = b.y - a.y;
+      const len = Math.sqrt(dx * dx + dy * dy);
+      if (len <= 1e-9) continue;
+      const reach = 3 * c;
+      const near = boxes.filter((bx) => Math.min(a.x, b.x) - reach <= bx.x + bx.w && Math.max(a.x, b.x) + reach >= bx.x && Math.min(a.y, b.y) - reach <= bx.y + bx.h && Math.max(a.y, b.y) + reach >= bx.y);
+      legs.push({ route, k, nx: -dy / len, ny: dx / len, boxes: near });
+    }
+  });
+  if (legs.length === 0) return result;
+  const shift = new Float64Array(legs.length);
+  const m1 = new Float64Array(legs.length);
+  const m2 = new Float64Array(legs.length);
+  // The legs that touch each point of each route, so a point moves with each of its legs.
+  const legAt = new Map<string, number[]>();
+  legs.forEach((l, i) => {
+    for (const k of [l.k, l.k + 1]) {
+      const key = `${l.route}:${k}`;
+      const list = legAt.get(key);
+      if (list) list.push(i);
+      else legAt.set(key, [i]);
+    }
+  });
+  const pointOf = (route: number, k: number): Point => {
+    const p = first[route]![k]!;
+    const list = legAt.get(`${route}:${k}`);
+    if (!list) return p;
+    let x = p.x;
+    let y = p.y;
+    for (const i of list) {
+      x += shift[i]! * legs[i]!.nx;
+      y += shift[i]! * legs[i]!.ny;
+    }
+    return { x, y };
+  };
+  // Each leg of each route, as the pairs of the sample: the free legs and the fixed legs.
+  const all: { route: number; k: number }[] = [];
+  first.forEach((pts, route) => {
+    for (let k = 0; k + 1 < pts.length; k++) all.push({ route, k });
+  });
+  const random = rng(Math.max(0, Math.floor(o.seed)));
+  const steps = Math.max(1, Math.floor(o.steps));
+  const count = Math.max(1, Math.floor(o.samples));
+  let b1 = 1;
+  let b2 = 1;
+  for (let t = 0; t < steps; t++) {
+    b1 *= BETA1;
+    b2 *= BETA2;
+    const eta = (o.eta * c) / (1 + (9 * t) / Math.max(1, steps - 1));
+    const grads = new Float64Array(legs.length);
+    legs.forEach((l, i) => {
+      const a = pointOf(l.route, l.k);
+      const b = pointOf(l.route, l.k + 1);
+      const mid = { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
+      let g = (2 * HOLD * shift[i]!) / (c * c);
+      for (let s = 0; s < count; s++) {
+        const other = all[Math.floor(random() * all.length)]!;
+        if (other.route === l.route) continue;
+        const q = nearestOn(mid, pointOf(other.route, other.k), pointOf(other.route, other.k + 1));
+        const dx = mid.x - q.x;
+        const dy = mid.y - q.y;
+        const d = Math.sqrt(dx * dx + dy * dy);
+        if (d >= c || d <= 1e-9) continue;
+        // E = (1 - d / c)², so dE/dt = -2 (1 - d / c) / c × (n · (mid - q)) / d.
+        g += ((-2 * (1 - d / c)) / c) * ((l.nx * dx + l.ny * dy) / d);
+      }
+      for (const bx of l.boxes) {
+        for (const p of [a, mid, b]) {
+          const q = nearestOfBox(p, bx);
+          const inside = p.x >= bx.x && p.x <= bx.x + bx.w && p.y >= bx.y && p.y <= bx.y + bx.h;
+          const dx = (inside ? q.x - p.x : p.x - q.x) || 0;
+          const dy = (inside ? q.y - p.y : p.y - q.y) || 0;
+          const d0 = Math.sqrt(dx * dx + dy * dy);
+          if (d0 <= 1e-9) continue;
+          const d = inside ? -d0 : d0;
+          if (d >= c) continue;
+          g += ((BOX_WEIGHT * -2 * (1 - d / c)) / c) * ((l.nx * dx + l.ny * dy) / d0);
+        }
+      }
+      grads[i] = g;
+    });
+    for (let i = 0; i < legs.length; i++) {
+      const g = grads[i]!;
+      m1[i] = BETA1 * m1[i]! + (1 - BETA1) * g;
+      m2[i] = BETA2 * m2[i]! + (1 - BETA2) * g * g;
+      const mh = m1[i]! / (1 - b1);
+      const vh = m2[i]! / (1 - b2);
+      shift[i] = Math.max(-2 * c, Math.min(2 * c, shift[i]! - (eta * mh) / (Math.sqrt(vh) + EPS)));
+    }
+  }
+  const moved = new Set(legs.map((l) => l.route));
+  const points = first.map((pts, route) => (moved.has(route) ? pts.map((_, k) => pointOf(route, k)) : pts));
+  // A moved route with more crossings than its first points, against the other routes as they are, goes back to its first points.
+  for (let round = 0; round < 8; round++) {
+    let back = 0;
+    for (const route of moved) {
+      if (points[route] === first[route] || crossingsOf(points[route]!, points, route) <= crossingsOf(first[route]!, points, route)) continue;
+      points[route] = first[route]!;
+      back++;
+    }
+    if (back === 0) break;
+  }
+  const build = (pts: readonly (readonly Point[])[]): Result => ({ ...result, routes: result.routes.map((r, i): Route => (pts[i] === r.points ? r : { ...r, points: pts[i]! })) });
+  let out = build(points);
+  for (let round = 0; round < 3; round++) {
+    const faulty = new Set(checkProperties(input, out, 1_000_000).map((v) => v.edge));
+    const fix = result.routes.map((r, i) => (faulty.has(r.edge) && points[i] !== first[i] ? i : -1)).filter((i) => i >= 0);
+    if (fix.length === 0) break;
+    for (const i of fix) points[i] = first[i]!;
+    out = build(points);
+  }
+  // The output keeps the routes of `shared` when it has a break of a hard rule, or more crossings, after the fixes.
+  if (checkProperties(input, out, 1).length > checkProperties(input, result, 1).length) return result;
+  return measureQuality(input, out).crossings > measureQuality(input, result).crossings ? result : out;
+}
+
+/**
+ * This function makes the router `adam` (RULE-020). It is the router `shared`, then the steps of Adam of `adamRoutes`.
+ * The runs and the bundles of `shared` stay, because no point of a run or of a trunk moves.
+ */
+export function adamRouter(options: Partial<AdamOptions> & { readonly name: string; readonly rule?: GroupRule; readonly maxNodes?: number }): Router {
+  const o = { ...ADAM_DEFAULTS, ...options };
+  const base = sharedRouter({ name: o.name, ...(o.rule === undefined ? {} : { rule: o.rule }), ...(o.maxNodes === undefined ? {} : { maxNodes: o.maxNodes }) });
+  return {
+    name: o.name,
+    ...(o.maxNodes === undefined ? {} : { maxNodes: o.maxNodes }),
+    route: (graph: Graph): Result => adamRoutes(graph, base.route(graph), o),
+  };
+}
+
+/**
+ * The router strategy `adam` (RULE-020), with the rule `byCollection` of `shared`. It is not a built-in router, so the benchmark and the hashes of `ROUTERS` do not change.
+ * A screen module or a consumer adds it to a registry.
+ */
+export const adamStrategy: Strategy<"router", AdamOptions> = defineStrategy({
+  step: "router",
+  name: "adam",
+  describe: "Adam with a seeded sample of pairs (RULE-020). The free legs of the routes of `shared` move along their normals, away from near legs and boxes.",
+  defaults: { ...ADAM_DEFAULTS },
+  schema: ADAM_SCHEMA,
+  maxNodes: 10_000,
+  run: (graph: Graph, o: Readonly<AdamOptions>): Result => adamRouter({ ...o, name: "adam", rule: byCollection }).route(graph),
+});

package/src/routers/annealing/index.ts

@@ -0,0 +1,260 @@
+import { rng } from "../../fixtures.ts";
+import { dist, type Point } from "../../geom.ts";
+import type { Graph, GroupRule, Result, Router } from "../../model.ts";
+import { defineStrategy, type Strategy } from "../../strategies/model.ts";
+import type { OptionSchema } from "../../strategies/options.ts";
+import { sharedRouter, type SharedSearch, type Way } from "../shared.ts";
+import { byCollection } from "../trunks.ts";
+
+/** The options of the router `annealing` (RULE-021: simulated annealing over candidate routes, with its rider WILD-028). */
+export interface AnnealingOptions {
+  /** The number of candidate ways of each edge, from 3 to 8. The default is 4. */
+  readonly candidates: number;
+  /** The cost of one crossing, in units of the median box side, from 0 to 20. The default is 4. */
+  readonly crossing: number;
+  /** The start temperature, in units of the median box side, from 0.1 to 10. The default is 1. */
+  readonly temperature: number;
+  /** The factor of the temperature after each sweep of the edges, from 0.9 to 0.99. The default is 0.95. */
+  readonly cooling: number;
+  /** The budget: the number of changes for each edge, from 20 to 200. The default is 50. */
+  readonly budget: number;
+  /** The seed of the random choices, a whole number from 0. The same seed gives the same routes. The default is 1. */
+  readonly seed: number;
+}
+
+/** The default options of the router `annealing`. */
+export const ANNEALING_DEFAULTS: Readonly<AnnealingOptions> = Object.freeze({ candidates: 4, crossing: 4, temperature: 1, cooling: 0.95, budget: 50, seed: 1 });
+
+/** The declarations of the options of the router `annealing` (RULE-021). */
+export const ANNEALING_SCHEMA: OptionSchema<AnnealingOptions> = {
+  candidates: { type: "integer", min: 3, max: 8, step: 1, marks: [3, 4, 6], default: 4, describe: "The number of candidate ways of each edge." },
+  crossing: { type: "number", min: 0, max: 20, step: 0.5, marks: [1, 4, 10], default: 4, describe: "The cost of one crossing, in units of the median box side." },
+  temperature: { type: "number", min: 0.1, max: 10, step: 0.1, marks: [0.5, 1, 4], default: 1, describe: "The start temperature, in units of the median box side." },
+  cooling: { type: "number", min: 0.9, max: 0.99, step: 0.01, marks: [0.9, 0.95, 0.98], default: 0.95, describe: "The factor of the temperature after each sweep of the edges." },
+  budget: { type: "integer", min: 20, max: 200, step: 10, marks: [20, 50, 100], default: 50, describe: "The budget: the number of changes for each edge." },
+  seed: { type: "integer", min: 0, max: 1_000_000, step: 1, marks: [1, 2, 3], default: 1, describe: "The seed of the random choices. The same seed gives the same routes." },
+};
+
+/** The share of the cost of a link that the edges of one key use already, as in `shared` with its default discount. */
+const DISCOUNT = 0.5;
+/** The cost factor of the links of the earlier candidates in the search of the next candidate. */
+const PENALTY = 3;
+
+/** One candidate way of an edge: its points, the indices of its points and the keys of its links. */
+interface Candidate {
+  readonly seq: Point[];
+  readonly ids: number[];
+  readonly links: number[];
+  readonly lengths: number[];
+  readonly length: number;
+}
+
+/** This function tells if the segments `a b` and `c d` cross at one inner point of each. A touch at an end or a common line is not a crossing. */
+function properCross(a: Point, b: Point, c: Point, d: Point): boolean {
+  const o = (p: Point, q: Point, r: Point): number => (q.x - p.x) * (r.y - p.y) - (q.y - p.y) * (r.x - p.x);
+  const d1 = o(c, d, a);
+  const d2 = o(c, d, b);
+  const d3 = o(a, b, c);
+  const d4 = o(a, b, d);
+  return ((d1 > 0 && d2 < 0) || (d1 < 0 && d2 > 0)) && ((d3 > 0 && d4 < 0) || (d3 < 0 && d4 > 0));
+}
+
+/** This function gives the median of the smaller side of the boxes, the unit of the costs. */
+function unitOf(graph: Graph): number {
+  const sides = graph.nodes.map((n) => Math.min(n.box.w, n.box.h)).sort((a, b) => a - b);
+  const u = sides.length === 0 ? 1 : sides[Math.floor((sides.length - 1) / 2)]!;
+  return u > 0 ? u : 1;
+}
+
+/**
+ * This function anneals the choice of one candidate way for each edge (RULE-021, after Davidson and Harel, 1996).
+ * The candidates of an edge are its way in `shared` and its shortest way. Other candidates are the shortest ways when the links of earlier candidates cost 3 times more.
+ * The energy is `(1 - 0.5) ink + 0.5 Σ L + crossing u X`: the cost of `shared` plus a cost for each crossing `X` between the ways of two edges.
+ * A change takes one edge to another candidate. A worse change stays with the rational chance `1 / (1 + y + y^2 / 2)`, with `y = ΔE / T`.
+ * The temperature falls by `cooling` after each sweep. The ways at the end are the ways of the lowest energy of the run.
+ */
+export function annealWays(ways: readonly Way[], search: SharedSearch, o: Readonly<AnnealingOptions>): void {
+  const live = ways.filter((w) => w.found);
+  const m = live.length;
+  if (m < 2) return;
+  const unit = unitOf(search.graph);
+  const n = search.corners;
+  let maxId = 0;
+  for (const w of live) for (const i of w.ids) maxId = Math.max(maxId, i);
+  const N = maxId + 1;
+  const pairOf = (a: number, b: number): number => (a < b ? a * N + b : b * N + a);
+  const make = (seq: Point[], ids: number[]): Candidate => {
+    const links: number[] = [];
+    const lengths: number[] = [];
+    let length = 0;
+    for (let i = 1; i < ids.length; i++) {
+      const d = dist(seq[i - 1]!, seq[i]!);
+      links.push(pairOf(ids[i - 1]!, ids[i]!));
+      lengths.push(d);
+      length += d;
+    }
+    return { seq, ids, links, lengths, length };
+  };
+  const k = Math.min(8, Math.max(1, Math.floor(o.candidates)));
+  // The candidates of each edge. The first is the way of `shared`, the start state.
+  const cands: Candidate[][] = live.map((w) => {
+    const list = [make(w.seq, w.ids)];
+    const seen = new Set([w.ids.join(",")]);
+    const hit = new Set<number>();
+    const mark = (c: Candidate): void => {
+      for (let i = 1; i < c.ids.length; i++) if (c.ids[i - 1]! < n && c.ids[i]! < n) hit.add(search.link(c.ids[i - 1]!, c.ids[i]!));
+    };
+    const add = (found: { seq: Point[]; ids: number[] } | undefined): boolean => {
+      if (!found) return false;
+      const key = found.ids.join(",");
+      if (seen.has(key)) return false;
+      seen.add(key);
+      const c = make(found.seq, found.ids);
+      list.push(c);
+      mark(c);
+      return true;
+    };
+    mark(list[0]!);
+    if (list.length < k) add(search.find(w));
+    for (let tries = 0; list.length < k && tries < k; tries++) {
+      if (!add(search.find(w, (i, j, d) => (hit.has(search.link(i, j)) ? d * PENALTY : d), 1))) break;
+    }
+    return list;
+  });
+  // The crossings of each pair of candidates of two edges, in a table for each pair of edges whose boxes meet.
+  type Bounds = { x0: number; y0: number; x1: number; y1: number };
+  const boundsOf = (seqs: readonly Point[][]): Bounds => {
+    let x0 = Infinity;
+    let y0 = Infinity;
+    let x1 = -Infinity;
+    let y1 = -Infinity;
+    for (const seq of seqs)
+      for (const p of seq) {
+        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 { x0, y0, x1, y1 };
+  };
+  const apart = (A: Bounds, B: Bounds): boolean => A.x1 < B.x0 || B.x1 < A.x0 || A.y1 < B.y0 || B.y1 < A.y0;
+  const own = cands.map((list) => list.map((c) => boundsOf([c.seq])));
+  const boxes = cands.map((list) => boundsOf(list.map((c) => c.seq)));
+  const near: { f: number; table: Int32Array; mine: boolean }[][] = live.map(() => []);
+  for (let e = 0; e < m; e++) {
+    for (let f = e + 1; f < m; f++) {
+      if (apart(boxes[e]!, boxes[f]!)) continue;
+      const ke = cands[e]!.length;
+      const kf = cands[f]!.length;
+      const table = new Int32Array(ke * kf);
+      let any = false;
+      for (let i = 0; i < ke; i++) {
+        const p = cands[e]![i]!.seq;
+        for (let j = 0; j < kf; j++) {
+          if (apart(own[e]![i]!, own[f]![j]!)) continue;
+          const q = cands[f]![j]!.seq;
+          let x = 0;
+          for (let s = 1; s < p.length; s++) for (let t = 1; t < q.length; t++) if (properCross(p[s - 1]!, p[s]!, q[t - 1]!, q[t]!)) x++;
+          table[i * kf + j] = x;
+          if (x > 0) any = true;
+        }
+      }
+      if (!any) continue;
+      near[e]!.push({ f, table, mine: true });
+      near[f]!.push({ f: e, table, mine: false });
+    }
+  }
+  // The users of each link in each key, for the ink.
+  const keys = live.map((w) => w.key);
+  const users = new Map<string, Map<number, number>>();
+  const use = (e: number, c: Candidate, step: number): number => {
+    let mine = users.get(keys[e]!);
+    if (!mine) users.set(keys[e]!, (mine = new Map()));
+    let ink = 0;
+    for (let i = 0; i < c.links.length; i++) {
+      const before = mine.get(c.links[i]!) ?? 0;
+      const after = before + step;
+      if (after === 0) mine.delete(c.links[i]!);
+      else mine.set(c.links[i]!, after);
+      if (before === 0 && after > 0) ink += c.lengths[i]!;
+      if (before > 0 && after === 0) ink -= c.lengths[i]!;
+    }
+    return ink;
+  };
+  const choice = new Int32Array(m);
+  for (let e = 0; e < m; e++) use(e, cands[e]![0]!, 1);
+  const crossCost = Math.max(0, o.crossing) * unit;
+  const crossings = (e: number, i: number): number => {
+    let x = 0;
+    for (const { f, table, mine } of near[e]!) {
+      const kf = cands[f]!.length;
+      const ke = cands[e]!.length;
+      x += mine ? table[i * kf + choice[f]!]! : table[choice[f]! * ke + i]!;
+    }
+    return x;
+  };
+  const random = rng(Math.max(0, Math.floor(o.seed)));
+  const cooling = Math.min(0.99, Math.max(0.9, o.cooling));
+  let temperature = Math.max(1e-6, o.temperature) * unit;
+  const moves = Math.max(1, Math.floor(o.budget)) * m;
+  let energy = 0;
+  let best = 0;
+  let bestChoice = choice.slice();
+  for (let s = 0; s < moves; s++) {
+    if (s > 0 && s % m === 0) temperature *= cooling;
+    const e = Math.floor(random() * m);
+    const list = cands[e]!;
+    if (list.length < 2) continue;
+    const from = choice[e]!;
+    const to = (from + 1 + Math.floor(random() * (list.length - 1))) % list.length;
+    // The change of the energy: the ink and the length of the key, and the crossings with the other edges.
+    const dInk = use(e, list[from]!, -1) + use(e, list[to]!, 1);
+    const dLength = list[to]!.length - list[from]!.length;
+    const dCross = crossings(e, to) - crossings(e, from);
+    const delta = (1 - DISCOUNT) * dInk + DISCOUNT * dLength + crossCost * dCross;
+    const y = delta / temperature;
+    if (delta <= 0 || random() < 1 / (1 + y + (y * y) / 2)) {
+      choice[e] = to;
+      energy += delta;
+      if (energy < best - 1e-9) {
+        best = energy;
+        bestChoice = choice.slice();
+      }
+    } else {
+      use(e, list[to]!, -1);
+      use(e, list[from]!, 1);
+    }
+  }
+  live.forEach((w, e) => {
+    const c = cands[e]![bestChoice[e]!]!;
+    w.seq = c.seq;
+    w.ids = c.ids;
+  });
+}
+
+/**
+ * This function makes the router `annealing` (RULE-021 with its rider WILD-028). It is the router `shared`, then the annealing of `annealWays`.
+ * Each candidate is a way through the corner graph, as in `shared`, so each one keeps the hard rules.
+ */
+export function annealingRouter(options: Partial<AnnealingOptions> & { readonly name: string; readonly rule?: GroupRule; readonly maxNodes?: number }): Router {
+  const o = { ...ANNEALING_DEFAULTS, ...options };
+  return sharedRouter(
+    { name: o.name, ...(o.rule === undefined ? {} : { rule: o.rule }), ...(o.maxNodes === undefined ? {} : { maxNodes: o.maxNodes }) },
+    undefined,
+    { refine: (ways, search) => annealWays(ways, search, o) },
+  );
+}
+
+/**
+ * The router strategy `annealing` (RULE-021), with the rule `byCollection` of `shared`. It is not a built-in router, so the benchmark and the hashes of `ROUTERS` do not change.
+ * A screen module or a consumer adds it to a registry.
+ */
+export const annealingStrategy: Strategy<"router", AnnealingOptions> = defineStrategy({
+  step: "router",
+  name: "annealing",
+  describe: "Simulated annealing over candidate routes (RULE-021, with WILD-028). Each edge picks one of a few ways, for less ink and fewer crossings.",
+  defaults: { ...ANNEALING_DEFAULTS },
+  schema: ANNEALING_SCHEMA,
+  maxNodes: 10_000,
+  run: (graph: Graph, o: Readonly<AnnealingOptions>): Result => annealingRouter({ ...o, name: "annealing", rule: byCollection }).route(graph),
+});