@thi.ng/arrays 2.8.12 → 2.9.0

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2024-03-27T09:53:45Z
+- **Last updated**: 2024-03-28T10:57:28Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -9,6 +9,22 @@ See [Conventional Commits](https://conventionalcommits.org/) for commit guidelin
 **Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
 and/or version bumps of transitive dependencies.
 
+## [2.9.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/arrays@2.9.0) (2024-03-28)
+
+#### 🚀 Features
+
+- add findSequence() & tests ([5f4db56](https://github.com/thi-ng/umbrella/commit/5f4db56))
+
+#### ♻️ Refactoring
+
+- add support for typed arrays ([1383916](https://github.com/thi-ng/umbrella/commit/1383916))
+  - add function overrides to support typed arrays for:
+    - argSort()
+    - bisect(), bisectWith()
+    - floydRivest()
+- update findSequence() ([f9e3c29](https://github.com/thi-ng/umbrella/commit/f9e3c29))
+  - reverse inner scan direction
+
 ## [2.8.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/arrays@2.8.0) (2024-02-19)
 
 #### 🚀 Features

package/README.md

@@ -54,7 +54,7 @@ For Node.js REPL:
 const arrays = await import("@thi.ng/arrays");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 2.90 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 3.00 KB
 
 ## Dependencies
 
@@ -84,7 +84,7 @@ directory are using this package:
 [Generated API docs](https://docs.thi.ng/umbrella/arrays/)
 
 - [`arrayIterator()`](https://github.com/thi-ng/umbrella/tree/develop/packages/arrays/src/iterator.ts)
-- [`argMin()` / argMax()](https://github.com/thi-ng/umbrella/tree/develop/packages/arrays/src/argmin.ts)
+- [`argMin()` / `argMax()`](https://github.com/thi-ng/umbrella/tree/develop/packages/arrays/src/argmin.ts)
 - [`argSort()`](https://github.com/thi-ng/umbrella/tree/develop/packages/arrays/src/arg-sort.ts)
 - [`binarySearch()`](https://github.com/thi-ng/umbrella/tree/develop/packages/arrays/src/binary-search.ts)
 - [`bisect()`](https://github.com/thi-ng/umbrella/tree/develop/packages/arrays/src/bisect.ts)
@@ -94,6 +94,7 @@ directory are using this package:
 - [`ensureIterable()`](https://github.com/thi-ng/umbrella/tree/develop/packages/arrays/src/ensure-iterable.ts)
 - [`fillRange()`](https://github.com/thi-ng/umbrella/tree/develop/packages/arrays/src/fill-range.ts)
 - [`find()`](https://github.com/thi-ng/umbrella/tree/develop/packages/arrays/src/find.ts)
+- [`findSequence()`](https://github.com/thi-ng/umbrella/tree/develop/packages/arrays/src/find-sequence.ts)
 - [`floydRivest()`](https://github.com/thi-ng/umbrella/tree/develop/packages/arrays/src/floyd-rivest.ts)
 - [`fuzzyMatch()`](https://github.com/thi-ng/umbrella/tree/develop/packages/arrays/src/fuzzy-match.ts)
 - [`insert()`](https://github.com/thi-ng/umbrella/tree/develop/packages/arrays/src/insert.ts)

package/arg-sort.d.ts

@@ -1,3 +1,4 @@
+import type { Comparator } from "@thi.ng/api";
 /**
  * Returns a new array of numeric indices in same order as sorted values of
  * `src` using given (optional) comparator (default: thi.ng/compare). The `src`
@@ -31,5 +32,5 @@
  * @param src -
  * @param cmp -
  */
-export declare const argSort: <T>(src: T[], cmp?: (a: any, b: any) => number) => any[];
+export declare const argSort: <T>(src: Iterable<T>, cmp?: Comparator<T>) => number[];
 //# sourceMappingURL=arg-sort.d.ts.map

package/arg-sort.js

@@ -1,7 +1,14 @@
 import { compare } from "@thi.ng/compare/compare";
 import { fillRange } from "./fill-range.js";
 import { sortByCachedKey } from "./sort-cached.js";
-const argSort = (src, cmp = compare) => sortByCachedKey(fillRange(new Array(src.length)), src.slice(), cmp);
+const argSort = (src, cmp = compare) => {
+  const $src = [...src];
+  return sortByCachedKey(
+    fillRange(new Array($src.length)),
+    $src,
+    cmp
+  );
+};
 export {
   argSort
 };

package/bisect.d.ts

@@ -1,11 +1,13 @@
-import type { Predicate } from "@thi.ng/api";
+import type { Predicate, TypedArray } from "@thi.ng/api";
 /**
- * Splits array at given index (default: floor(src.length/2)) and returns tuple of [lhs, rhs].
+ * Splits array at given index (default: floor(src.length/2)) and returns tuple
+ * of [lhs, rhs].
  *
  * @param src -
- * @param i -
+ * @param index -
  */
-export declare const bisect: <T>(src: T[], i?: number) => T[][];
+export declare function bisect<T>(src: T[], index?: number): [T[], T[]];
+export declare function bisect<T extends TypedArray>(src: T, index?: number): [T, T];
 /**
  * Similar to {@link bisect}, but first finds split index via provided
  * predicate. The item for which the predicate first returns a truthy result,
@@ -15,5 +17,6 @@ export declare const bisect: <T>(src: T[], i?: number) => T[][];
  * @param src -
  * @param pred -
  */
-export declare const bisectWith: <T>(src: T[], pred: Predicate<T>) => T[][];
+export declare function bisectWith<T>(src: T[], pred: Predicate<T>): [T[], T[]];
+export declare function bisectWith<T extends TypedArray>(src: T, pred: Predicate<number>): [T, T];
 //# sourceMappingURL=bisect.d.ts.map

package/bisect.js

@@ -1,11 +1,10 @@
-const bisect = (src, i = src.length >>> 1) => [
-  src.slice(0, i),
-  src.slice(i)
-];
-const bisectWith = (src, pred) => {
+function bisect(src, index = src.length >>> 1) {
+  return [src.slice(0, index), src.slice(index)];
+}
+function bisectWith(src, pred) {
   const i = src.findIndex(pred);
-  return i >= 0 ? bisect(src, i) : [src, []];
-};
+  return i >= 0 ? bisect(src, i) : [src, src.slice(0, 0)];
+}
 export {
   bisect,
   bisectWith

package/fill-range.d.ts

@@ -1,4 +1,4 @@
-import type { TypedArray } from "@thi.ng/api";
+import type { NumericArray } from "@thi.ng/api";
 /**
  * Fills given array with values in [start .. end) interval from `index`
  * and with optional `step` size.
@@ -28,5 +28,5 @@ import type { TypedArray } from "@thi.ng/api";
  * @param end -
  * @param step -
  */
-export declare const fillRange: <T extends number[] | TypedArray>(buf: T, index?: number, start?: number, end?: number, step?: number) => T;
+export declare const fillRange: <T extends NumericArray>(buf: T, index?: number, start?: number, end?: number, step?: number) => T;
 //# sourceMappingURL=fill-range.d.ts.map

package/find-seq.d.ts

@@ -0,0 +1,3 @@
+import type { NumericArray } from "@thi.ng/api";
+export declare const findSequence: (haystack: NumericArray, needle: NumericArray, i?: number) => number;
+//# sourceMappingURL=find-seq.d.ts.map

package/find-seq.js

@@ -0,0 +1,25 @@
+const findSequence = (haystack, needle, i = 0) => {
+  const m = haystack.length;
+  const n = needle.length;
+  const max = m - n;
+  if (max < 0)
+    return -1;
+  while (i < m) {
+    const idx = haystack.indexOf(needle[0], i);
+    if (idx < 0 || idx > max)
+      return -1;
+    let j;
+    for (j = 1; j < n; j++) {
+      if (haystack[idx + j] !== needle[j]) {
+        i = idx + 1;
+        break;
+      }
+    }
+    if (j >= n)
+      return idx;
+  }
+  return -1;
+};
+export {
+  findSequence
+};

package/find-sequence.d.ts

@@ -0,0 +1,26 @@
+import type { TypedArray } from "@thi.ng/api";
+/**
+ * Returns index of `needle` sequence in a larger buffer or -1 if unsuccessful.
+ * Search only starts at given `start` index.
+ *
+ * @remarks
+ * TODO Also add Boyer-Moore implementation as alternative for longer sequences
+ * (but with more overhead).
+ *
+ * @example
+ * ```ts tangle:../export/find-seq.ts
+ * import { findSequence } from "@thi.ng/arrays";
+ *
+ * console.log(
+ *   findSequence([1, 2, 3, 1, 2, 3, 4], [1, 2, 3, 4])
+ * );
+ * // 3
+ * ```
+ *
+ * @param buf
+ * @param needle
+ * @param start
+ */
+export declare function findSequence<T>(buf: Array<T>, needle: ArrayLike<T>, start?: number): number;
+export declare function findSequence(buf: TypedArray, needle: ArrayLike<number>, start?: number): number;
+//# sourceMappingURL=find-sequence.d.ts.map

package/find-sequence.js

@@ -0,0 +1,25 @@
+function findSequence(buf, needle, start = 0) {
+  const m = buf.length;
+  const n = needle.length;
+  const max = m - n;
+  if (max < 0)
+    return -1;
+  while (start < m) {
+    const idx = buf.indexOf(needle[0], start);
+    if (idx < 0 || idx > max)
+      return -1;
+    let j = n;
+    while (j-- > 1) {
+      if (buf[idx + j] !== needle[j]) {
+        start = idx + 1;
+        break;
+      }
+    }
+    if (j === 0)
+      return idx;
+  }
+  return -1;
+}
+export {
+  findSequence
+};

package/floyd-rivest.d.ts

@@ -1,4 +1,4 @@
-import type { Comparator } from "@thi.ng/api";
+import type { Comparator, TypedArray } from "@thi.ng/api";
 /**
  * Implementation of the Floyd-Rivest selection algorithm to partially find &
  * sort the `k`th smallest elements in given array, according to supplied
@@ -30,5 +30,6 @@ import type { Comparator } from "@thi.ng/api";
  * @param left
  * @param right
  */
-export declare const floydRivest: <T>(buf: T[], k?: number, cmp?: Comparator<T>, left?: number, right?: number) => T[];
+export declare function floydRivest<T>(buf: T[], k?: number, cmp?: Comparator<T>, left?: number, right?: number): T[];
+export declare function floydRivest<T extends TypedArray>(buf: T, k?: number, cmp?: Comparator<number>, left?: number, right?: number): T;
 //# sourceMappingURL=floyd-rivest.d.ts.map

package/floyd-rivest.js

@@ -1,6 +1,6 @@
 import { compare } from "@thi.ng/compare/compare";
 import { swap } from "./swap.js";
-const floydRivest = (buf, k = 1, cmp = compare, left = 0, right = buf.length - 1) => {
+function floydRivest(buf, k = 1, cmp = compare, left = 0, right = buf.length - 1) {
   while (right > left) {
     if (right - left > 600) {
       const n = right - left + 1;
@@ -43,7 +43,7 @@ const floydRivest = (buf, k = 1, cmp = compare, left = 0, right = buf.length - 1
       right = j - 1;
   }
   return buf;
-};
+}
 export {
   floydRivest
 };

package/index.d.ts

@@ -7,8 +7,9 @@ export * from "./blit.js";
 export * from "./ends-with.js";
 export * from "./ensure-array.js";
 export * from "./ensure-iterable.js";
-export * from "./find.js";
 export * from "./fill-range.js";
+export * from "./find.js";
+export * from "./find-sequence.js";
 export * from "./floyd-rivest.js";
 export * from "./fuzzy-match.js";
 export * from "./is-sorted.js";

package/index.js

@@ -7,8 +7,9 @@ export * from "./blit.js";
 export * from "./ends-with.js";
 export * from "./ensure-array.js";
 export * from "./ensure-iterable.js";
-export * from "./find.js";
 export * from "./fill-range.js";
+export * from "./find.js";
+export * from "./find-sequence.js";
 export * from "./floyd-rivest.js";
 export * from "./fuzzy-match.js";
 export * from "./is-sorted.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/arrays",
-  "version": "2.8.12",
+  "version": "2.9.0",
   "description": "Array / Arraylike utilities",
   "type": "module",
   "module": "./index.js",
@@ -108,6 +108,9 @@
     "./fill-range": {
       "default": "./fill-range.js"
     },
+    "./find-sequence": {
+      "default": "./find-sequence.js"
+    },
     "./find": {
       "default": "./find.js"
     },
@@ -166,5 +169,5 @@
   "thi.ng": {
     "year": 2018
   },
-  "gitHead": "feb3b24654f2c931cd3c3308c1c0c807ee14d0e4\n"
+  "gitHead": "db5f5a5d1b223a8e6b4999d67836678038fd3560\n"
 }