@softsky/utils 2.7.0 → 2.7.1

package/README.md

@@ -84,6 +84,9 @@ Only deletes last encountered.
 
 Returns index of deleted value.
 
+---
+__function__ `reverse` - Reverse part of array
+
 ---
 
 
@@ -295,14 +298,16 @@ You can use `unfoldPathfindingResult()` to get array of nodes.
 __function__ `knapsack` - Knapsack find best way to get maximum value in limited capacity
 
 ---
-__function__ `tspHeldKarp` - Find min path between points. You need to supply 2-dim array
+__function__ `hamiltonianCycle` - Find min path between points. You need to supply 2-dim array
 where first index is a point and second index is a distance from this point to another.
 Put infinity if where are no path. Returns cycle (start and end at the same point)
 Original: https://github.com/qntm/held-karp
 
 ---
-__function__ `tspHeldKarpPath` - Look for description of `tspHeldKarp`.
-Returns path without cycle
+__function__ `traverseByNearestNeighbor` - Traverse all points by nearest neighbor. Should be able to go from any point to any other point.
+
+---
+__function__ `twoOpt` - 2-opt improvement
 
 ---
 

package/dist/arrays.d.ts

@@ -48,3 +48,5 @@ export declare function removeFromArray<T>(array: T[], value: T): number;
  * Returns index of deleted value.
  */
 export declare function removeLastFromArray<T>(array: T[], value: T): number;
+/** Reverse part of array */
+export declare function reverse<T>(array: T[], start: number, end: number): T[];

package/dist/arrays.js

@@ -133,3 +133,14 @@ export function removeLastFromArray(array, value) {
         array.splice(index, 1);
     return index;
 }
+/** Reverse part of array */
+export function reverse(array, start, end) {
+    array = [...array];
+    const n = ((end - start + 1) / 2) | 0;
+    for (let index = 0; index < n; index++) {
+        const temporary = array[start + index];
+        array[start + index] = array[end - index];
+        array[end - index] = temporary;
+    }
+    return array;
+}

package/dist/graphs.d.ts

@@ -70,15 +70,10 @@ export declare function knapsack(weights: number[], values: number[], capacity:
  * Put infinity if where are no path. Returns cycle (start and end at the same point)
  * Original: https://github.com/qntm/held-karp
  */
-export declare function tspHeldKarp(distribution: number[][]): {
-    distance: number;
-    path: number[];
-};
+export declare function hamiltonianCycle(distribution: number[][]): number[];
 /**
- * Look for description of `tspHeldKarp`.
- * Returns path without cycle
+ * Traverse all points by nearest neighbor. Should be able to go from any point to any other point.
  */
-export declare function tspHeldKarpPath(d: number[][]): {
-    distance: number;
-    path: number[];
-};
+export declare function traverseByNearestNeighbor(distribution: number[][]): number[];
+/** 2-opt improvement */
+export declare function twoOpt(tour: number[], distribution: number[][]): number[];

package/dist/graphs.js

@@ -137,10 +137,10 @@ export function knapsack(weights, values, capacity) {
  * Put infinity if where are no path. Returns cycle (start and end at the same point)
  * Original: https://github.com/qntm/held-karp
  */
-export function tspHeldKarp(distribution) {
+export function hamiltonianCycle(distribution) {
     const n = distribution.length;
     if (n === 1)
-        return { distance: 0, path: [0, 0] };
+        return [0, 0];
     const all = (1 << (n - 1)) - 1;
     const length = new Float64Array((1 << (n - 1)) * (n - 1));
     const previous = new Uint8Array((1 << (n - 1)) * (n - 1));
@@ -198,20 +198,60 @@ export function tspHeldKarp(distribution) {
         S = S2;
     }
     const index = cycle.indexOf(0);
-    return {
-        distance: cycle.reduce((accumulator, u, index_, cycle) => accumulator +
-            distribution[u][cycle[index_ + 1 in cycle ? index_ + 1 : 0]], 0),
-        path: [...cycle.slice(index), ...cycle.slice(0, index), 0],
-    };
+    return [...cycle.slice(index), ...cycle.slice(0, index), 0];
 }
 /**
- * Look for description of `tspHeldKarp`.
- * Returns path without cycle
+ * Traverse all points by nearest neighbor. Should be able to go from any point to any other point.
  */
-export function tspHeldKarpPath(d) {
-    const { distance, path } = tspHeldKarp([
-        [0, ...new Array(d.length).fill(0)],
-        ...d.map((d2) => [0, ...d2]),
-    ]);
-    return { distance, path: path.slice(1, -1).map((u) => u - 1) };
+export function traverseByNearestNeighbor(distribution) {
+    const n = distribution.length;
+    const toVisit = new Array(n).fill(true);
+    const path = [0];
+    let last = 0;
+    toVisit[0] = false;
+    for (let index = 1; index < n; index++) {
+        let nearest = -1;
+        let nearestDistribution = Infinity;
+        for (let index = 0; index < n; index++) {
+            if (toVisit[index] && distribution[last][index] < nearestDistribution) {
+                nearest = index;
+                nearestDistribution = distribution[last][index];
+            }
+        }
+        path.push(nearest);
+        last = nearest;
+        toVisit[nearest] = false;
+    }
+    return path;
+}
+/** 2-opt improvement */
+export function twoOpt(tour, distribution) {
+    let improved = true;
+    const nStart = tour.length - 2;
+    const nEnd = tour.length - 1;
+    while (improved) {
+        improved = false;
+        for (let start = 1; start < nStart; start++) {
+            for (let end = start + 1; end < nEnd; end++) {
+                const t0 = distribution[tour[start - 1]];
+                const t1 = tour[start];
+                const tk1 = tour[end];
+                const tk2 = tour[end + 1];
+                if (t0[tk1] +
+                    distribution[t1][tk2] -
+                    t0[t1] -
+                    distribution[tk1][tk2] <
+                    -1e-9) {
+                    const n = ((end - start + 1) / 2) | 0;
+                    for (let index = 0; index < n; index++) {
+                        const temporary = tour[start + index];
+                        tour[start + index] = tour[end - index];
+                        tour[end - index] = temporary;
+                    }
+                    improved = true;
+                }
+            }
+        }
+    }
+    return tour;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softsky/utils",
-  "version": "2.7.0",
+  "version": "2.7.1",
   "description": "JavaScript/TypeScript utilities",
   "main": "dist/index.js",
   "scripts": {