add two sided generation, export calculate graph bounds

Author: seveibar

lib/JumperGraphSolver/jumper-graph-generator/createProblemFromBaseGraph.ts

@@ -62,15 +62,75 @@ const isValidPoint = (
   return true
 }
 
+type Side = "top" | "right" | "bottom" | "left"
+
+/**
+ * Generates a random point on a specific side of the bounds
+ */
+const getPointOnSide = (
+  bounds: { minX: number; maxX: number; minY: number; maxY: number },
+  side: Side,
+  t: number, // 0-1 position along the side
+): { x: number; y: number } => {
+  const width = bounds.maxX - bounds.minX
+  const height = bounds.maxY - bounds.minY
+
+  switch (side) {
+    case "top":
+      return { x: bounds.minX + t * width, y: bounds.maxY }
+    case "right":
+      return { x: bounds.maxX, y: bounds.maxY - t * height }
+    case "bottom":
+      return { x: bounds.maxX - t * width, y: bounds.minY }
+    case "left":
+      return { x: bounds.minX, y: bounds.minY + t * height }
+  }
+}
+
+/**
+ * Returns the length of a side
+ */
+const getSideLength = (
+  bounds: { minX: number; maxX: number; minY: number; maxY: number },
+  side: Side,
+): number => {
+  const width = bounds.maxX - bounds.minX
+  const height = bounds.maxY - bounds.minY
+  return side === "top" || side === "bottom" ? width : height
+}
+
 /**
  * Generates a random point on the perimeter of the given bounds
+ * If allowedSides is provided, only generates points on those sides
  */
 const getRandomPerimeterPoint = (
   bounds: { minX: number; maxX: number; minY: number; maxY: number },
   random: () => number,
+  allowedSides?: Side[],
 ): { x: number; y: number } => {
   const width = bounds.maxX - bounds.minX
   const height = bounds.maxY - bounds.minY
+
+  if (allowedSides && allowedSides.length > 0) {
+    // Calculate total length of allowed sides
+    const sideLengths = allowedSides.map((side) => getSideLength(bounds, side))
+    const totalLength = sideLengths.reduce((sum, len) => sum + len, 0)
+
+    // Pick a random position along the combined length
+    let pos = random() * totalLength
+
+    for (let i = 0; i < allowedSides.length; i++) {
+      if (pos < sideLengths[i]) {
+        const t = pos / sideLengths[i]
+        return getPointOnSide(bounds, allowedSides[i], t)
+      }
+      pos -= sideLengths[i]
+    }
+
+    // Fallback to last side (shouldn't happen due to floating point)
+    return getPointOnSide(bounds, allowedSides[allowedSides.length - 1], random())
+  }
+
   const perimeter = 2 * width + 2 * height
 
   // Pick a random position along the perimeter
@@ -92,6 +152,20 @@ const getRandomPerimeterPoint = (
   return { x: bounds.minX, y: bounds.minY + (pos - 2 * width - height) }
 }
 
+const ALL_SIDES: Side[] = ["top", "right", "bottom", "left"]
+
+/**
+ * Picks two random different sides
+ */
+const pickTwoRandomSides = (random: () => number): [Side, Side] => {
+  const firstIndex = Math.floor(random() * 4)
+  let secondIndex = Math.floor(random() * 3)
+  if (secondIndex >= firstIndex) {
+    secondIndex++
+  }
+  return [ALL_SIDES[firstIndex], ALL_SIDES[secondIndex]]
+}
+
 /**
  * Generates a connection ID from an index (0 -> "A", 1 -> "B", etc.)
  */
@@ -103,6 +177,7 @@ export type CreateProblemFromBaseGraphParams = {
   baseGraph: JumperGraph
   numCrossings: number
   randomSeed: number
+  twoSided?: boolean
 }
 
 /**
@@ -114,10 +189,14 @@ export const createProblemFromBaseGraph = ({
   baseGraph,
   numCrossings,
   randomSeed,
+  twoSided = false,
 }: CreateProblemFromBaseGraphParams): JumperGraphWithConnections => {
   const random = createSeededRandom(randomSeed)
   const graphBounds = calculateGraphBounds(baseGraph.regions)
 
+  // If twoSided, pick two random sides to use for all points in this problem
+  const allowedSides = twoSided ? pickTwoRandomSides(random) : undefined
+
   // Start with minimum connections needed for the desired crossings
   // For n connections, max crossings is n*(n-1)/2, so we need at least
   // ceil((1 + sqrt(1 + 8*numCrossings)) / 2) connections
@@ -136,7 +215,7 @@ export const createProblemFromBaseGraph = ({
       // Try to find a valid start point
       let start: { x: number; y: number } | null = null
       for (let tryCount = 0; tryCount < 100; tryCount++) {
-        const candidate = getRandomPerimeterPoint(graphBounds, random)
+        const candidate = getRandomPerimeterPoint(graphBounds, random, allowedSides)
         if (isValidPoint(candidate, allPoints)) {
           start = candidate
           break
@@ -151,7 +230,7 @@ export const createProblemFromBaseGraph = ({
       // Try to find a valid end point
       let end: { x: number; y: number } | null = null
       for (let tryCount = 0; tryCount < 100; tryCount++) {
-        const candidate = getRandomPerimeterPoint(graphBounds, random)
+        const candidate = getRandomPerimeterPoint(graphBounds, random, allowedSides)
         if (isValidPoint(candidate, allPoints)) {
           end = candidate
           break

lib/index.ts

@@ -6,3 +6,4 @@ export * from "./HyperGraphSolver"
 export * from "./JumperGraphSolver/geometry/applyTransformToGraph"
 export * from "./types"
 export * from "./JumperGraphSolver/jumper-types"
+export { calculateGraphBounds } from "./JumperGraphSolver/jumper-graph-generator/calculateGraphBounds"

scripts/run-benchmark-4x4-1206x4-both-orientations.ts

@@ -29,10 +29,11 @@ const createBaseGraph = (orientation: "vertical" | "horizontal" = "vertical") =>
     marginY: 1.2,
     outerPaddingX: 2,
     outerPaddingY: 2,
+    parallelTracesUnderJumperCount: 2,
     innerColChannelPointCount: 3,
     innerRowChannelPointCount: 3,
-    outerChannelXPointCount: 5,
-    outerChannelYPointCount: 5,
+    outerChannelXPointCount: 3,
+    outerChannelYPointCount: 3,
     regionsBetweenPads: true,
     orientation,
   })

scripts/run-benchmark-4x4-1206x4-two-sided.ts

@@ -0,0 +1,146 @@
+import { generateJumperX4Grid } from "../lib/JumperGraphSolver/jumper-graph-generator/generateJumperX4Grid"
+import { createProblemFromBaseGraph } from "../lib/JumperGraphSolver/jumper-graph-generator/createProblemFromBaseGraph"
+import { JumperGraphSolver } from "../lib/JumperGraphSolver/JumperGraphSolver"
+import { calculateGraphBounds } from "../lib/JumperGraphSolver/jumper-graph-generator/calculateGraphBounds"
+
+const SAMPLES_PER_CROSSING_COUNT = 100
+const MIN_CROSSINGS = 2
+const MAX_CROSSINGS = 20
+
+const median = (numbers: number[]): number | undefined => {
+  if (numbers.length === 0) return undefined
+  const sorted = numbers.slice().sort((a, b) => a - b)
+  const middle = Math.floor(sorted.length / 2)
+  return sorted[middle]
+}
+
+const percentile = (numbers: number[], p: number): number | undefined => {
+  if (numbers.length === 0) return undefined
+  const sorted = numbers.slice().sort((a, b) => a - b)
+  const index = Math.floor((p / 100) * (sorted.length - 1))
+  return sorted[index]
+}
+
+const createBaseGraph = (orientation: "vertical" | "horizontal" = "vertical") =>
+  generateJumperX4Grid({
+    cols: 4,
+    rows: 4,
+    marginX: 1.2,
+    marginY: 1.2,
+    outerPaddingX: 2,
+    outerPaddingY: 2,
+    parallelTracesUnderJumperCount: 2,
+    innerColChannelPointCount: 3,
+    innerRowChannelPointCount: 3,
+    outerChannelXPointCount: 3,
+    outerChannelYPointCount: 3,
+    regionsBetweenPads: true,
+    orientation,
+  })
+
+// Calculate and display graph sizes for both orientations
+const verticalGraph = createBaseGraph("vertical")
+const verticalBounds = calculateGraphBounds(verticalGraph.regions)
+const vWidth = verticalBounds.maxX - verticalBounds.minX
+const vHeight = verticalBounds.maxY - verticalBounds.minY
+console.log(
+  `Graph size (vertical): ${vWidth.toFixed(1)}x${vHeight.toFixed(1)}mm`,
+)
+
+const horizontalGraph = createBaseGraph("horizontal")
+const horizontalBounds = calculateGraphBounds(horizontalGraph.regions)
+const hWidth = horizontalBounds.maxX - horizontalBounds.minX
+const hHeight = horizontalBounds.maxY - horizontalBounds.minY
+console.log(
+  `Graph size (horizontal): ${hWidth.toFixed(1)}x${hHeight.toFixed(1)}mm`,
+)
+
+console.log("Benchmark: 4x4 1206x4 Jumper Grid Solver (Two-Sided Points, Both Orientations)")
+console.log("=".repeat(50))
+console.log(
+  `Testing ${MIN_CROSSINGS}-${MAX_CROSSINGS} connections with ${SAMPLES_PER_CROSSING_COUNT} samples each\n`,
+)
+
+const results: {
+  numConnections: number
+  successRate: number
+  successes: number
+}[] = []
+
+for (
+  let numCrossings = MIN_CROSSINGS;
+  numCrossings <= MAX_CROSSINGS;
+  numCrossings++
+) {
+  let successes = 0
+
+  const iterationsTaken: number[] = []
+  const solverDurations: number[] = []
+  for (
+    let sampleIndex = 0;
+    sampleIndex < SAMPLES_PER_CROSSING_COUNT;
+    sampleIndex++
+  ) {
+    const randomSeed = 1000 * numCrossings + sampleIndex
+    let cumulativeDuration = 0
+
+    for (const orientation of ["vertical", "horizontal"] as const) {
+      const graphWithConnections = createProblemFromBaseGraph({
+        baseGraph: createBaseGraph(orientation),
+        numCrossings: numCrossings,
+        randomSeed,
+        twoSided: true,
+      })
+
+      const solver = new JumperGraphSolver({
+        inputGraph: {
+          regions: graphWithConnections.regions,
+          ports: graphWithConnections.ports,
+        },
+        inputConnections: graphWithConnections.connections,
+      })
+
+      const startTime = performance.now()
+      solver.solve()
+      const duration = performance.now() - startTime
+      cumulativeDuration += duration
+
+      if (solver.solved) {
+        iterationsTaken.push(solver.iterations)
+        solverDurations.push(cumulativeDuration)
+        successes++
+        break
+      }
+    }
+  }
+
+  const successRate = (successes / SAMPLES_PER_CROSSING_COUNT) * 100
+  results.push({ numConnections: numCrossings, successRate, successes })
+
+  const med = median(iterationsTaken)
+  const p95 = percentile(iterationsTaken, 95)
+  const p99 = percentile(iterationsTaken, 99)
+  const medDuration = median(solverDurations)
+  console.log(
+    `Crossings: ${numCrossings.toString().padStart(2)} | ` +
+      `Success: ${successes.toString().padStart(3)}/${SAMPLES_PER_CROSSING_COUNT} | ` +
+      `Rate: ${successRate.toFixed(1).padStart(5)}%`,
+    `  Med iters: ${med?.toFixed(0) ?? "N/A"}`,
+    `  P95: ${p95?.toFixed(0) ?? "N/A"}, P99: ${p99?.toFixed(0) ?? "N/A"}`,
+    `  Med time: ${medDuration !== undefined ? medDuration.toFixed(1) + "ms" : "N/A"}`,
+  )
+}
+
+console.log("\n" + "=".repeat(50))
+console.log("Summary:")
+console.log("=".repeat(50))
+
+const avgSuccessRate =
+  results.reduce((sum, r) => sum + r.successRate, 0) / results.length
+console.log(`Average success rate: ${avgSuccessRate.toFixed(1)}%`)
+
+const perfectScores = results.filter((r) => r.successRate === 100).length
+console.log(`Crossing counts with 100% success: ${perfectScores}`)
+
+const zeroScores = results.filter((r) => r.successRate === 0).length
+console.log(`Crossing counts with 0% success: ${zeroScores}`)