@softsky/utils 2.7.0 → 2.7.2

package/README.md

@@ -84,6 +84,9 @@ Only deletes last encountered.
 
 Returns index of deleted value.
 
+---
+__function__ `reverse` - Reverse part of array
+
 ---
 
 
@@ -201,6 +204,12 @@ semaphore.run(()=>{
 ---
 __async function__ `withTimeout` - Add timeout to a promise
 
+---
+__function__ `promisify` - Promisify a function with callback
+
+---
+__function__ `promisifyEventSource` - Create a promise out of EventSource
+
 ---
 
 
@@ -295,14 +304,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/control.d.ts

@@ -123,4 +123,8 @@ export declare class Semaphore {
 }
 /** Add timeout to a promise */
 export declare function withTimeout<T>(run: () => Promise<T>, ms: number): Promise<T>;
+/** Promisify a function with callback */
+export declare function promisify<A extends any[], R extends any[]>(handler: (...handlerArguments: [...A, (...results: R) => void]) => void): (...handlerArguments: A) => Promise<R extends [infer U] ? U : R>;
+/** Create a promise out of EventSource */
+export declare function promisifyEventSource<T = unknown>(target: EventSource, resolveEvents: string[], rejectEvents?: string[]): Promise<T>;
 export {};

package/dist/control.js

@@ -288,3 +288,21 @@ export class Semaphore {
 export async function withTimeout(run, ms) {
     return Promise.race([run(), timeout(ms)]);
 }
+/** Promisify a function with callback */
+export function promisify(handler) {
+    return (...handlerArguments) => new Promise((resolve) => {
+        handler(...handlerArguments, (...results) => {
+            resolve(results.length > 1 ? results : results[0]);
+        });
+    });
+}
+/** Create a promise out of EventSource */
+export function promisifyEventSource(target, resolveEvents, rejectEvents = ['error']) {
+    return new Promise((resolve, reject) => {
+        for (let index = 0; index < resolveEvents.length; index++)
+            // @ts-ignore
+            target.addEventListener(resolveEvents[index], resolve);
+        for (let index = 0; index < rejectEvents.length; index++)
+            target.addEventListener(rejectEvents[index], reject);
+    });
+}

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.2",
   "description": "JavaScript/TypeScript utilities",
   "main": "dist/index.js",
   "scripts": {
@@ -21,7 +21,7 @@
   "homepage": "https://github.com/SoundOfTheSky/utils#readme",
   "devDependencies": {
     "@softsky/configs": "^1.3.4",
-    "@types/bun": "^1.2.19"
+    "@types/bun": "^1.2.21"
   },
   "files": ["dist/**/*"]
 }