@softsky/utils 2.3.2 → 2.4.0

package/README.md

@@ -61,11 +61,16 @@ ${\textsf{\color{CornflowerBlue}function}}$ combinations - Return all combinatio
 ${\textsf{\color{CornflowerBlue}function}}$ permutations - Return all permutations of items in array
 
 ---
-${\textsf{\color{CornflowerBlue}function}}$ pushToSorted - Push data in array so array is always kept sorted
+${\textsf{\color{CornflowerBlue}function}}$ pushToSorted - Push data to sorted array. Array will always be kept sorted.
 
-Compare must return true when found position to push in.
-For example if we return `[false, false, true, false]`,
-Array will become `[false, false, Element, true, false]`.
+Compare function should compare your needed value with value on index passed to it.
+If compare returns 0 it means we found target.
+If compare returns > 0 it means target is smaller.
+If compare returns < 0 it means target is bigger.
+
+```ts
+pushToSorted(numArray, 10,  x => x - 10);
+```
 
 ---
 ${\textsf{\color{CornflowerBlue}function}}$ removeFromArray - Delete value from array.
@@ -210,6 +215,31 @@ pipe(
 ---
 
 
+## Graphs
+Pos
+
+${\textsf{\color{CornflowerBlue}function}}$ unfoldPathfindingResult - Unfold pathfinding result to path array.
+
+---
+${\textsf{\color{CornflowerBlue}function}}$ aStar - Pathfind using aStar.
+Returns a target and map of parents.
+You can use `unfoldPathfindingResult()` to get array of nodes.
+
+---
+${\textsf{\color{CornflowerBlue}function}}$ bfs - Breadth-first search. Slower than dfs.
+If isTarget is omitted becomes floodfill.
+Returns a target and map of parents.
+You can use `unfoldPathfindingResult()` to get array of nodes.
+
+---
+${\textsf{\color{CornflowerBlue}function}}$ dfs - Depth-first search. Faster than bfs.
+If isTarget is omitted becomes floodfill.
+Returns a target and map of parents.
+You can use `unfoldPathfindingResult()` to get array of nodes.
+
+---
+
+
 ## Numbers
 Numbers, math, etc.
 

package/dist/arrays.d.ts

@@ -14,7 +14,7 @@ export declare function swap<T>(array: T[], index: number, index2: number): T[];
  * If compare returns > 0 it means we have to cut out bigger side of array.
  * If compare returns < 0 it means we have to cut out smaller side of array.
  */
-export declare function binarySearch(size: number, compare: (index: number) => number): number;
+export declare function binarySearch(size: number, compare: (index: number) => number, returnClosest?: boolean): number;
 /** Split array into sub arrays of spicified size */
 export declare function chunk<T>(array: T[], chunkSize: number): T[][];
 /** Return all combinations of items in array */
@@ -22,13 +22,18 @@ export declare function combinations<T>(array: T[]): T[][];
 /** Return all permutations of items in array */
 export declare function permutations<T>(array: T[]): T[][];
 /**
- * Push data in array so array is always kept sorted
+ * Push data to sorted array. Array will always be kept sorted.
  *
- * Compare must return true when found position to push in.
- * For example if we return `[false, false, true, false]`,
- * Array will become `[false, false, Element, true, false]`.
+ * Compare function should compare your needed value with value on index passed to it.
+ * If compare returns 0 it means we found target.
+ * If compare returns > 0 it means target is smaller.
+ * If compare returns < 0 it means target is bigger.
+ *
+ * ```ts
+ * pushToSorted(numArray, 10,  x => x - 10);
+ * ```
  */
-export declare function pushToSorted<T>(array: T[], element: T, compare: (element: T) => boolean): void;
+export declare function pushToSorted<T>(array: T[], element: T, compare: (x: T) => number): void;
 /**
  * Delete value from array.
  * Only deletes first encountered.

package/dist/arrays.js

@@ -32,23 +32,23 @@ export function swap(array, index, index2) {
  * If compare returns > 0 it means we have to cut out bigger side of array.
  * If compare returns < 0 it means we have to cut out smaller side of array.
  */
-export function binarySearch(size, compare) {
+export function binarySearch(size, compare, returnClosest) {
+    if (size === 0)
+        return returnClosest ? 0 : -1;
     let low = 0;
-    let high = size - 1;
-    let position = -1;
-    while (low <= high) {
-        const mid = Math.trunc((low + high) / 2);
+    let high = size;
+    let mid = -1;
+    while (high > low) {
+        mid = ((low + high) / 2) | 0;
         const compared = compare(mid);
-        if (compared === 0) {
-            position = mid;
-            break;
-        }
+        if (compared === 0)
+            return mid;
         else if (compared > 0)
-            high = mid - 1;
+            high = mid;
         else
             low = mid + 1;
     }
-    return position;
+    return returnClosest ? mid : -1;
 }
 /** Split array into sub arrays of spicified size */
 export function chunk(array, chunkSize) {
@@ -94,15 +94,20 @@ export function permutations(array) {
     return result;
 }
 /**
- * Push data in array so array is always kept sorted
+ * Push data to sorted array. Array will always be kept sorted.
+ *
+ * Compare function should compare your needed value with value on index passed to it.
+ * If compare returns 0 it means we found target.
+ * If compare returns > 0 it means target is smaller.
+ * If compare returns < 0 it means target is bigger.
  *
- * Compare must return true when found position to push in.
- * For example if we return `[false, false, true, false]`,
- * Array will become `[false, false, Element, true, false]`.
+ * ```ts
+ * pushToSorted(numArray, 10,  x => x - 10);
+ * ```
  */
 export function pushToSorted(array, element, compare) {
-    const index = array.findIndex(compare);
-    array.splice(index === -1 ? array.length : index, 0, element);
+    const index = binarySearch(array.length, (x) => compare(array[x]), true);
+    array.splice(index, 0, element);
 }
 /**
  * Delete value from array.

package/dist/graphs.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Unfold pathfinding result to path array.
+ */
+export declare function unfoldPathfindingResult<T>({ target, parents, }: {
+    parents: Map<T, T>;
+    target?: T;
+}): T[];
+/**
+ * Pathfind using aStar.
+ * Returns a target and map of parents.
+ * You can use `unfoldPathfindingResult()` to get array of nodes.
+ */
+export declare function aStar<T>(options: {
+    /** Start node */
+    start: T;
+    /** Get weight of node */
+    getWeight: (node: T) => number;
+    /** Presumed cost of going to the target from node */
+    heuristic: (node: T) => number;
+    /** Get neighbors of node */
+    getNeighbors: (node: T) => T[];
+    /** Check if node is a target */
+    isTarget: (node: T) => boolean;
+}): {
+    parents: Map<T, T>;
+    target?: T;
+};
+/**
+ * Breadth-first search. Slower than dfs.
+ * If isTarget is omitted becomes floodfill.
+ * Returns a target and map of parents.
+ * You can use `unfoldPathfindingResult()` to get array of nodes.
+ */
+export declare function bfs<T>(options: {
+    /** Start node */
+    start: T;
+    /** Get neighbors of node */
+    getNeighbors: (parent: T) => T[];
+    /** Check if node is a target */
+    isTarget?: (child: T, parent: T) => boolean;
+}): {
+    parents: Map<T, T>;
+    target?: T;
+};
+/**
+ * Depth-first search. Faster than bfs.
+ * If isTarget is omitted becomes floodfill.
+ * Returns a target and map of parents.
+ * You can use `unfoldPathfindingResult()` to get array of nodes.
+ */
+export declare function dfs<T>(options: {
+    /** Start node */
+    start: T;
+    /** Get neighbors of node */
+    getNeighbors: (parent: T) => T[];
+    /** Check if node is a target */
+    isTarget?: (child: T, parent: T) => boolean;
+}): {
+    parents: Map<T, T>;
+    target?: T;
+};

package/dist/graphs.js

@@ -0,0 +1,111 @@
+import { pushToSorted } from './arrays';
+/**
+ * Unfold pathfinding result to path array.
+ */
+export function unfoldPathfindingResult({ target, parents, }) {
+    let node = target;
+    const path = [];
+    while (node) {
+        path.push(node);
+        node = parents.get(node);
+    }
+    return path.reverse();
+}
+/**
+ * Pathfind using aStar.
+ * Returns a target and map of parents.
+ * You can use `unfoldPathfindingResult()` to get array of nodes.
+ */
+export function aStar(options) {
+    const parents = new Map();
+    const queue = [
+        {
+            d: options.start,
+            g: 0,
+            h: options.heuristic(options.start),
+        },
+    ];
+    while (queue.length > 0) {
+        const node = queue.pop();
+        if (options.isTarget(node.d))
+            return {
+                parents,
+                target: node.d,
+            };
+        const neighbors = options.getNeighbors(node.d);
+        for (let index = 0; index < neighbors.length; index++) {
+            const neighbor = neighbors[index];
+            if (options.start === neighbor || parents.has(neighbor))
+                continue;
+            parents.set(neighbor, node.d);
+            const neighborNode = {
+                d: neighbor,
+                g: node.g + options.getWeight(neighbor),
+                h: options.heuristic(neighbor),
+            };
+            neighborNode.h += node.g;
+            pushToSorted(queue, neighborNode, (x) => neighborNode.h - x.h);
+        }
+    }
+    return {
+        parents,
+    };
+}
+/**
+ * Breadth-first search. Slower than dfs.
+ * If isTarget is omitted becomes floodfill.
+ * Returns a target and map of parents.
+ * You can use `unfoldPathfindingResult()` to get array of nodes.
+ */
+export function bfs(options) {
+    const queue = [options.start];
+    const parents = new Map();
+    for (let index = 0; index < queue.length; index++) {
+        const parent = queue[index];
+        const neighbors = options.getNeighbors(parent);
+        for (let index = 0; index < neighbors.length; index++) {
+            const neighbor = neighbors[index];
+            if (neighbor === options.start || parents.has(neighbor))
+                continue;
+            parents.set(neighbor, parent);
+            if (options.isTarget?.(neighbor, parent))
+                return {
+                    target: neighbor,
+                    parents,
+                };
+            queue.push(neighbor);
+        }
+    }
+    return {
+        parents,
+    };
+}
+/**
+ * Depth-first search. Faster than bfs.
+ * If isTarget is omitted becomes floodfill.
+ * Returns a target and map of parents.
+ * You can use `unfoldPathfindingResult()` to get array of nodes.
+ */
+export function dfs(options) {
+    const queue = [options.start];
+    const parents = new Map();
+    while (queue.length > 0) {
+        const node = queue.pop();
+        const neighbors = options.getNeighbors(node);
+        for (let index = 0; index < neighbors.length; index++) {
+            const neighbor = neighbors[index];
+            if (neighbor === options.start || parents.has(neighbor))
+                continue;
+            parents.set(neighbor, node);
+            if (options.isTarget?.(neighbor, node))
+                return {
+                    target: neighbor,
+                    parents,
+                };
+            queue.push(neighbor);
+        }
+    }
+    return {
+        parents,
+    };
+}

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export * from './consts';
 export * from './control';
 export * from './errors';
 export * from './formatting';
+export * from './graphs';
 export * from './numbers';
 export * from './objects';
 export * from './signals';

package/dist/index.js

@@ -3,6 +3,7 @@ export * from './consts';
 export * from './control';
 export * from './errors';
 export * from './formatting';
+export * from './graphs';
 export * from './numbers';
 export * from './objects';
 export * from './signals';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softsky/utils",
-  "version": "2.3.2",
+  "version": "2.4.0",
   "description": "JavaScript/TypeScript utilities",
   "main": "dist/index.js",
   "scripts": {
@@ -20,8 +20,8 @@
   },
   "homepage": "https://github.com/SoundOfTheSky/utils#readme",
   "devDependencies": {
-    "@softsky/configs": "^1.3.0",
-    "@types/bun": "^1.2.8"
+    "@softsky/configs": "^1.3.3",
+    "@types/bun": "^1.2.11"
   },
   "files": ["dist/**/*"]
 }