@softsky/utils 2.6.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
+
 ---
 
 
@@ -291,6 +294,21 @@ If isTarget is omitted becomes floodfill.
 Returns a target and map of parents.
 You can use `unfoldPathfindingResult()` to get array of nodes.
 
+---
+__function__ `knapsack` - Knapsack find best way to get maximum value in limited capacity
+
+---
+__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__ `traverseByNearestNeighbor` - Traverse all points by nearest neighbor. Should be able to go from any point to any other point.
+
+---
+__function__ `twoOpt` - 2-opt improvement
+
 ---
 
 
@@ -505,14 +523,20 @@ Returns clear function.
 For cron string syntax check __getNextCron()__ description
 
 ---
-__function__ `getNextCron` - Find next cron date after passed date.
+__function__ `getNextCron` - Find next cron date after passed date. This function __DOES NOT__ implement regular CRON 1 to 1.
 
-This function __DOES NOT__ implement regular CRON 1 to 1.
+1. [0-999] Milliseconds
+2. [0-59] Seconds
+3. [0-59] Minutes
+4. [0-23] Hours
+5. [1-31] Dates
+6. [1-12] Months
+7. [0-6] Weekdays
 
 Main differences:
 - Weekdays value only 0 to 6 (0 is Sunday)
 - New supported syntax: __30-60/10__ - means __30,40,50,60__
-- Second and millisecond support: __* * * * * 30 999__ - executes every 30 seconds at the end of a second
+- Second and millisecond support: __0,500 300__ - every 30 seconds, two times
 
 ---
 __class__ `SpeedCalculator` - Object that calculates speed, ETA and percent of any measurable task.

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

@@ -59,3 +59,21 @@ export declare function dfs<T>(options: {
     parents: Map<T, T>;
     target?: T;
 };
+/** Knapsack find best way to get maximum value in limited capacity */
+export declare function knapsack(weights: number[], values: number[], capacity: number): {
+    weight: number;
+    items: number[];
+};
+/**
+ * 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
+ */
+export declare function hamiltonianCycle(distribution: number[][]): number[];
+/**
+ * Traverse all points by nearest neighbor. Should be able to go from any point to any other point.
+ */
+export declare function traverseByNearestNeighbor(distribution: number[][]): number[];
+/** 2-opt improvement */
+export declare function twoOpt(tour: number[], distribution: number[][]): number[];

package/dist/graphs.js

@@ -109,3 +109,149 @@ export function dfs(options) {
         parents,
     };
 }
+/** Knapsack find best way to get maximum value in limited capacity */
+export function knapsack(weights, values, capacity) {
+    const n = weights.length;
+    const dp = Array.from({ length: n + 1 }, () => new Array(capacity + 1).fill(0));
+    for (let index = 1; index <= n; index++) {
+        const w = weights[index - 1];
+        const v = values[index - 1];
+        const dpc = dp[index];
+        const dpl = dp[index - 1];
+        for (let c = 0; c <= capacity; c++)
+            dpc[c] = w > c ? dpl[c] : Math.max(dpl[c], dpl[c - w] + v);
+    }
+    const items = [];
+    let c = capacity;
+    for (let index = n; index > 0 && c > 0; index--) {
+        if (dp[index][c] !== dp[index - 1][c]) {
+            items.push(index - 1);
+            c -= weights[index - 1];
+        }
+    }
+    return { weight: dp[n][capacity], items: items.reverse() };
+}
+/**
+ * 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
+ */
+export function hamiltonianCycle(distribution) {
+    const n = distribution.length;
+    if (n === 1)
+        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));
+    let S = 0;
+    do {
+        S++;
+        let v = n - 1;
+        do {
+            v--;
+            const S2 = S ^ (1 << v);
+            if (S2 < S) {
+                let bestL = 0;
+                let bestU = 0;
+                if (S2) {
+                    bestL = Infinity;
+                    let u = n - 1;
+                    do {
+                        u--;
+                        if (S2 & (1 << u)) {
+                            const l = length[(n - 1) * S2 + u] + distribution[u][v];
+                            if (l <= bestL) {
+                                bestL = l;
+                                bestU = u;
+                            }
+                        }
+                    } while (u);
+                }
+                else {
+                    bestL = distribution[n - 1][v];
+                    bestU = n - 1;
+                }
+                length[(n - 1) * S + v] = bestL;
+                previous[(n - 1) * S + v] = bestU;
+            }
+        } while (v);
+    } while (S < all);
+    let bestL = Infinity;
+    let bestU = -1;
+    let u = n - 1;
+    do {
+        u--;
+        const l = length[(n - 1) * all + u] + distribution[u][n - 1];
+        if (l <= bestL) {
+            bestL = l;
+            bestU = u;
+        }
+    } while (u);
+    const cycle = [n - 1];
+    u = bestU;
+    S = all;
+    while (u !== n - 1) {
+        cycle.unshift(u);
+        const S2 = S ^ (1 << u);
+        u = previous[(n - 1) * S + u];
+        S = S2;
+    }
+    const index = cycle.indexOf(0);
+    return [...cycle.slice(index), ...cycle.slice(0, index), 0];
+}
+/**
+ * Traverse all points by nearest neighbor. Should be able to go from any point to any other point.
+ */
+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/dist/time.d.ts

@@ -22,14 +22,21 @@ export declare function setSafeInterval(handler: AnyFunction, delay: number): ()
  *  Returns clear function.
  *  For cron string syntax check __getNextCron()__ description */
 export declare function cronInterval(run: () => unknown, cronString: string): () => void;
-/** Find next cron date after passed date.
+/** Find next cron date after passed date. This function __DOES NOT__ implement regular CRON 1 to 1.
  *
- *  This function __DOES NOT__ implement regular CRON 1 to 1.
+ *  1. [0-999] Milliseconds
+ *  2. [0-59] Seconds
+ *  3. [0-59] Minutes
+ *  4. [0-23] Hours
+ *  5. [1-31] Dates
+ *  6. [1-12] Months
+ *  7. [0-6] Weekdays
  *
  *  Main differences:
  *  - Weekdays value only 0 to 6 (0 is Sunday)
  *  - New supported syntax: __30-60/10__ - means __30,40,50,60__
- *  - Second and millisecond support: __* * * * * 30 999__ - executes every 30 seconds at the end of a second */
+ *  - Second and millisecond support: __0,500 300__ - every 30 seconds, two times
+ * */
 export declare function getNextCron(cronString: string, datetime?: Date): Date;
 /**
  * Object that calculates speed, ETA and percent of any measurable task.

package/dist/time.js

@@ -79,14 +79,21 @@ export function cronInterval(run, cronString) {
         clearTimeout(timeout);
     };
 }
-/** Find next cron date after passed date.
+/** Find next cron date after passed date. This function __DOES NOT__ implement regular CRON 1 to 1.
  *
- *  This function __DOES NOT__ implement regular CRON 1 to 1.
+ *  1. [0-999] Milliseconds
+ *  2. [0-59] Seconds
+ *  3. [0-59] Minutes
+ *  4. [0-23] Hours
+ *  5. [1-31] Dates
+ *  6. [1-12] Months
+ *  7. [0-6] Weekdays
  *
  *  Main differences:
  *  - Weekdays value only 0 to 6 (0 is Sunday)
  *  - New supported syntax: __30-60/10__ - means __30,40,50,60__
- *  - Second and millisecond support: __* * * * * 30 999__ - executes every 30 seconds at the end of a second */
+ *  - Second and millisecond support: __0,500 300__ - every 30 seconds, two times
+ * */
 export function getNextCron(cronString, datetime = new Date()) {
     const cron = cronString.split(' ');
     for (let index = cron.length; index < 7; index++)
@@ -244,6 +251,7 @@ export class SpeedCalculator {
                     : {
                         speed,
                         percent: this.sum / this.size,
+                        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-conversion
                         eta: ~~((this.size - this.sum) / speed) * 1000,
                     };
         }

package/package.json

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