@tscircuit/hypergraph 0.0.13 → 0.0.15

package/dist/index.d.ts

@@ -389,6 +389,7 @@ declare class JumperGraphSolver extends HyperGraphSolver<JRegion, JPort> {
     ripCost: number;
     baseMaxIterations: number;
     additionalMaxIterationsPerConnection: number;
+    additionalMaxIterationsPerCrossing: number;
     constructor(input: {
         inputGraph: HyperGraph | SerializedHyperGraph;
         inputConnections: (Connection | SerializedConnection)[];

package/dist/index.js

@@ -10,19 +10,21 @@ var computeBoundsCenter = (bounds) => {
 var dims1206x4 = {
   padWidth: 0.8,
   // X direction (horizontal)
-  padHeight: 0.5,
-  // Y direction (vertical)
-  leftPadCenterX: -1.35,
+  outerPadHeight: 0.5,
+  // Y direction (vertical) for rows 1 and 4
+  innerPadHeight: 0.4,
+  // Y direction (vertical) for rows 2 and 3
+  leftPadCenterX: -0.9,
   // X position of left pads (P1, P2, P3, P4)
-  rightPadCenterX: 1.35,
+  rightPadCenterX: 0.9,
   // X position of right pads (P5, P6, P7, P8)
-  row1CenterY: 1.905,
+  row1CenterY: -1.2,
   // Y position of row 1 (P1, P8)
-  row2CenterY: 0.635,
+  row2CenterY: -0.4,
   // Y position of row 2 (P2, P7)
-  row3CenterY: -0.635,
+  row3CenterY: 0.4,
   // Y position of row 3 (P3, P6)
-  row4CenterY: -1.905
+  row4CenterY: 1.2
   // Y position of row 4 (P4, P5)
 };
 
@@ -232,7 +234,8 @@ var generateJumperX4Grid = ({
   const ports = [];
   const {
     padWidth,
-    padHeight,
+    outerPadHeight,
+    innerPadHeight,
     leftPadCenterX,
     rightPadCenterX,
     row1CenterY,
@@ -241,10 +244,11 @@ var generateJumperX4Grid = ({
     row4CenterY
   } = dims1206x4;
   const padHalfWidth = padWidth / 2;
-  const padHalfHeight = padHeight / 2;
+  const outerPadHalfHeight = outerPadHeight / 2;
+  const innerPadHalfHeight = innerPadHeight / 2;
   const cellWidth = rightPadCenterX - leftPadCenterX + padWidth;
   const horizontalSpacing = cellWidth + marginX;
-  const cellHeight = row1CenterY - row4CenterY + padHeight;
+  const cellHeight = row4CenterY - row1CenterY + outerPadHeight;
   const verticalSpacing = cellHeight + marginY;
   let outerPaddingX = outerPaddingXParam;
   let outerPaddingY = outerPaddingYParam;
@@ -365,25 +369,59 @@ var generateJumperX4Grid = ({
       const p7CenterY = centerY + row2CenterY;
       const p8CenterX = centerX + rightPadCenterX;
       const p8CenterY = centerY + row1CenterY;
-      const createPadBounds = (padCenterX, padCenterY) => ({
+      const createPadBounds = (padCenterX, padCenterY, halfHeight) => ({
         minX: padCenterX - padHalfWidth,
         maxX: padCenterX + padHalfWidth,
-        minY: padCenterY - padHalfHeight,
-        maxY: padCenterY + padHalfHeight
+        minY: padCenterY - halfHeight,
+        maxY: padCenterY + halfHeight
       });
-      const pad1Bounds = createPadBounds(p1CenterX, p1CenterY);
-      const pad2Bounds = createPadBounds(p2CenterX, p2CenterY);
-      const pad3Bounds = createPadBounds(p3CenterX, p3CenterY);
-      const pad4Bounds = createPadBounds(p4CenterX, p4CenterY);
-      const pad5Bounds = createPadBounds(p5CenterX, p5CenterY);
-      const pad6Bounds = createPadBounds(p6CenterX, p6CenterY);
-      const pad7Bounds = createPadBounds(p7CenterX, p7CenterY);
-      const pad8Bounds = createPadBounds(p8CenterX, p8CenterY);
+      const pad1Bounds = createPadBounds(
+        p1CenterX,
+        p1CenterY,
+        outerPadHalfHeight
+      );
+      const pad2Bounds = createPadBounds(
+        p2CenterX,
+        p2CenterY,
+        innerPadHalfHeight
+      );
+      const pad3Bounds = createPadBounds(
+        p3CenterX,
+        p3CenterY,
+        innerPadHalfHeight
+      );
+      const pad4Bounds = createPadBounds(
+        p4CenterX,
+        p4CenterY,
+        outerPadHalfHeight
+      );
+      const pad5Bounds = createPadBounds(
+        p5CenterX,
+        p5CenterY,
+        outerPadHalfHeight
+      );
+      const pad6Bounds = createPadBounds(
+        p6CenterX,
+        p6CenterY,
+        innerPadHalfHeight
+      );
+      const pad7Bounds = createPadBounds(
+        p7CenterX,
+        p7CenterY,
+        innerPadHalfHeight
+      );
+      const pad8Bounds = createPadBounds(
+        p8CenterX,
+        p8CenterY,
+        outerPadHalfHeight
+      );
       const underjumperBounds = {
         minX: pad1Bounds.maxX,
         maxX: pad8Bounds.minX,
-        minY: pad4Bounds.minY,
-        maxY: pad1Bounds.maxY
+        minY: pad1Bounds.minY,
+        // row 1 is now at bottom (Y=-1.2)
+        maxY: pad4Bounds.maxY
+        // row 4 is now at top (Y=1.2)
       };
       const throughjumperHeight = 0.3;
       const throughjumper1Bounds = {
@@ -412,8 +450,8 @@ var generateJumperX4Grid = ({
       };
       const mainMinX = pad1Bounds.minX;
       const mainMaxX = pad8Bounds.maxX;
-      const mainMinY = pad4Bounds.minY;
-      const mainMaxY = pad1Bounds.maxY;
+      const mainMinY = pad1Bounds.minY;
+      const mainMaxY = pad4Bounds.maxY;
       const pad1 = createRegion(`${idPrefix}:pad1`, pad1Bounds, true);
       const pad2 = createRegion(`${idPrefix}:pad2`, pad2Bounds, true);
       const pad3 = createRegion(`${idPrefix}:pad3`, pad3Bounds, true);
@@ -485,8 +523,10 @@ var generateJumperX4Grid = ({
           {
             minX: pad1Bounds.minX,
             maxX: pad1Bounds.maxX,
-            minY: pad2Bounds.maxY,
-            maxY: pad1Bounds.minY
+            minY: pad1Bounds.maxY,
+            // top of pad1
+            maxY: pad2Bounds.minY
+            // bottom of pad2
           },
           false
         );
@@ -495,8 +535,10 @@ var generateJumperX4Grid = ({
           {
             minX: pad2Bounds.minX,
             maxX: pad2Bounds.maxX,
-            minY: pad3Bounds.maxY,
-            maxY: pad2Bounds.minY
+            minY: pad2Bounds.maxY,
+            // top of pad2
+            maxY: pad3Bounds.minY
+            // bottom of pad3
           },
           false
         );
@@ -505,8 +547,10 @@ var generateJumperX4Grid = ({
           {
             minX: pad3Bounds.minX,
             maxX: pad3Bounds.maxX,
-            minY: pad4Bounds.maxY,
-            maxY: pad3Bounds.minY
+            minY: pad3Bounds.maxY,
+            // top of pad3
+            maxY: pad4Bounds.minY
+            // bottom of pad4
           },
           false
         );
@@ -515,8 +559,10 @@ var generateJumperX4Grid = ({
           {
             minX: pad8Bounds.minX,
             maxX: pad8Bounds.maxX,
-            minY: pad7Bounds.maxY,
-            maxY: pad8Bounds.minY
+            minY: pad8Bounds.maxY,
+            // top of pad8
+            maxY: pad7Bounds.minY
+            // bottom of pad7
           },
           false
         );
@@ -525,8 +571,10 @@ var generateJumperX4Grid = ({
           {
             minX: pad7Bounds.minX,
             maxX: pad7Bounds.maxX,
-            minY: pad6Bounds.maxY,
-            maxY: pad7Bounds.minY
+            minY: pad7Bounds.maxY,
+            // top of pad7
+            maxY: pad6Bounds.minY
+            // bottom of pad6
           },
           false
         );
@@ -535,8 +583,10 @@ var generateJumperX4Grid = ({
           {
             minX: pad6Bounds.minX,
             maxX: pad6Bounds.maxX,
-            minY: pad5Bounds.maxY,
-            maxY: pad6Bounds.minY
+            minY: pad6Bounds.maxY,
+            // top of pad6
+            maxY: pad5Bounds.minY
+            // bottom of pad5
           },
           false
         );
@@ -657,8 +707,8 @@ var generateJumperX4Grid = ({
             isLastCol ? effectiveOuterChannelXPoints : innerColChannelPointCount
           )
         );
-        ports.push(createPort(`${idPrefix}:T-P1`, top, pad1));
-        ports.push(createPort(`${idPrefix}:T-P8`, top, pad8));
+        ports.push(createPort(`${idPrefix}:T-P4`, top, pad4));
+        ports.push(createPort(`${idPrefix}:T-P5`, top, pad5));
         if (regionsBetweenPads) {
           const ujBounds = underjumper.d.bounds;
           const ujWidth = ujBounds.maxX - ujBounds.minX;
@@ -698,8 +748,8 @@ var generateJumperX4Grid = ({
             isLastCol ? effectiveOuterChannelXPoints : innerColChannelPointCount
           )
         );
-        ports.push(createPort(`${idPrefix}:B-P4`, bottom, pad4));
-        ports.push(createPort(`${idPrefix}:B-P5`, bottom, pad5));
+        ports.push(createPort(`${idPrefix}:B-P1`, bottom, pad1));
+        ports.push(createPort(`${idPrefix}:B-P8`, bottom, pad8));
         if (regionsBetweenPads) {
           const ujBounds = underjumper.d.bounds;
           const ujWidth = ujBounds.maxX - ujBounds.minX;
@@ -906,9 +956,9 @@ var generateJumperX4Grid = ({
         }
         ports.push(
           createPort(
-            `cell_${row - 1}_${col}->cell_${row}_${col}:B-P1`,
+            `cell_${row - 1}_${col}->cell_${row}_${col}:B-P4`,
             aboveCell.bottom,
-            pad1
+            pad4
           )
         );
         if (regionsBetweenPads) {
@@ -938,9 +988,9 @@ var generateJumperX4Grid = ({
         }
         ports.push(
           createPort(
-            `cell_${row - 1}_${col}->cell_${row}_${col}:B-P8`,
+            `cell_${row - 1}_${col}->cell_${row}_${col}:B-P5`,
             aboveCell.bottom,
-            pad8
+            pad5
           )
         );
         ports.push(
@@ -2369,24 +2419,88 @@ function computeCrossingAssignments(region, port1, port2) {
   return crossingAssignments;
 }
 
+// lib/JumperGraphSolver/countInputConnectionCrossings.ts
+function countInputConnectionCrossings(graph, connections) {
+  if (connections.length < 2) {
+    return 0;
+  }
+  let minX = Infinity;
+  let maxX = -Infinity;
+  let minY = Infinity;
+  let maxY = -Infinity;
+  for (const region of graph.regions) {
+    const jRegion = region;
+    if (jRegion.d?.bounds) {
+      minX = Math.min(minX, jRegion.d.bounds.minX);
+      maxX = Math.max(maxX, jRegion.d.bounds.maxX);
+      minY = Math.min(minY, jRegion.d.bounds.minY);
+      maxY = Math.max(maxY, jRegion.d.bounds.maxY);
+    } else if (jRegion.d?.center) {
+      minX = Math.min(minX, jRegion.d.center.x);
+      maxX = Math.max(maxX, jRegion.d.center.x);
+      minY = Math.min(minY, jRegion.d.center.y);
+      maxY = Math.max(maxY, jRegion.d.center.y);
+    }
+  }
+  const regionCenterMap = /* @__PURE__ */ new Map();
+  for (const region of graph.regions) {
+    const jRegion = region;
+    if (jRegion.d?.center) {
+      regionCenterMap.set(region.regionId, jRegion.d.center);
+    }
+  }
+  const chords = [];
+  for (const conn of connections) {
+    let startCenter;
+    let endCenter;
+    if ("startRegion" in conn && conn.startRegion) {
+      const startRegion = conn.startRegion;
+      const endRegion = conn.endRegion;
+      startCenter = startRegion.d?.center;
+      endCenter = endRegion.d?.center;
+    } else if ("startRegionId" in conn) {
+      startCenter = regionCenterMap.get(conn.startRegionId);
+      endCenter = regionCenterMap.get(conn.endRegionId);
+    }
+    if (!startCenter || !endCenter) {
+      continue;
+    }
+    const t1 = perimeterT(startCenter, minX, maxX, minY, maxY);
+    const t2 = perimeterT(endCenter, minX, maxX, minY, maxY);
+    chords.push([t1, t2]);
+  }
+  let crossings = 0;
+  for (let i = 0; i < chords.length; i++) {
+    for (let j = i + 1; j < chords.length; j++) {
+      if (chordsCross(chords[i], chords[j])) {
+        crossings++;
+      }
+    }
+  }
+  return crossings;
+}
+
 // 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
+  portUsagePenalty: 0.034685181009478865,
+  // portUsagePenaltySq: 0.06194817180037216,
+  portUsagePenaltySq: 0,
+  crossingPenalty: 4.072520483177124,
+  crossingPenaltySq: 0,
+  // crossingPenaltySq: 0.1315528159128946,
+  ripCost: 35.38577539020022,
+  greedyMultiplier: 0.5518001238069296
 };
 var JumperGraphSolver = class extends HyperGraphSolver {
-  UNIT_OF_COST = "distance";
+  UNIT_OF_COST = "hops";
   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 = 4e3;
+  additionalMaxIterationsPerConnection = 2e3;
+  additionalMaxIterationsPerCrossing = 2e3;
   constructor(input) {
     super({
       greedyMultiplier: JUMPER_GRAPH_SOLVER_DEFAULTS.greedyMultiplier,
@@ -2398,7 +2512,11 @@ var JumperGraphSolver = class extends HyperGraphSolver {
     this.crossingPenalty = input.crossingPenalty ?? this.crossingPenalty;
     this.baseMaxIterations = input.baseMaxIterations ?? this.baseMaxIterations;
     this.additionalMaxIterationsPerConnection = input.additionalMaxIterationsPerConnection ?? this.additionalMaxIterationsPerConnection;
-    this.MAX_ITERATIONS = this.baseMaxIterations + input.inputConnections.length * this.additionalMaxIterationsPerConnection;
+    const crossings = countInputConnectionCrossings(
+      this.graph,
+      input.inputConnections
+    );
+    this.MAX_ITERATIONS = this.baseMaxIterations + input.inputConnections.length * this.additionalMaxIterationsPerConnection + crossings * this.additionalMaxIterationsPerCrossing;
     this.populateDistanceToEndMaps();
   }
   populateDistanceToEndMaps() {

package/package.json

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