@tscircuit/schematic-trace-solver 0.0.17 → 0.0.18

package/dist/index.js

@@ -6682,7 +6682,18 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
       guidelines: this.guidelines
     });
     this.movableSegments = movableSegments;
-    this.queuedCandidatePaths = [this.baseElbow, ...elbowVariants];
+    const getPathLength = (pts) => {
+      let len = 0;
+      for (let i = 0; i < pts.length - 1; i++) {
+        const dx = pts[i + 1].x - pts[i].x;
+        const dy = pts[i + 1].y - pts[i].y;
+        len += Math.sqrt(dx * dx + dy * dy);
+      }
+      return len;
+    };
+    this.queuedCandidatePaths = [this.baseElbow, ...elbowVariants].sort(
+      (a, b) => getPathLength(a) - getPathLength(b)
+    );
   }
   getConstructorParams() {
     return {

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/SchematicTraceSingleLineSolver.ts

@@ -81,7 +81,19 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
 
     this.movableSegments = movableSegments
 
-    this.queuedCandidatePaths = [this.baseElbow, ...elbowVariants]
+    const getPathLength = (pts: Point[]) => {
+      let len = 0
+      for (let i = 0; i < pts.length - 1; i++) {
+        const dx = pts[i + 1].x - pts[i].x
+        const dy = pts[i + 1].y - pts[i].y
+        len += Math.sqrt(dx * dx + dy * dy)
+      }
+      return len
+    }
+
+    this.queuedCandidatePaths = [this.baseElbow, ...elbowVariants].sort(
+      (a, b) => getPathLength(a) - getPathLength(b),
+    )
   }
 
   override getConstructorParams(): ConstructorParameters<

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.17",
+  "version": "0.0.18",
   "type": "module",
   "scripts": {
     "start": "cosmos",

package/tests/solvers/SchematicTraceSingleLineSolver/SchematicTraceSingleLineSolver_shortest.test.ts

@@ -0,0 +1,71 @@
+import { test, expect } from "bun:test"
+import { SchematicTraceSingleLineSolver } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/SchematicTraceSingleLineSolver"
+import { calculateElbow } from "calculate-elbow"
+import { generateElbowVariants } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/generateElbowVariants"
+import type { InputChip, InputProblem } from "lib/types/InputProblem"
+import type { Guideline } from "lib/solvers/GuidelinesSolver/GuidelinesSolver"
+
+const pathLength = (pts: { x: number; y: number }[]) => {
+  let len = 0
+  for (let i = 0; i < pts.length - 1; i++) {
+    const dx = pts[i + 1].x - pts[i].x
+    const dy = pts[i + 1].y - pts[i].y
+    len += Math.sqrt(dx * dx + dy * dy)
+  }
+  return len
+}
+
+test("SchematicTraceSingleLineSolver chooses shortest candidate path", () => {
+  const chipA: InputChip = {
+    chipId: "A",
+    center: { x: 0, y: 0 },
+    width: 0.2,
+    height: 0.2,
+    pins: [{ pinId: "A1", x: 0, y: 0 }],
+  }
+  const chipB: InputChip = {
+    chipId: "B",
+    center: { x: 4, y: 2 },
+    width: 0.2,
+    height: 0.2,
+    pins: [{ pinId: "B1", x: 4, y: 2 }],
+  }
+
+  const pins = [
+    { pinId: "A1", x: 0, y: 0, _facingDirection: "x+" as const, chipId: "A" },
+    { pinId: "B1", x: 4, y: 2, _facingDirection: "x+" as const, chipId: "B" },
+  ]
+
+  const guidelines: Guideline[] = [
+    { orientation: "vertical", x: 4, y: undefined },
+    { orientation: "vertical", x: 6, y: undefined },
+  ]
+
+  const inputProblem: InputProblem = {
+    chips: [chipA, chipB],
+    directConnections: [],
+    netConnections: [],
+    availableNetLabelOrientations: {},
+  }
+
+  const solver = new SchematicTraceSingleLineSolver({
+    pins: pins as any,
+    guidelines,
+    inputProblem,
+    chipMap: { A: chipA, B: chipB },
+  })
+
+  solver.solve()
+  expect(solver.solved).toBe(true)
+
+  const baseElbow = calculateElbow(
+    { x: pins[0].x, y: pins[0].y, facingDirection: pins[0]._facingDirection },
+    { x: pins[1].x, y: pins[1].y, facingDirection: pins[1]._facingDirection },
+    { overshoot: 0.2 },
+  )
+  const { elbowVariants } = generateElbowVariants({ baseElbow, guidelines })
+  const candidates = [baseElbow, ...elbowVariants]
+  const shortestLength = Math.min(...candidates.map(pathLength))
+
+  expect(pathLength(solver.solvedTracePath!)).toBe(shortestLength)
+})