@mark1russell7/highways 0.5.0 → 0.5.1

package/package.json

@@ -9,7 +9,7 @@
     "directory": "packages/core"
   },
   "homepage": "https://mark1russell7.github.io/highways/",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "type": "module",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -28,9 +28,11 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@mark1russell7/layout-contract": "^0.2.6"
+  },
   "devDependencies": {
     "@mark1russell7/cue": "github:mark1russell7/cue",
-    "@mark1russell7/layout-contract": "github:mark1russell7/layout-contract#69933a61b0270c5915b82ab563d24908ade708af&path:/packages/layout-contract",
     "@types/node": "^26.6.4",
     "highs": "^1.15.4",
     "typescript": "^7.0.2",
@@ -45,6 +47,13 @@
     "profile": "node scripts/profile.ts",
     "levels": "node scripts/levels.ts",
     "screen": "node scripts/screen.ts",
+    "exact": "node scripts/exact.ts",
+    "oracle": "node scripts/oracle.ts",
+    "portfolio": "node scripts/portfolio.ts",
+    "portfolio:time": "node scripts/portfolio-time.ts",
+    "portfolio:sets": "node scripts/portfolio-sets.ts",
+    "portfolio:api": "node scripts/portfolio-api-report.ts",
+    "bounds": "node scripts/bounds.ts",
     "screen:inputs": "node scripts/screen-inputs.ts",
     "test:watch": "vitest",
     "typecheck": "tsc -p tsconfig.json && tsc -p tsconfig.test.json"

package/src/bench/exact/index.ts

@@ -1,7 +1,7 @@
-import { dist, type Point } from "../../geom.ts";
+import { dist, polylineLength, type Point } from "../../geom.ts";
 import { edgePlugs, sharedStretches, type KeyedWay } from "../../highways/stretches.ts";
 import type { HighwayPlan } from "../../highways/model.ts";
-import type { Graph } from "../../model.ts";
+import type { Edge, Graph, Route } from "../../model.ts";
 import { byCollection } from "../../routers/trunks.ts";
 import { WayFinder, type WayOptions } from "../../ways.ts";
 
@@ -28,6 +28,8 @@ export interface ExactModel {
   readonly rows: number;
   /** The number of edges in the model. An edge without a way in the stretch limit is not in the model. */
   readonly edges: number;
+  /** The length of the arc or the link of each binary variable, by its name. A name `x…` is an arc of an edge, and a name `y…` is a link of a key. */
+  readonly lengths: ReadonlyMap<string, number>;
   /** This function gives the plan of a solution. `value` gives the value of a variable by its name. */
   decode(value: (name: string) => number): HighwayPlan;
 }
@@ -54,13 +56,19 @@ function distances(adj: readonly (readonly { to: number; len: number }[])[], sta
   }
 }
 
-/**
- * This function gives the model of fixed-charge network design (Magnanti and Wong 1984) for the edges of a graph (HWY-040).
- * The network is the corner graph, plus the point out of each plug. Each link costs its length once for each key that uses it.
- * Each edge goes one way between the points out of its two plugs. The way is `stretch` times its shortest way or shorter.
- * The optimum has the least ink for the stretch limit. The ways of the solution give highways with `sharedStretches`.
- */
-export function exactModel(graph: Graph, o: Readonly<ExactOptions>): ExactModel {
+/** The network of the exact model: the corner graph, plus the point out of each plug of each edge. */
+interface ExactNetwork {
+  readonly points: readonly Point[];
+  readonly links: readonly { readonly u: number; readonly v: number; readonly len: number }[];
+  readonly adj: readonly (readonly { to: number; len: number }[])[];
+  /** The two end points of each edge: the points out of its plugs. */
+  readonly ends: readonly { readonly edge: Edge; readonly a: number; readonly b: number }[];
+  /** The distance from a plug to the point out of it. */
+  readonly margin: number;
+}
+
+/** This function makes the network of the exact model for the edges of a graph. */
+function exactNetwork(graph: Graph, o: Readonly<WayOptions>): ExactNetwork {
   const finder = new WayFinder(graph.nodes, { ...(o.margin === undefined ? {} : { margin: o.margin }), ...(o.k === undefined ? {} : { k: o.k }) });
   const corners = finder.corners;
   const k = o.k ?? 8;
@@ -79,7 +87,7 @@ export function exactModel(graph: Graph, o: Readonly<ExactOptions>): ExactModel
   };
   corners.points.forEach((p, i) => ids.set(`${p.x},${p.y}`, i));
   const plugs = edgePlugs(graph);
-  const ends = plugs.map(({ edge, ps, pt }) => ({ edge: edge.id, key: o.rule === "all" ? "*" : (byCollection(edge) ?? `\u0000${edge.id}`), a: nodeOf(finder.out(ps)), b: nodeOf(finder.out(pt)) }));
+  const ends = plugs.map(({ edge, ps, pt }) => ({ edge, a: nodeOf(finder.out(ps)), b: nodeOf(finder.out(pt)) }));
 
   // The links: each corner to its k nearest visible corners, as in the corner graph, and each end point to its 2k nearest visible corners.
   const linkIds = new Map<string, number>();
@@ -99,12 +107,25 @@ export function exactModel(graph: Graph, o: Readonly<ExactOptions>): ExactModel
     adj[l.u]!.push({ to: l.v, len: l.len });
     adj[l.v]!.push({ to: l.u, len: l.len });
   }
+  return { points, links, adj, ends, margin: finder.margin };
+}
+
+/**
+ * This function gives the model of fixed-charge network design (Magnanti and Wong 1984) for the edges of a graph (HWY-040).
+ * The network is the corner graph, plus the point out of each plug. Each link costs its length once for each key that uses it.
+ * Each edge goes one way between the points out of its two plugs. The way is `stretch` times its shortest way or shorter.
+ * The optimum has the least ink for the stretch limit. The ways of the solution give highways with `sharedStretches`.
+ */
+export function exactModel(graph: Graph, o: Readonly<ExactOptions>): ExactModel {
+  const { points, links, adj, ends: outs } = exactNetwork(graph, o);
+  const ends = outs.map((e) => ({ edge: e.edge.id, key: o.rule === "all" ? "*" : (byCollection(e.edge) ?? `\u0000${e.edge.id}`), a: e.a, b: e.b }));
 
   // The arcs of each edge: the arcs on some way within the stretch limit.
   const eps = o.epsilon ?? 0.001;
   const objective: string[] = [];
   const rows: string[] = [];
   const binaries: string[] = [];
+  const lengths = new Map<string, number>();
   const keys = [...new Set(ends.map((e) => e.key))];
   const used = new Map<string, Set<number>>();
   const arcsOf: { e: number; arcs: Arc[] }[] = [];
@@ -134,6 +155,7 @@ export function exactModel(graph: Graph, o: Readonly<ExactOptions>): ExactModel
     for (const a of arcs) {
       const x = `x${ei}_${a.link}_${a.from < a.to ? 0 : 1}`;
       binaries.push(x);
+      lengths.set(x, a.len);
       objective.push(`${(eps * a.len).toFixed(6)} ${x}`);
       term(a.from, `+ ${x}`);
       term(a.to, `- ${x}`);
@@ -156,6 +178,7 @@ export function exactModel(graph: Graph, o: Readonly<ExactOptions>): ExactModel
     for (const li of used.get(key) ?? []) {
       const y = `y${ki}_${li}`;
       binaries.push(y);
+      lengths.set(y, links[li]!.len);
       objective.push(`${links[li]!.len.toFixed(6)} ${y}`);
     }
   });
@@ -193,5 +216,43 @@ export function exactModel(graph: Graph, o: Readonly<ExactOptions>): ExactModel
     }
     return sharedStretches(ways, { minSize: 2 });
   };
-  return { lp, columns: binaries.length, rows: rows.length, edges: arcsOf.length, decode };
+  return { lp, columns: binaries.length, rows: rows.length, edges: arcsOf.length, lengths, decode };
+}
+
+/**
+ * This function gives the stretch of each route as the exact model counts it, by the edge id.
+ * The stretch of a route is its length without its two plug ends, divided by the shortest way in the network of the model.
+ * The function builds the network one time. The result function then measures each list of routes of the graph, so a portfolio pays for the network once.
+ * An edge without a route or without a way in the network has no value.
+ */
+export function exactStretches(graph: Graph, o: Readonly<WayOptions> = {}): (routes: readonly Route[]) => Map<string, number> {
+  const { adj, ends, margin } = exactNetwork(graph, o);
+  const best = new Map<number, Float64Array>();
+  const from = (a: number): Float64Array => {
+    if (!best.has(a)) best.set(a, distances(adj, a));
+    return best.get(a)!;
+  };
+  return (routes) => {
+    const byEdge = new Map(routes.map((r) => [r.edge, r]));
+    const out = new Map<string, number>();
+    for (const e of ends) {
+      const r = byEdge.get(e.edge.id);
+      if (!r || r.points.length < 2 || e.a === e.b) continue;
+      const b = from(e.a)[e.b]!;
+      if (!Number.isFinite(b) || b <= 1) continue;
+      out.set(e.edge.id, (polylineLength(r.points) - 2 * margin) / b);
+    }
+    return out;
+  };
+}
+
+/**
+ * This function gives the largest stretch of routes as the exact model counts it (`exactStretches`).
+ * The cap of the model is a limit on this value.
+ * An edge without a route or without a way in the network does not count. Without such an edge, the value is 1.
+ */
+export function exactStretch(graph: Graph, routes: readonly Route[], o: Readonly<WayOptions> = {}): number {
+  let max = 1;
+  for (const v of exactStretches(graph, o)(routes).values()) max = Math.max(max, v);
+  return max;
 }