@tscircuit/hypergraph 0.0.9 → 0.0.10

package/dist/index.d.ts

@@ -19,6 +19,11 @@ type RegionPort = {
      * ports that are likely to block off connections
      */
     ripCount?: number;
+    /**
+     * Optionally can be used by solvers to keep track of the distance to
+     * each end era.
+     */
+    distanceToEndMap?: Record<RegionId, number>;
 };
 type Region = {
     regionId: RegionId;
@@ -345,11 +350,26 @@ declare class HyperGraphSolver<RegionType extends Region = Region, RegionPortTyp
      * can also help avoid loops
      */
     routeSolvedHook(solvedRoute: SolvedRoute): void;
+    /**
+     * OPTIONALLY OVERRIDE THIS
+     *
+     * You can override this to perform actions when a new route begins, e.g.
+     * you may want to log or track which connection is being processed.
+     */
+    routeStartedHook(connection: Connection): void;
     ripSolvedRoute(solvedRoute: SolvedRoute): void;
     beginNewConnection(): void;
     _step(): void;
 }
 
+declare const JUMPER_GRAPH_SOLVER_DEFAULTS: {
+    portUsagePenalty: number;
+    portUsagePenaltySq: number;
+    crossingPenalty: number;
+    crossingPenaltySq: number;
+    ripCost: number;
+    greedyMultiplier: number;
+};
 declare class JumperGraphSolver extends HyperGraphSolver<JRegion, JPort> {
     UNIT_OF_COST: string;
     portUsagePenalty: number;
@@ -368,11 +388,13 @@ declare class JumperGraphSolver extends HyperGraphSolver<JRegion, JPort> {
         baseMaxIterations?: number;
         additionalMaxIterationsPerConnection?: number;
     });
+    private populateDistanceToEndMaps;
     estimateCostToEnd(port: JPort): number;
     getPortUsagePenalty(port: JPort): number;
     computeIncreasedRegionCostIfPortsAreUsed(region: JRegion, port1: JPort, port2: JPort): number;
     getRipsRequiredForPortUsage(region: JRegion, port1: JPort, port2: JPort): RegionPortAssignment[];
     routeSolvedHook(solvedRoute: SolvedRoute): void;
+    routeStartedHook(connection: Connection): void;
     visualize(): GraphicsObject;
 }
 
@@ -386,4 +408,4 @@ declare const applyTransformToGraph: (graph: JumperGraph, matrix: Matrix) => Jum
  */
 declare const rotateGraph90Degrees: (graph: JumperGraph) => JumperGraph;
 
-export { type Candidate, type Connection, type ConnectionId, type GScore, type GraphEdgeId, type HyperGraph, HyperGraphSolver, type JPort, type JRegion, type JumperGraph, JumperGraphSolver, type JumperGraphWithConnections, type NetworkId, type PortAssignment, type PortId, type Region, type RegionId, type RegionPort, type RegionPortAssignment, type SerializedConnection, type SerializedGraphPort, type SerializedGraphRegion, type SerializedHyperGraph, type SerializedRegionPortAssignment, type SolvedRoute, type XYConnection, applyTransformToGraph, createGraphWithConnectionsFromBaseGraph, generateJumperGrid, generateJumperX4Grid, rotateGraph90Degrees };
+export { type Candidate, type Connection, type ConnectionId, type GScore, type GraphEdgeId, type HyperGraph, HyperGraphSolver, type JPort, type JRegion, JUMPER_GRAPH_SOLVER_DEFAULTS, type JumperGraph, JumperGraphSolver, type JumperGraphWithConnections, type NetworkId, type PortAssignment, type PortId, type Region, type RegionId, type RegionPort, type RegionPortAssignment, type SerializedConnection, type SerializedGraphPort, type SerializedGraphRegion, type SerializedHyperGraph, type SerializedRegionPortAssignment, type SolvedRoute, type XYConnection, applyTransformToGraph, createGraphWithConnectionsFromBaseGraph, generateJumperGrid, generateJumperX4Grid, rotateGraph90Degrees };

package/dist/index.js

@@ -1935,6 +1935,14 @@ var HyperGraphSolver = class extends BaseSolver {
    */
   routeSolvedHook(solvedRoute) {
   }
+  /**
+   * OPTIONALLY OVERRIDE THIS
+   *
+   * You can override this to perform actions when a new route begins, e.g.
+   * you may want to log or track which connection is being processed.
+   */
+  routeStartedHook(connection) {
+  }
   ripSolvedRoute(solvedRoute) {
     for (const port of solvedRoute.path.map((candidate) => candidate.port)) {
       port.ripCount = (port.ripCount ?? 0) + 1;
@@ -1954,6 +1962,7 @@ var HyperGraphSolver = class extends BaseSolver {
     this.currentEndRegion = this.currentConnection.endRegion;
     this.candidateQueue = new PriorityQueue();
     this.visitedPointsForCurrentConnection.clear();
+    this.routeStartedHook(this.currentConnection);
     for (const port of this.currentConnection.startRegion.ports) {
       this.candidateQueue.enqueue({
         port,
@@ -2212,13 +2221,6 @@ var visualizeJumperGraphSolver = (solver) => {
   return graphics;
 };
 
-// node_modules/@tscircuit/math-utils/dist/chunk-EFLPMB4J.js
-function distance(p1, p2) {
-  const dx = p1.x - p2.x;
-  const dy = p1.y - p2.y;
-  return Math.sqrt(dx * dx + dy * dy);
-}
-
 // lib/JumperGraphSolver/perimeterChordUtils.ts
 function perimeterT(p, xmin, xmax, ymin, ymax) {
   const W = xmax - xmin;
@@ -2327,18 +2329,26 @@ function computeCrossingAssignments(region, port1, port2) {
 }
 
 // lib/JumperGraphSolver/JumperGraphSolver.ts
+var JUMPER_GRAPH_SOLVER_DEFAULTS = {
+  portUsagePenalty: 0.06393718451067248,
+  portUsagePenaltySq: 0.06194817180037216,
+  crossingPenalty: 6.0761550028071145,
+  crossingPenaltySq: 0.1315528159128946,
+  ripCost: 40.00702225250195,
+  greedyMultiplier: 0.4316469416682083
+};
 var JumperGraphSolver = class extends HyperGraphSolver {
   UNIT_OF_COST = "distance";
-  portUsagePenalty = 0.197;
-  portUsagePenaltySq = 0;
-  crossingPenalty = 6.007;
-  crossingPenaltySq = 0.111;
-  ripCost = 40;
+  portUsagePenalty = JUMPER_GRAPH_SOLVER_DEFAULTS.portUsagePenalty;
+  portUsagePenaltySq = JUMPER_GRAPH_SOLVER_DEFAULTS.portUsagePenaltySq;
+  crossingPenalty = JUMPER_GRAPH_SOLVER_DEFAULTS.crossingPenalty;
+  crossingPenaltySq = JUMPER_GRAPH_SOLVER_DEFAULTS.crossingPenaltySq;
+  ripCost = JUMPER_GRAPH_SOLVER_DEFAULTS.ripCost;
   baseMaxIterations = 4e3;
-  additionalMaxIterationsPerConnection = 2e3;
+  additionalMaxIterationsPerConnection = 4e3;
   constructor(input) {
     super({
-      greedyMultiplier: 0.45,
+      greedyMultiplier: JUMPER_GRAPH_SOLVER_DEFAULTS.greedyMultiplier,
       rippingEnabled: true,
       ...input
     });
@@ -2348,9 +2358,39 @@ var JumperGraphSolver = class extends HyperGraphSolver {
     this.baseMaxIterations = input.baseMaxIterations ?? this.baseMaxIterations;
     this.additionalMaxIterationsPerConnection = input.additionalMaxIterationsPerConnection ?? this.additionalMaxIterationsPerConnection;
     this.MAX_ITERATIONS = this.baseMaxIterations + input.inputConnections.length * this.additionalMaxIterationsPerConnection;
+    this.populateDistanceToEndMaps();
+  }
+  populateDistanceToEndMaps() {
+    const endRegions = new Set(this.connections.map((c) => c.endRegion));
+    for (const endRegion of endRegions) {
+      const regionDistanceMap = /* @__PURE__ */ new Map();
+      const queue = [];
+      regionDistanceMap.set(endRegion.regionId, 0);
+      queue.push({ region: endRegion, distance: 0 });
+      while (queue.length > 0) {
+        const { region, distance: dist } = queue.shift();
+        for (const port of region.ports) {
+          const otherRegion = port.region1 === region ? port.region2 : port.region1;
+          if (!regionDistanceMap.has(otherRegion.regionId)) {
+            regionDistanceMap.set(otherRegion.regionId, dist + 1);
+            queue.push({ region: otherRegion, distance: dist + 1 });
+          }
+        }
+      }
+      for (const port of this.graph.ports) {
+        if (!port.distanceToEndMap) {
+          port.distanceToEndMap = {};
+        }
+        const d1 = regionDistanceMap.get(port.region1.regionId) ?? Infinity;
+        const d2 = regionDistanceMap.get(port.region2.regionId) ?? Infinity;
+        port.distanceToEndMap[endRegion.regionId] = Math.min(d1, d2);
+      }
+    }
   }
   estimateCostToEnd(port) {
-    return distance(port.d, this.currentEndRegion.d.center);
+    const endRegionId = this.currentEndRegion.regionId;
+    const hopDistance = port.distanceToEndMap[endRegionId];
+    return hopDistance;
   }
   getPortUsagePenalty(port) {
     const ripCount = port.ripCount ?? 0;
@@ -2368,12 +2408,15 @@ var JumperGraphSolver = class extends HyperGraphSolver {
   }
   routeSolvedHook(solvedRoute) {
   }
+  routeStartedHook(connection) {
+  }
   visualize() {
     return visualizeJumperGraphSolver(this);
   }
 };
 export {
   HyperGraphSolver,
+  JUMPER_GRAPH_SOLVER_DEFAULTS,
   JumperGraphSolver,
   applyTransformToGraph,
   createGraphWithConnectionsFromBaseGraph,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/hypergraph",
   "main": "dist/index.js",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "type": "module",
   "scripts": {
     "start": "cosmos",