@mark1russell7/highways 0.2.0 → 0.4.0

package/src/bench/measures/bundles.ts

@@ -0,0 +1,119 @@
+import { dist, polylineLength } from "../../geom.ts";
+import { rng } from "../../fixtures.ts";
+import type { Graph, Route } from "../../model.ts";
+import { drawnSegments, segmentKey } from "./routes.ts";
+
+/**
+ * This function gives the share of the ink that shared segments save (B1 of MEAS0): `inkSaved = 1 - ink(S) / Σ_e L(r_e)`.
+ * `ink(S)` counts a shared segment one time, as `measureQuality` does. The scale is 0 to 1, and higher is better. The cost is `n log n`.
+ */
+export function inkSaved(routes: readonly Route[]): number {
+  let total = 0;
+  for (const r of routes) total += polylineLength(r.points);
+  if (total <= 0) return 0;
+  let ink = 0;
+  for (const [a, b] of drawnSegments(routes)) ink += dist(a, b);
+  return Math.max(0, 1 - ink / total);
+}
+
+/** The ambiguity of a result (B4 of MEAS0). */
+export interface Ambiguity {
+  /** The share of false neighbours, from 0 to 1. Lower is better. */
+  readonly value: number;
+  /** This value is true when the value comes from a sample of the nodes. */
+  readonly estimated: boolean;
+}
+
+/** The options of `ambiguity`. */
+export interface AmbiguityOptions {
+  /** Up to this number of nodes, the function examines each node. The default is 1000. */
+  readonly exact?: number;
+  /** Above `exact` nodes, the function examines this number of nodes from a seeded sample. The default is 2000. */
+  readonly sample?: number;
+  /** The seed of the sample. The default is 1. */
+  readonly seed?: number;
+}
+
+/**
+ * This function measures the ambiguity of the routes (B4 of MEAS0), with one step of neighbours.
+ * `N(v)` holds the nodes whose routes share a drawn segment with a route of `v`.
+ * `amb = Σ_v count(w in N(v) : no edge v-w) / Σ_v count(N(v))`. The cost is quadratic, so a seeded sample serves above `exact` nodes.
+ */
+export function ambiguity(graph: Graph, routes: readonly Route[], options: AmbiguityOptions = {}): Ambiguity {
+  const n = graph.nodes.length;
+  const index = new Map(graph.nodes.map((v, i) => [v.id, i] as const));
+  const ends = new Map<string, readonly [number, number]>();
+  for (const e of graph.edges) {
+    const s = index.get(e.source.node);
+    const t = index.get(e.target.node);
+    if (s !== undefined && t !== undefined) ends.set(e.id, [s, t]);
+  }
+  // Each drawn segment gets a number. `keysOf` holds the segments of each edge, and `nodesOf` the distinct end nodes of the edges of each segment.
+  const keyIds = new Map<string, number>();
+  const nodesOf: number[][] = [];
+  const keysOf = new Map<string, number[]>();
+  for (const r of routes) {
+    const end = ends.get(r.edge);
+    if (!end) continue;
+    const own: number[] = [];
+    for (let i = 1; i < r.points.length; i++) {
+      const k = segmentKey(r.points[i - 1]!, r.points[i]!);
+      if (k === undefined) continue;
+      let id = keyIds.get(k);
+      if (id === undefined) {
+        id = nodesOf.length;
+        keyIds.set(k, id);
+        nodesOf.push([]);
+      }
+      if (own.includes(id)) continue;
+      own.push(id);
+      nodesOf[id]!.push(end[0], end[1]);
+    }
+    keysOf.set(r.edge, own);
+  }
+  const mark = new Int32Array(n).fill(-1);
+  nodesOf.forEach((list, k) => {
+    let j = 0;
+    for (const v of list)
+      if (mark[v] !== k) {
+        mark[v] = k;
+        list[j++] = v;
+      }
+    list.length = j;
+  });
+  const incident: string[][] = Array.from({ length: n }, () => []);
+  const adjacent: number[][] = Array.from({ length: n }, () => []);
+  for (const e of graph.edges) {
+    const end = ends.get(e.id);
+    if (!end) continue;
+    incident[end[0]]!.push(e.id);
+    incident[end[1]]!.push(e.id);
+    adjacent[end[0]]!.push(end[1]);
+    adjacent[end[1]]!.push(end[0]);
+  }
+  const exact = n <= (options.exact ?? 1000);
+  const R = rng(options.seed ?? 1);
+  const pick = exact ? Array.from({ length: n }, (_, i) => i) : Array.from({ length: options.sample ?? 2000 }, () => Math.floor(R() * n));
+  // The stamps mark the segments, the near nodes and the neighbours of the current node, with no new set for each node.
+  const keyStamp = new Int32Array(nodesOf.length).fill(-1);
+  const nearStamp = new Int32Array(n).fill(-1);
+  const linkStamp = new Int32Array(n).fill(-1);
+  let all = 0;
+  let wrong = 0;
+  pick.forEach((v, step) => {
+    for (const w of adjacent[v]!) linkStamp[w] = step;
+    nearStamp[v] = step;
+    for (const e of incident[v]!)
+      for (const k of keysOf.get(e) ?? []) {
+        if (keyStamp[k] === step) continue;
+        keyStamp[k] = step;
+        for (const w of nodesOf[k]!) {
+          if (nearStamp[w] === step) continue;
+          nearStamp[w] = step;
+          all++;
+          if (linkStamp[w] !== step) wrong++;
+        }
+      }
+  });
+  return { value: all ? wrong / all : 0, estimated: !exact };
+}

package/src/bench/measures/curves.ts

@@ -0,0 +1,211 @@
+import type { CurveSegment } from "../../curves/model.ts";
+import type { CurveSpace } from "../../curves/space.ts";
+import { dist, polylineLength, segmentsCross, turns, type Point } from "../../geom.ts";
+import { Grid } from "../../grid.ts";
+import { TOLERANCE } from "../properties.ts";
+
+const EPS = 1e-9;
+const DEG = 180 / Math.PI;
+
+/** A joint of a curve: the end of one drawn segment and the start of the next drawn segment. */
+export interface CurveJoint {
+  readonly at: Point;
+  /** The angle between the tangent at the end of the first segment and the tangent at the start of the second segment, in degrees. */
+  readonly angle: number;
+  /** The jump of the curvature at the joint, `abs(κ^- - κ^+)`, in 1 / units. */
+  readonly jump: number;
+  /** The unit tangent at the end of the first segment. */
+  readonly before: Point;
+  /** The unit tangent at the start of the second segment. */
+  readonly after: Point;
+}
+
+const unit = (x: number, y: number): Point | undefined => {
+  const l = Math.hypot(x, y);
+  return l > EPS ? { x: x / l, y: y / l } : undefined;
+};
+
+/** This function gives the unit tangent and the curvature at the start (`t = 0`) or at the end (`t = 1`) of a segment that starts at `from`. */
+function frame(from: Point, s: CurveSegment, t: 0 | 1): { tangent: Point | undefined; curvature: number } {
+  if (s.kind === "line" || s.kind === "move") return { tangent: unit(s.to.x - from.x, s.to.y - from.y), curvature: 0 };
+  if (s.kind === "arc") {
+    const a = t === 0 ? s.start : s.start + s.sweep;
+    const sign = Math.sign(s.sweep) || 1;
+    return { tangent: { x: -Math.sin(a) * sign, y: Math.cos(a) * sign }, curvature: s.radius > EPS ? sign / s.radius : 0 };
+  }
+  // A cubic curve: B'(0) = 3 (c1 - p0), B''(0) = 6 (p0 - 2 c1 + c2), B'(1) = 3 (p3 - c2), B''(1) = 6 (c1 - 2 c2 + p3).
+  const [p0, p1, p2, p3] = [from, s.c1, s.c2, s.to];
+  const d = t === 0 ? { x: 3 * (p1.x - p0.x), y: 3 * (p1.y - p0.y) } : { x: 3 * (p3.x - p2.x), y: 3 * (p3.y - p2.y) };
+  const dd = t === 0 ? { x: 6 * (p0.x - 2 * p1.x + p2.x), y: 6 * (p0.y - 2 * p1.y + p2.y) } : { x: 6 * (p1.x - 2 * p2.x + p3.x), y: 6 * (p1.y - 2 * p2.y + p3.y) };
+  const speed = Math.hypot(d.x, d.y);
+  if (speed > EPS) return { tangent: { x: d.x / speed, y: d.y / speed }, curvature: (d.x * dd.y - d.y * dd.x) / speed ** 3 };
+  // A handle of length 0: the tangent comes from the next control point that differs.
+  const fallback = t === 0 ? (unit(p2.x - p0.x, p2.y - p0.y) ?? unit(p3.x - p0.x, p3.y - p0.y)) : (unit(p3.x - p1.x, p3.y - p1.y) ?? unit(p3.x - p0.x, p3.y - p0.y));
+  return { tangent: fallback, curvature: 0 };
+}
+
+const angleOf = (u: Point, v: Point): number => Math.acos(Math.max(-1, Math.min(1, u.x * v.x + u.y * v.y))) * DEG;
+
+/**
+ * This function gives the joints of a curve: each point where one drawn segment ends and the next one starts.
+ * A segment of length 0 has no tangent, so the joint skips it. The analytic tangents and curvatures of lines, cubic curves and arcs give the values.
+ */
+export function curveJoints(segments: readonly CurveSegment[]): CurveJoint[] {
+  const out: CurveJoint[] = [];
+  let at: Point | undefined;
+  let last: { tangent: Point; curvature: number } | undefined;
+  for (const s of segments) {
+    if (s.kind === "move" || at === undefined) {
+      at = s.to;
+      last = undefined;
+      continue;
+    }
+    const start = frame(at, s, 0);
+    const end = frame(at, s, 1);
+    if (start.tangent && end.tangent) {
+      if (last) out.push({ at, angle: angleOf(last.tangent, start.tangent), jump: Math.abs(last.curvature - start.curvature), before: last.tangent, after: start.tangent });
+      last = { tangent: end.tangent, curvature: end.curvature };
+    }
+    at = s.to;
+  }
+  return out;
+}
+
+/**
+ * This function gives the G1 defect of a curve (C1 of MEAS0): `g1 = max_j angle(T_j^-, T_j^+)` over the joints, in degrees.
+ * Lower is better. A curve is G1 when `g1` is 0.5 degrees or less. The cost is linear.
+ */
+export function g1Defect(segments: readonly CurveSegment[]): number {
+  return curveJoints(segments).reduce((m, j) => Math.max(m, j.angle), 0);
+}
+
+/**
+ * This function gives the G2 defect of a curve (C2 of MEAS0): `g2 = max_j abs(κ_j^- - κ_j^+) · u` over the joints.
+ * The value has no unit, and lower is better. `u` is the unit of the board (`boardUnit`). The cost is linear.
+ */
+export function g2Defect(segments: readonly CurveSegment[], u: number): number {
+  return curveJoints(segments).reduce((m, j) => Math.max(m, j.jump * u), 0);
+}
+
+/**
+ * This function gives the bending energy of a sampled curve (C3 of MEAS0): `E = L · ∫ κ(s)^2 ds`.
+ * At each inner sample, `κ = φ / l`, so `E = L · Σ φ_i^2 / l_i`. The length `l_i` is the mean of the two legs, with a limit of `8τ / φ_i`.
+ * Thus a sharp corner counts as an arc with a sagitta of `τ`, the tolerance of the samples.
+ *
+ * The value has no unit, and lower is better. A full circle gives `4π^2`. The cost is linear.
+ */
+export function bendingEnergy(points: readonly Point[], tolerance = 0.25): number {
+  const q: Point[] = [];
+  for (const v of points) if (q.length === 0 || dist(q[q.length - 1]!, v) > EPS) q.push(v);
+  if (q.length < 3) return 0;
+  const phi = turns(q);
+  let sum = 0;
+  for (let i = 1; i + 1 < q.length; i++) {
+    const t = Math.abs(phi[i - 1]!);
+    if (t < EPS) continue;
+    const l = Math.min((dist(q[i - 1]!, q[i]!) + dist(q[i]!, q[i + 1]!)) / 2, (8 * tolerance) / t);
+    sum += (t * t) / l;
+  }
+  return polylineLength(q) * sum;
+}
+
+/** This function tells if a polyline crosses itself. Two legs next to each other do not count. The cost is `n log n`. */
+export function crossesItself(p: readonly Point[]): boolean {
+  if (p.length < 4) return false;
+  const len = polylineLength(p) / (p.length - 1);
+  const grid = new Grid<number>(Math.max(1, len * 4));
+  for (let i = 1; i < p.length; i++) grid.addSegment(i, p[i - 1]!, p[i]!);
+  for (let i = 1; i < p.length; i++) {
+    const a = p[i - 1]!;
+    const b = p[i]!;
+    const hit = grid.someSegment(a, b, 0, (j) => j > i + 1 && segmentsCross(a, b, p[j - 1]!, p[j]!));
+    if (hit) return true;
+  }
+  return false;
+}
+
+/** This function tells if a polyline turns back on itself at a vertex: a turn of more than 179 degrees, as at a cusp. */
+export function hasCusp(p: readonly Point[]): boolean {
+  return turns(p).some((t) => Math.abs(t) * DEG > 179);
+}
+
+/** The input of `curveFaults`: one curve and the polyline that it draws. */
+export interface CurveCheck {
+  /** The polyline of the route. */
+  readonly polyline: readonly Point[];
+  /** The segments of the curve. */
+  readonly segments: readonly CurveSegment[];
+  /** The samples of the curve (`sampleCurve`). */
+  readonly samples: readonly Point[];
+  /** The free space of the board. Without it, the check `clear` gives false. */
+  readonly space?: CurveSpace;
+  /** With these normals, the check `ends` also examines the direction of the curve at its two ends. */
+  readonly startNormal?: Point;
+  readonly endNormal?: Point;
+  /** With this value, the check `g1` examines the joints. Give it for a curve type that is G1 by its design. */
+  readonly smooth?: boolean;
+}
+
+/** The faults of one curve: one value for each proposed hard rule of the curves in MEAS0. */
+export interface CurveFaults {
+  /** `curve-clear`: the curve goes through a box that its polyline avoids (C7). */
+  readonly clear: boolean;
+  /** `curve-ends`: the curve misses an end of its polyline, or an end tangent is more than 1 degree off its normal (C10). */
+  readonly ends: boolean;
+  /** `curve-g1`: a joint has a G1 defect of more than 0.5 degrees, and it is not a corner that the free space keeps sharp (C1). */
+  readonly g1: boolean;
+  /** `curve-simple`: the curve crosses itself or turns back at a cusp, and its polyline does not (C9). */
+  readonly simple: boolean;
+}
+
+/**
+ * This function tells if a joint is a corner that the free space keeps sharp. The joint is a vertex of the polyline,
+ * and the curve on one side of it goes along the leg of the polyline.
+ */
+function keptSharp(j: CurveJoint, polyline: readonly Point[]): boolean {
+  for (let i = 1; i + 1 < polyline.length; i++) {
+    const v = polyline[i]!;
+    if (dist(v, j.at) > 1e-6) continue;
+    const a = unit(v.x - polyline[i - 1]!.x, v.y - polyline[i - 1]!.y);
+    const b = unit(polyline[i + 1]!.x - v.x, polyline[i + 1]!.y - v.y);
+    if ((a && angleOf(a, j.before) <= 0.5) || (b && angleOf(b, j.after) <= 0.5)) return true;
+  }
+  return false;
+}
+
+/** This function checks one curve against the proposed hard rules of the curves of MEAS0. The cost is `n log n` for each curve. */
+export function curveFaults(c: CurveCheck): CurveFaults {
+  const p = c.polyline;
+  const s = c.samples;
+  const clear = c.space !== undefined && s.length > 1 && c.space.addsHit(s, p);
+  let ends = p.length > 0 && (s.length === 0 || dist(s[0]!, p[0]!) > TOLERANCE || dist(s[s.length - 1]!, p[p.length - 1]!) > TOLERANCE);
+  if (!ends && (c.startNormal || c.endNormal)) {
+    const joints = drawnFrames(c.segments);
+    const n0 = c.startNormal && unit(c.startNormal.x, c.startNormal.y);
+    const n1 = c.endNormal && unit(-c.endNormal.x, -c.endNormal.y);
+    if (n0 && joints.first && angleOf(n0, joints.first) > 1) ends = true;
+    if (n1 && joints.last && angleOf(n1, joints.last) > 1) ends = true;
+  }
+  const g1 = c.smooth === true && curveJoints(c.segments).some((j) => j.angle > 0.5 && !keptSharp(j, p));
+  const simple = !crossesItself(p) && !hasCusp(p) && (crossesItself(s) || hasCusp(s));
+  return { clear, ends, g1, simple };
+}
+
+/** This function gives the unit tangent at the start of the first drawn segment and at the end of the last drawn segment. */
+function drawnFrames(segments: readonly CurveSegment[]): { first: Point | undefined; last: Point | undefined } {
+  let at: Point | undefined;
+  let first: Point | undefined;
+  let last: Point | undefined;
+  for (const s of segments) {
+    if (s.kind === "move" || at === undefined) {
+      at = s.to;
+      continue;
+    }
+    const t0 = frame(at, s, 0).tangent;
+    const t1 = frame(at, s, 1).tangent;
+    if (first === undefined && t0) first = t0;
+    if (t1) last = t1;
+    at = s.to;
+  }
+  return { first, last };
+}

package/src/bench/measures/groups.ts

@@ -0,0 +1,122 @@
+import type { Graph, Level } from "../../model.ts";
+import type { Section } from "../../sections.ts";
+import { adjustedRandIndex } from "./stats.ts";
+
+/** A grouping of the nodes: a map from the id of each node to the id of its group. */
+export type Grouping = ReadonlyMap<string, string>;
+
+/** This function gives the grouping of one level: each node goes to the id of its item. */
+export function levelGrouping(level: Level): Map<string, string> {
+  const m = new Map<string, string>();
+  for (const item of level.items) for (const n of item.nodes) m.set(n, item.id);
+  return m;
+}
+
+/** This function gives the far view of a result: the first level with more than one item, in the order of depth. */
+export function farLevel(levels: readonly Level[]): Level | undefined {
+  return [...levels].sort((a, b) => a.depth - b.depth).find((l) => l.items.length > 1);
+}
+
+/**
+ * This function gives the modularity of a grouping (G1 of MEAS0, Newman and Girvan, 2004).
+ * `Q = Σ_c (e_c / m - (d_c / (2m))^2)`, with `e_c` the edges inside `c` and `d_c` the sum of the degrees in `c`.
+ * The scale is -0.5 to 1, and higher is better. A node without a group is a group alone. The cost is linear.
+ */
+export function modularity(graph: Graph, groups: Grouping): number {
+  const m = graph.edges.length;
+  if (m === 0) return 0;
+  const inside = new Map<string, number>();
+  const degree = new Map<string, number>();
+  const of = (v: string): string => groups.get(v) ?? `\u0000${v}`;
+  for (const e of graph.edges) {
+    const a = of(e.source.node);
+    const b = of(e.target.node);
+    degree.set(a, (degree.get(a) ?? 0) + 1);
+    degree.set(b, (degree.get(b) ?? 0) + 1);
+    if (a === b) inside.set(a, (inside.get(a) ?? 0) + 1);
+  }
+  let q = 0;
+  for (const [c, d] of degree) q += (inside.get(c) ?? 0) / m - (d / (2 * m)) ** 2;
+  return q;
+}
+
+/**
+ * This function gives the cut share of a grouping (G2 of MEAS0): the share of the edges between two groups.
+ * For the grouping of a level, it is the sum of the counts of the links of the level, divided by `m`. The scale is 0 to 1, and lower is better.
+ */
+export function cutShare(graph: Graph, groups: Grouping): number {
+  const m = graph.edges.length;
+  if (m === 0) return 0;
+  let cut = 0;
+  for (const e of graph.edges) if ((groups.get(e.source.node) ?? e.source.node) !== (groups.get(e.target.node) ?? e.target.node)) cut++;
+  return cut / m;
+}
+
+/**
+ * This function gives the balance of one level (G6 of MEAS0): `H(s) / log(k)`, with `s` the shares of the nodes of the `k` items and `H` the entropy.
+ * The scale is 0 to 1, and higher is better. A value of 1 is items of equal size. A level with one item gives 1.
+ */
+export function balance(level: Level): number {
+  const k = level.items.length;
+  const total = level.items.reduce((s, item) => s + item.nodes.length, 0);
+  if (k < 2 || total === 0) return 1;
+  let h = 0;
+  for (const item of level.items) {
+    const p = item.nodes.length / total;
+    if (p > 0) h -= p * Math.log(p);
+  }
+  return h / Math.log(k);
+}
+
+/**
+ * This function gives the tree cost of the levels (G8 of MEAS0, Dasgupta, 2016): `D = Σ_(u,v) leaves(lca(u, v)) / (m n)`.
+ * The levels make the tree. `leaves(lca(u, v))` is the number of nodes of the deepest item that holds both ends.
+ * Without such an item, the value is `n`. The scale is 0 to 1, and lower is better. The cost is linear times the depth.
+ */
+export function treeCost(graph: Graph, levels: readonly Level[]): number {
+  const n = graph.nodes.length;
+  const m = graph.edges.length;
+  if (n === 0 || m === 0) return 0;
+  const list = [...levels].sort((a, b) => b.depth - a.depth);
+  const maps = list.map((l) => {
+    const size = new Map<string, number>();
+    const of = new Map<string, string>();
+    for (const item of l.items) {
+      size.set(item.id, item.nodes.length);
+      for (const v of item.nodes) of.set(v, item.id);
+    }
+    return { size, of };
+  });
+  let sum = 0;
+  for (const e of graph.edges) {
+    let leaves = n;
+    for (const { size, of } of maps) {
+      const a = of.get(e.source.node);
+      if (a !== undefined && a === of.get(e.target.node)) {
+        leaves = size.get(a)!;
+        break;
+      }
+    }
+    sum += leaves;
+  }
+  return sum / (m * n);
+}
+
+/** This function gives the leaf of each node in a tree of sections: the id of the leaf, by the index of the node. */
+export function leafGroups(root: Section, count: number): string[] {
+  const out = new Array<string>(count).fill("");
+  const walk = (s: Section): void => {
+    if (s.children.length === 0) for (const i of s.nodes) out[i] = s.id;
+    else for (const c of s.children) walk(c);
+  };
+  walk(root);
+  return out.map((id, i) => id || `#${i}`);
+}
+
+/**
+ * This function gives the group stability of two trees of the same nodes (G9 of MEAS0): the adjusted Rand index of their leaves.
+ * The second tree comes from the graph after a small change (`changeGraph`). The scale is -1 to 1, and higher is better.
+ */
+export function groupStability(before: Section, after: Section, count: number): number {
+  return adjustedRandIndex(leafGroups(before, count), leafGroups(after, count));
+}

package/src/bench/measures/index.ts

@@ -0,0 +1,9 @@
+export * from "./stats.ts";
+export * from "./routes.ts";
+export * from "./bundles.ts";
+export * from "./curves.ts";
+export * from "./levels.ts";
+export * from "./groups.ts";
+export * from "./stability.ts";
+export * from "./room.ts";
+export * from "./pareto.ts";

package/src/bench/measures/levels.ts

@@ -0,0 +1,103 @@
+import { center, dist } from "../../geom.ts";
+import type { Graph, Level } from "../../model.ts";
+import { kendallTau } from "./stats.ts";
+
+/** This function gives the levels in the order of their depth, from the far view to the near view. */
+function byDepth(levels: readonly Level[]): Level[] {
+  return [...levels].sort((a, b) => a.depth - b.depth);
+}
+
+/** This function gives a map from the id of each node to the index of its item in the level. */
+function itemIndex(level: Level): Map<string, number> {
+  const m = new Map<string, number>();
+  level.items.forEach((item, i) => {
+    for (const n of item.nodes) m.set(n, i);
+  });
+  return m;
+}
+
+/**
+ * This function counts the faults of the nesting of the levels (Z6 of MEAS0, the proposed rule `level-nesting`).
+ * It counts the items of each level whose nodes are in more than one item of the level before it. Lower is better, and 0 is correct.
+ * The cost is linear.
+ */
+export function nestingFaults(levels: readonly Level[]): number {
+  const list = byDepth(levels);
+  let faults = 0;
+  for (let d = 1; d < list.length; d++) {
+    const coarse = itemIndex(list[d - 1]!);
+    for (const item of list[d]!.items) {
+      const parents = new Set<number | undefined>(item.nodes.map((n) => coarse.get(n)));
+      if (parents.size > 1) faults++;
+    }
+  }
+  return faults;
+}
+
+/**
+ * This function measures the position stability of the levels (Z7 of MEAS0).
+ * `ps = mean_(v,d) dist(center(item_d(v)), center(item_(d+1)(v))) / size(item_d(v))`, with `size` the longer side of the box.
+ * The value has no unit, and lower is better. A result with one level gives 0. The cost is linear.
+ */
+export function positionStability(levels: readonly Level[]): number {
+  const list = byDepth(levels);
+  let sum = 0;
+  let n = 0;
+  for (let d = 0; d + 1 < list.length; d++) {
+    const a = list[d]!;
+    const fine = itemIndex(list[d + 1]!);
+    const items = list[d + 1]!.items;
+    for (const item of a.items) {
+      const size = Math.max(item.box.w, item.box.h);
+      if (size <= 0) continue;
+      const c = center(item.box);
+      for (const v of item.nodes) {
+        const j = fine.get(v);
+        if (j === undefined) continue;
+        sum += dist(c, center(items[j]!.box)) / size;
+        n++;
+      }
+    }
+  }
+  return n ? sum / n : 0;
+}
+
+/**
+ * This function measures the order stability of the levels with groups (Z8 of MEAS0).
+ * For each level, `τ_x` and `τ_y` are the Kendall tau between the item centers and the centroids of their nodes on each axis.
+ * The value is the mean of `(τ_x + τ_y) / 2` over the levels with groups and two items or more. The scale is -1 to 1, and higher is better.
+ * A result without such a level gives 1. The cost is `n log n`, with a sample above 1500 items.
+ */
+export function orderStability(graph: Graph, levels: readonly Level[]): number {
+  const centers = new Map(graph.nodes.map((n) => [n.id, center(n.box)] as const));
+  let sum = 0;
+  let n = 0;
+  for (const level of levels) {
+    if (level.items.length < 2 || !level.items.some((i) => i.nodes.length > 1)) continue;
+    const ix: number[] = [];
+    const iy: number[] = [];
+    const nx: number[] = [];
+    const ny: number[] = [];
+    for (const item of level.items) {
+      let x = 0;
+      let y = 0;
+      let k = 0;
+      for (const v of item.nodes) {
+        const c = centers.get(v);
+        if (!c) continue;
+        x += c.x;
+        y += c.y;
+        k++;
+      }
+      if (k === 0) continue;
+      const c = center(item.box);
+      ix.push(c.x);
+      iy.push(c.y);
+      nx.push(x / k);
+      ny.push(y / k);
+    }
+    sum += (kendallTau(ix, nx, level.depth + 1) + kendallTau(iy, ny, level.depth + 1)) / 2;
+    n++;
+  }
+  return n ? sum / n : 1;
+}

package/src/bench/measures/pareto.ts

@@ -0,0 +1,37 @@
+/** One axis of a Pareto front: the key of a measure and the direction that is better. */
+export interface Objective {
+  readonly key: string;
+  /** `min`: lower is better. `max`: higher is better. */
+  readonly better: "min" | "max";
+}
+
+/** This function gives the value of a measure as a cost: lower is better. A value that is not a number is the worst cost. */
+function cost(values: Readonly<Record<string, number>>, o: Objective): number {
+  const v = values[o.key];
+  if (v === undefined || Number.isNaN(v)) return Infinity;
+  return o.better === "min" ? v : -v;
+}
+
+/**
+ * This function tells if the values `a` dominate the values `b`: `a` is no worse on each objective and better on one objective.
+ * A missing value or `NaN` is the worst value.
+ */
+export function dominates(a: Readonly<Record<string, number>>, b: Readonly<Record<string, number>>, objectives: readonly Objective[]): boolean {
+  let better = false;
+  for (const o of objectives) {
+    const ca = cost(a, o);
+    const cb = cost(b, o);
+    if (ca > cb) return false;
+    if (ca < cb) better = true;
+  }
+  return better;
+}
+
+/**
+ * This function gives the Pareto front of a list: the items that no other item dominates (MEAS0, "Pareto fronts").
+ * The function `values` gives the measures of an item. The front keeps the order of the list. The cost is quadratic in the items.
+ */
+export function paretoFront<T>(items: readonly T[], values: (item: T) => Readonly<Record<string, number>>, objectives: readonly Objective[]): T[] {
+  const v = items.map(values);
+  return items.filter((_, i) => !v.some((w, j) => j !== i && dominates(w, v[i]!, objectives)));
+}

package/src/bench/measures/room.ts

@@ -0,0 +1,43 @@
+import { rng } from "../../fixtures.ts";
+import type { Box } from "../../geom.ts";
+import type { Boxed } from "../../room/index.ts";
+
+/** Up to this number of boxes, `roomOrderFaults` examines each pair. */
+const EXACT_PAIRS = 2000;
+const SAMPLE_PAIRS = 2_000_000;
+
+/**
+ * This function counts the pairs of boxes whose order or alignment changes on an axis (M2 of MEAS0, the proposed rule `room-order`).
+ * On each axis, it compares the order of the low edges, the order of the high edges, and the relation "a ends before b starts".
+ * Two values nearer than `snap` are equal. Lower is better, and 0 is correct. Above 2000 boxes, a seeded sample of pairs gives an estimate.
+ */
+export function roomOrderFaults(before: readonly Boxed[], after: readonly Boxed[], snap = 0.5): number {
+  const next = new Map(after.map((b) => [b.id, b.box] as const));
+  const list: [Box, Box][] = [];
+  for (const b of before) {
+    const a = next.get(b.id);
+    if (a) list.push([b.box, a]);
+  }
+  const sign = (x: number): number => (x > snap ? 1 : x < -snap ? -1 : 0);
+  // The key packs the eight relations of a pair into one number in base 3.
+  const axis = (p0: number, p1: number, q0: number, q1: number): number =>
+    (sign(p0 - q0) + 1) * 27 + (sign(p1 - q1) + 1) * 9 + (q0 - p1 >= -snap ? 3 : 0) + (p0 - q1 >= -snap ? 1 : 0);
+  const key = (p: Box, q: Box): number => axis(p.x, p.x + p.w, q.x, q.x + q.w) * 81 + axis(p.y, p.y + p.h, q.y, q.y + q.h);
+  const changed = (i: number, j: number): boolean => key(list[i]![0], list[j]![0]) !== key(list[i]![1], list[j]![1]);
+  const n = list.length;
+  let faults = 0;
+  if (n <= EXACT_PAIRS) {
+    for (let i = 0; i < n; i++) for (let j = i + 1; j < n; j++) if (changed(i, j)) faults++;
+    return faults;
+  }
+  const R = rng(n);
+  let seen = 0;
+  for (let k = 0; k < SAMPLE_PAIRS; k++) {
+    const i = Math.floor(R() * n);
+    const j = Math.floor(R() * n);
+    if (i === j) continue;
+    seen++;
+    if (changed(i, j)) faults++;
+  }
+  return Math.round((faults * (n * (n - 1)) / 2) / Math.max(1, seen));
+}