@eturnity/eturnity_maths 7.48.2 → 7.51.1

package/src/stringPatchMatching.js

@@ -0,0 +1,140 @@
+export function solveStringPatchMatching(stringList, patchList) {
+  // Problem Setup
+  const n = patchList.length // Number of rows
+  const m = stringList.length // Number of columns
+  const R = patchList.slice() // Row sum constraints
+  const C = stringList.slice() // Column sum constraints
+
+  // Initialize matrix with zeros
+  const matrix = Array.from({ length: n }, () => Array(m).fill(0))
+
+  // Function to find combinations of columns to satisfy a row sum
+  //each row represent a patch, each column represent a string
+  //we try to find matches to complete one patch with one or multiple strings
+  function findCombinationMatchesForRow(rowSum, colSums) {
+    const matches = []
+    const colsData = colSums.map((colSum, index) => {
+      return { value: colSum, index }
+    })
+    function findCombinations(
+      currentColsData,
+      currentSum,
+      target,
+      availableColsData
+    ) {
+      const stack = [
+        {
+          currentColsData,
+          currentSum,
+          availableColsData,
+          index: 0,
+        },
+      ]
+
+      let iterations = 0
+      while (stack.length > 0 && iterations < 1000 && matches.length < 5) {
+        iterations++
+        const current = stack[stack.length - 1]
+
+        if (current.currentSum === target) {
+          matches.push(current.currentColsData.map((col) => col.index))
+          stack.pop()
+          continue
+        }
+
+        if (current.availableColsData.length === 0) {
+          stack.pop()
+          continue
+        }
+
+        // Filter once per stack frame
+        if (!current.filtered) {
+          current.availableColsData = current.availableColsData.filter(
+            (colData) => colData.value <= target - current.currentSum
+          )
+          current.filtered = true
+        }
+
+        if (current.index >= current.availableColsData.length) {
+          stack.pop()
+          continue
+        }
+
+        const selectedCol = current.availableColsData[current.index]
+        current.index++
+
+        const nextColsData = current.currentColsData.concat(selectedCol)
+        const nextSum = current.currentSum + selectedCol.value
+        const nextAvailableColsData = current.availableColsData.filter(
+          (colData) => colData.index > selectedCol.index
+        )
+
+        stack.push({
+          currentColsData: nextColsData,
+          currentSum: nextSum,
+          availableColsData: nextAvailableColsData,
+          index: 0,
+        })
+      }
+    }
+    findCombinations([], 0, rowSum, colsData)
+    return matches
+  }
+
+  // Function to assign values to matrix for matched rows and columns
+  function assignCombinationPerRowMatches(matches, rowSums, colSums) {
+    matches.forEach(({ row, cols }) => {
+      if (rowSums[row] && cols.every((col) => colSums[col])) {
+        cols.forEach((col) => {
+          matrix[row][col] = colSums[col]
+          colSums[col] = null // Mark column as completed
+        })
+        rowSums[row] = null // Mark row as completed
+      }
+    })
+  }
+  // Main greedy decomposition function
+  function greedyDecomposition(rowSums, colSums) {
+    // Step 1: Try to decompose rows (patch) using column (string) combinations
+    const matches = []
+    for (let i = 0; i < rowSums.length; i++) {
+      if (rowSums[i] !== null) {
+        const colCombinations = findCombinationMatchesForRow(
+          rowSums[i],
+          colSums
+        )
+        colCombinations.forEach((cols) => {
+          matches.push({
+            row: i,
+            cols,
+          })
+        })
+      }
+    }
+    //sort the matchs by biggest string first
+    matches.sort(
+      (a, b) =>
+        Math.max(...b.cols.map((col) => colSums[col])) -
+        Math.max(...a.cols.map((col) => colSums[col]))
+    )
+    //sort the matchs by patch in descending order
+    matches.sort((a, b) => rowSums[b.row] - rowSums[a.row])
+    assignCombinationPerRowMatches(matches, rowSums, colSums)
+  }
+
+  // Run the greedy decomposition algorithm
+  greedyDecomposition(R, C)
+
+  // Output the resulting matrix
+  return {
+    matrix,
+    R,
+    C,
+    rowsWithSolution: R.map((r, index) => (r == null ? index : null)).filter(
+      (r) => r !== null
+    ),
+    colsWithSolution: C.map((c, index) => (c == null ? index : null)).filter(
+      (c) => c !== null
+    ),
+  }
+}

package/src/tests/SHPSolver/SHPSolver.spec.js

@@ -0,0 +1,71 @@
+import {
+  shortestHamiltonianPathSolver,
+  vectorLength,
+  substractVector,
+} from '../../index'
+describe('ShortestHamiltonianPathSolver', () => {
+  let solver = shortestHamiltonianPathSolver
+  it('should return empty array for empty input', () => {
+    const result = solver.solve([])
+    expect(result.indexOrder).toEqual([])
+  })
+
+  it('should handle single node input', () => {
+    const nodes = [{ x: 1, y: 1, z: 1 }]
+    const result = solver.solve(nodes)
+    expect(result.sortedNodes).toEqual(nodes)
+    expect(result.indexOrder).toEqual([0])
+  })
+
+  it('should find optimal path for two nodes', () => {
+    const nodes = [
+      { x: 0, y: 0, z: 0 },
+      { x: 1, y: 1, z: 1 },
+    ]
+    const result = solver.solve(nodes)
+    expect(result.sortedNodes).toEqual(nodes)
+    expect(result.indexOrder).toEqual([0, 1])
+  })
+
+  it('should find optimal path for square', () => {
+    const input = [
+      { x: 0, y: 0, z: 0 },
+      { x: 100, y: 100, z: 0 },
+      { x: 0, y: 100, z: 0 },
+      { x: 100, y: 0, z: 0 },
+    ]
+    solver.isVerbose = true
+    const expectedIndexOrder = []
+    const result = solver.solve(input)
+    expect(result.cost).toBe(300)
+  })
+
+  it('should find optimal path for line', () => {
+    const A = { x: 0, y: 0, z: 0 }
+    const B = { x: 0, y: 100, z: 0 }
+    const C = { x: 0, y: 200, z: 0 }
+    const D = { x: 0, y: 300, z: 0 }
+    const E = { x: 0, y: 400, z: 0 }
+
+    let result = solver.solve([A, B, C, D, E])
+    expect(result.cost).toBe(400)
+    result = solver.solve([E, B, C, D, A])
+    expect(result.cost).toBe(400)
+    result = solver.solve([B, C, A, E, D])
+    expect(result.cost).toBe(400)
+    result = solver.solve([E, D, C, B, A])
+    expect(result.cost).toBe(400)
+    result = solver.solve([D, E, C, A, B])
+    expect(result.cost).toBe(400)
+  })
+
+  it('should handle nodes with same coordinates', () => {
+    const nodes = [
+      { x: 1, y: 1, z: 1 },
+      { x: 1, y: 1, z: 1 },
+    ]
+    const result = solver.solve(nodes)
+    expect(result.sortedNodes.length).toBe(2)
+    expect(result.indexOrder.length).toBe(2)
+  })
+})

package/src/tests/SHPSolver/SHPSolverDebugCase.spec.js

@@ -0,0 +1,26 @@
+import { shortestHamiltonianPathSolver } from '../../index'
+import { scenario_4 } from './scenarios'
+
+describe('ShortestHamiltonianPathSolver', () => {
+  let solver = shortestHamiltonianPathSolver
+  it('should be return shortestHamiltonianPath from real scenario 3', () => {
+    // const input = scenario_4.inputData.panels.map((p) => p.center)
+    // const N = scenario_4.inputData.panels.length
+    // const initialCost = solver.computePathCost(
+    //   Array(N)
+    //     .fill()
+    //     .map((_, i) => i),
+    //   input,
+    //   false
+    // )
+    // const result = solver.solve(input, {
+    //   hasVirtualNode: true,
+    //   proximityMatrix: null,
+    //   preventIntersection: true,
+    // })
+    // const sortedNodes = result.sortedNodes
+    // const areSelfIntersect = solver.isPathValid(result.indexOrder, input, false)
+    //console.log('result', initialCost, areSelfIntersect, result)
+    //expect(areSelfIntersect).toBe(false)
+  })
+})

package/src/tests/SHPSolver/scenarios/index.js

@@ -0,0 +1,17 @@
+import scenario_1 from './scenario_1.json'
+import scenario_1b from './scenario_1b.json'
+import scenario_1_row from './scenario_1_row.json'
+import scenario_2_row from './scenario_2_row.json'
+import scenario_3 from './scenario_3.json'
+import scenario_4 from './scenario_4.json'
+import scenario_3_simplify from './scenario_3_simplify.json'
+
+export {
+  scenario_1,
+  scenario_1b,
+  scenario_1_row,
+  scenario_2_row,
+  scenario_3,
+  scenario_3_simplify,
+  scenario_4,
+}

package/src/tests/SHPSolver/scenarios/scenario_1.json

@@ -0,0 +1,58 @@
+{
+  "inputData": {
+    "panelsIndexes": [
+      [4, 13],
+      [5, 13],
+      [4, 12],
+      [5, 12],
+      [3, 12]
+    ],
+    "panels": [
+      {
+        "center": {
+          "x": 100,
+          "y": 100,
+          "z": 0
+        }
+      },
+      {
+        "center": {
+          "x": 100,
+          "y": 200,
+          "z": 0
+        }
+      },
+      {
+        "center": {
+          "x": 200,
+          "y": 100,
+          "z": 0
+        }
+      },
+      {
+        "center": {
+          "x": 200,
+          "y": 200,
+          "z": 0
+        }
+      },
+      {
+        "center": {
+          "x": 200,
+          "y": 0,
+          "z": 0
+        }
+      }
+    ]
+  },
+  "outputData": {
+    "panelsIndexes": [
+      [4, 13],
+      [5, 13],
+      [4, 12],
+      [5, 12],
+      [3, 12]
+    ],
+    "indexOrder": [0, 1, 2, 3, 4]
+  }
+}

package/src/tests/SHPSolver/scenarios/scenario_1_row.json

@@ -0,0 +1,159 @@
+{
+  "inputData": {
+    "panelsIndexes": [
+      [3, 13],
+      [4, 13],
+      [5, 13],
+      [4, 12],
+      [5, 12],
+      [3, 12],
+      [2, 12],
+      [1, 12],
+      [0, 12]
+    ],
+    "panels": [
+      {
+        "center": {
+          "x": -201592.9454132333,
+          "y": -145757.73980606598,
+          "z": 3992.2558982478513
+        }
+      },
+      {
+        "center": {
+          "x": -201387.29671194102,
+          "y": -144876.38822909922,
+          "z": 4442.865495832077
+        }
+      },
+      {
+        "center": {
+          "x": -201181.6480106488,
+          "y": -143995.03665213246,
+          "z": 4893.475093416302
+        }
+      },
+      {
+        "center": {
+          "x": -199760.98189167224,
+          "y": -145255.8616871619,
+          "z": 4442.865495832069
+        }
+      },
+      {
+        "center": {
+          "x": -199555.33319038,
+          "y": -144374.51011019514,
+          "z": 4893.475093416295
+        }
+      },
+      {
+        "center": {
+          "x": -199966.63059296447,
+          "y": -146137.21326412866,
+          "z": 3992.255898247844
+        }
+      },
+      {
+        "center": {
+          "x": -200172.2792942567,
+          "y": -147018.56484109542,
+          "z": 3541.6463006636186
+        }
+      },
+      {
+        "center": {
+          "x": -200377.927995549,
+          "y": -147899.91641806217,
+          "z": 3091.036703079393
+        }
+      },
+      {
+        "center": {
+          "x": -200583.57669684122,
+          "y": -148781.26799502896,
+          "z": 2640.4271054951605
+        }
+      }
+    ]
+  },
+  "outputData": {
+    "panelsIndexes": [
+      [3, 13],
+      [4, 13],
+      [5, 13],
+      [4, 12],
+      [5, 12],
+      [3, 12],
+      [2, 12],
+      [1, 12],
+      [0, 12]
+    ],
+    "panels": [
+      {
+        "center": {
+          "x": -201592.9454132333,
+          "y": -145757.73980606598,
+          "z": 3992.2558982478513
+        }
+      },
+      {
+        "center": {
+          "x": -201387.29671194102,
+          "y": -144876.38822909922,
+          "z": 4442.865495832077
+        }
+      },
+      {
+        "center": {
+          "x": -201181.6480106488,
+          "y": -143995.03665213246,
+          "z": 4893.475093416302
+        }
+      },
+      {
+        "center": {
+          "x": -199760.98189167224,
+          "y": -145255.8616871619,
+          "z": 4442.865495832069
+        }
+      },
+      {
+        "center": {
+          "x": -199555.33319038,
+          "y": -144374.51011019514,
+          "z": 4893.475093416295
+        }
+      },
+      {
+        "center": {
+          "x": -199966.63059296447,
+          "y": -146137.21326412866,
+          "z": 3992.255898247844
+        }
+      },
+      {
+        "center": {
+          "x": -200172.2792942567,
+          "y": -147018.56484109542,
+          "z": 3541.6463006636186
+        }
+      },
+      {
+        "center": {
+          "x": -200377.927995549,
+          "y": -147899.91641806217,
+          "z": 3091.036703079393
+        }
+      },
+      {
+        "center": {
+          "x": -200583.57669684122,
+          "y": -148781.26799502896,
+          "z": 2640.4271054951605
+        }
+      }
+    ],
+    "indexOrder": [0, 1, 2, 3, 4, 5, 6, 7, 8]
+  }
+}

package/src/tests/SHPSolver/scenarios/scenario_1b.json

@@ -0,0 +1,35 @@
+{
+  "inputData": {
+    "panelsIndexes": [
+      [0, 4],
+      [1, 3],
+      [0, 3]
+    ],
+    "panels": [
+      {
+        "center": {
+          "x": 0,
+          "y": 0,
+          "z": 0
+        }
+      },
+      {
+        "center": {
+          "x": 200,
+          "y": 100,
+          "z": 0
+        }
+      },
+      {
+        "center": {
+          "x": 200,
+          "y": 0,
+          "z": 0
+        }
+      }
+    ]
+  },
+  "outputData": {
+    "indexOrder": [0, 2, 1]
+  }
+}

package/src/tests/SHPSolver/scenarios/scenario_1b_row.json

@@ -0,0 +1,51 @@
+{
+  "inputData": {
+    "panelsIndexes": [
+      [1, 4],
+      [0, 4],
+      [1, 3],
+      [0, 3],
+      [2, 3]
+    ],
+    "panels": [
+      {
+        "center": {
+          "x": 5815.287972158337,
+          "y": -3592.857582161817,
+          "z": 3000
+        }
+      },
+      {
+        "center": {
+          "x": 5835.303850225924,
+          "y": -4603.659424574653,
+          "z": 3000
+        }
+      },
+      {
+        "center": {
+          "x": 7484.9606495366115,
+          "y": -3559.794756867186,
+          "z": 3000
+        }
+      },
+      {
+        "center": {
+          "x": 7504.9765276042,
+          "y": -4570.596599280022,
+          "z": 3000
+        }
+      },
+      {
+        "center": {
+          "x": 7464.944771469023,
+          "y": -2548.9929144543503,
+          "z": 3000
+        }
+      }
+    ]
+  },
+  "outputData": {
+    "indexOrder": [0, 1, 3, 2, 4]
+  }
+}