@softsky/utils 2.6.0 → 2.7.0

package/README.md

@@ -291,6 +291,19 @@ 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__ `tspHeldKarp` - 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
+
 ---
 
 
@@ -505,14 +518,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/graphs.d.ts

@@ -59,3 +59,26 @@ 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 tspHeldKarp(distribution: number[][]): {
+    distance: number;
+    path: number[];
+};
+/**
+ * Look for description of `tspHeldKarp`.
+ * Returns path without cycle
+ */
+export declare function tspHeldKarpPath(d: number[][]): {
+    distance: number;
+    path: number[];
+};

package/dist/graphs.js

@@ -109,3 +109,109 @@ 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 tspHeldKarp(distribution) {
+    const n = distribution.length;
+    if (n === 1)
+        return { distance: 0, path: [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 {
+        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],
+    };
+}
+/**
+ * Look for description of `tspHeldKarp`.
+ * Returns path without cycle
+ */
+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) };
+}

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.0",
   "description": "JavaScript/TypeScript utilities",
   "main": "dist/index.js",
   "scripts": {