@thi.ng/arrays 2.7.7 → 2.7.9

package/quicksort.js

@@ -1,23 +1,26 @@
 import { compare } from "@thi.ng/compare/compare";
 import { swap } from "./swap.js";
-export function quickSort(arr, _cmp = compare, _swap = swap, start = 0, end = arr.length - 1) {
-    if (start < end) {
-        const pivot = arr[start + ((end - start) >> 1)];
-        let s = start - 1;
-        let e = end + 1;
-        while (true) {
-            do {
-                s++;
-            } while (_cmp(arr[s], pivot) < 0);
-            do {
-                e--;
-            } while (_cmp(arr[e], pivot) > 0);
-            if (s >= e)
-                break;
-            _swap(arr, s, e);
-        }
-        quickSort(arr, _cmp, _swap, start, e);
-        quickSort(arr, _cmp, _swap, e + 1, end);
+function quickSort(arr, _cmp = compare, _swap = swap, start = 0, end = arr.length - 1) {
+  if (start < end) {
+    const pivot = arr[start + (end - start >> 1)];
+    let s = start - 1;
+    let e = end + 1;
+    while (true) {
+      do {
+        s++;
+      } while (_cmp(arr[s], pivot) < 0);
+      do {
+        e--;
+      } while (_cmp(arr[e], pivot) > 0);
+      if (s >= e)
+        break;
+      _swap(arr, s, e);
     }
-    return arr;
+    quickSort(arr, _cmp, _swap, start, e);
+    quickSort(arr, _cmp, _swap, e + 1, end);
+  }
+  return arr;
 }
+export {
+  quickSort
+};

package/rotate.js

@@ -1,45 +1,29 @@
-/**
- * Rotates array by `num` items. If `num < 0` items are rotated left (towards
- * the beginning of the array), otherwise to the right (end). The rotation
- * distance will be `num % buf.length`. The function is no-op if the resulting
- * distance is zero or `buf` is empty.
- *
- * @remarks
- * Not suitable for typed arrays. Use {@link rotateTyped} for those.
- *
- * @param buf
- * @param num
- */
-export const rotate = (buf, num) => {
-    if (!(num = __distance(buf, num)))
-        return buf;
-    if (num < 0) {
-        buf.push(...buf.splice(0, -num));
-    }
-    else {
-        buf.unshift(...buf.splice(-num));
-    }
+const rotate = (buf, num) => {
+  if (!(num = __distance(buf, num)))
     return buf;
+  if (num < 0) {
+    buf.push(...buf.splice(0, -num));
+  } else {
+    buf.unshift(...buf.splice(-num));
+  }
+  return buf;
 };
-/**
- * Same as {@link rotate}, but for optimized for typed arrays!
- *
- * @param buf
- * @param num
- */
-export const rotateTyped = (buf, num) => {
-    if (!(num = __distance(buf, num)))
-        return buf;
-    if (num < 0) {
-        const tmp = buf.slice(0, -num);
-        buf.copyWithin(0, -num);
-        buf.set(tmp, buf.length + num);
-    }
-    else if (num > 0) {
-        const tmp = buf.slice(buf.length - num);
-        buf.copyWithin(num, 0);
-        buf.set(tmp, 0);
-    }
+const rotateTyped = (buf, num) => {
+  if (!(num = __distance(buf, num)))
     return buf;
+  if (num < 0) {
+    const tmp = buf.slice(0, -num);
+    buf.copyWithin(0, -num);
+    buf.set(tmp, buf.length + num);
+  } else if (num > 0) {
+    const tmp = buf.slice(buf.length - num);
+    buf.copyWithin(num, 0);
+    buf.set(tmp, 0);
+  }
+  return buf;
 };
 const __distance = (buf, num) => buf.length ? (num | 0) % buf.length : 0;
+export {
+  rotate,
+  rotateTyped
+};

package/shuffle.js

@@ -1,39 +1,22 @@
 import { assert } from "@thi.ng/errors/assert";
 import { SYSTEM } from "@thi.ng/random/system";
-/**
- * Shuffles the items in the given index range of array `buf` using Fisher-yates
- * and optional `rnd` PRNG.
- *
- * @remarks
- * If neither `start` / `end` are given, the entire array will be shuffled.
- * Mutates original array.
- *
- * See [`IRandom`](https://docs.thi.ng/umbrella/random/interfaces/IRandom.html)
- *
- * @param buf - array
- * @param n - num items
- * @param rnd - PRNG
- */
-export const shuffleRange = (buf, start = 0, end = buf.length, rnd = SYSTEM) => {
-    assert(start >= 0 && end >= start && end <= buf.length, `illegal range ${start}..${end}`);
-    if (end - start > 1) {
-        for (let i = end; i-- > start;) {
-            const a = rnd.minmax(start, i + 1) | 0;
-            const t = buf[a];
-            buf[a] = buf[i];
-            buf[i] = t;
-        }
+const shuffleRange = (buf, start = 0, end = buf.length, rnd = SYSTEM) => {
+  assert(
+    start >= 0 && end >= start && end <= buf.length,
+    `illegal range ${start}..${end}`
+  );
+  if (end - start > 1) {
+    for (let i = end; i-- > start; ) {
+      const a = rnd.minmax(start, i + 1) | 0;
+      const t = buf[a];
+      buf[a] = buf[i];
+      buf[i] = t;
     }
-    return buf;
+  }
+  return buf;
+};
+const shuffle = (buf, n = buf.length, rnd = SYSTEM) => shuffleRange(buf, 0, n, rnd);
+export {
+  shuffle,
+  shuffleRange
 };
-/**
- * Applies {@link shuffleRange} to the given array. If `n` is given,
- * only the first `n` items are shuffled. Mutates original array.
- *
- * {@link shuffleRange}
- *
- * @param buf - array
- * @param n - num items
- * @param rnd - PRNG
- */
-export const shuffle = (buf, n = buf.length, rnd = SYSTEM) => shuffleRange(buf, 0, n, rnd);

package/sort-cached.js

@@ -3,36 +3,12 @@ import { compare } from "@thi.ng/compare/compare";
 import { assert } from "@thi.ng/errors/assert";
 import { quickSort } from "./quicksort.js";
 import { multiSwap } from "./swap.js";
-/**
- * Takes a `src` array and `key` array of function to provide the sort key of
- * each item. If a function, it will be first applied to pre-compute a new array
- * of all sort keys. Then uses {@link quickSort} to sort `src` array, based on
- * the ordering of cached keys and the optionally given comparator. Returns
- * `src`.
- *
- * @remarks
- * This function is primarily intended for use cases where an array needs to be
- * sorted based on the item order of another array, or where sort keys are
- * derived from non-trivial computations and need to be cached, rather than be
- * re-evaluated multiple times from within a comparator.
- *
- * @example
- * ```ts
- * // sort by length in descending order
- * sortByCachedKey(["a","bbbb","ccc","dd"], (x) => x.length, (a, b) => b - a);
- * // [ 'bbbb', 'ccc', 'dd', 'a' ]
- *
- * sortByCachedKey(["a", "b", "c", "d"], [3, 2, 1, 0])
- * // [ 'd', 'c', 'b', 'a' ]
- * ```
- *
- * @param src -
- * @param key -
- * @param cmp -
- */
-export const sortByCachedKey = (src, key, cmp = compare) => {
-    const keys = isFunction(key) ? src.map(key) : key;
-    assert(keys.length === src.length, `keys.length != src.length`);
-    quickSort(keys, cmp, multiSwap(src));
-    return src;
+const sortByCachedKey = (src, key, cmp = compare) => {
+  const keys = isFunction(key) ? src.map(key) : key;
+  assert(keys.length === src.length, `keys.length != src.length`);
+  quickSort(keys, cmp, multiSwap(src));
+  return src;
+};
+export {
+  sortByCachedKey
 };

package/starts-with.js

@@ -1,26 +1,13 @@
 import { equiv as _eq } from "@thi.ng/equiv";
-/**
- * Returns true if the first items of `buf` are the same items as in `needle`.
- *
- * @remarks
- * This means `buf` should have at least the same length as `needle` for this to
- * be true.
- *
- * By default, uses
- * [`equiv()`](https://docs.thi.ng/umbrella/equiv/functions/equiv.html) for
- * equality checking.
- *
- * {@link endsWith}
- *
- * @param buf - array
- * @param needle - search value
- * @param equiv - equivalence predicate
- */
-export const startsWith = (buf, needle, equiv = _eq) => {
-    let i = buf.length;
-    let j = needle.length;
-    if (i < j)
-        return false;
-    while (-j >= 0 && equiv(buf[j], needle[j])) { }
-    return j < 0;
+const startsWith = (buf, needle, equiv = _eq) => {
+  let i = buf.length;
+  let j = needle.length;
+  if (i < j)
+    return false;
+  while (-j >= 0 && equiv(buf[j], needle[j])) {
+  }
+  return j < 0;
+};
+export {
+  startsWith
 };

package/swap.js

@@ -1,73 +1,41 @@
-/**
- * Swaps values at index `x`/`y` in given array.
- *
- * @param arr - array
- * @param x - first index
- * @param y - other index
- */
-export const swap = (arr, x, y) => {
-    const t = arr[x];
-    arr[x] = arr[y];
-    arr[y] = t;
+const swap = (arr, x, y) => {
+  const t = arr[x];
+  arr[x] = arr[y];
+  arr[y] = t;
 };
-/**
- * Higher-order version of {@link swap} for swapping elements in multiple arrays
- * at once and hence useful for sorting multiple arrays based on a single
- * criteria.
- *
- * @remarks
- * The returned function takes the same args as `swap`, and when called swaps 2
- * elements in the array given to that function AND in the arrays given to
- * {@link multiSwap} itself. Provides fast routes for up to 3 extra arrays, then
- * falls back to a loop-based approach.
- *
- * {@link quickSort}
- *
- * @example
- * ```ts
- * a = [2, 1];
- * b = [20, 10];
- * c = [40, 30];
- *
- * ms = multiSwap(b, c);
- * ms(a, 0, 1);
- *
- * // a: [1, 2]
- * // b: [10, 20]
- * // c: [30, 40]
- * ```
- *
- * @param xs - arrays to swap in later
- */
-export const multiSwap = (...xs) => {
-    const [b, c, d] = xs;
-    const n = xs.length;
-    switch (n) {
-        case 0:
-            return swap;
-        case 1:
-            return (a, x, y) => {
-                swap(a, x, y);
-                swap(b, x, y);
-            };
-        case 2:
-            return (a, x, y) => {
-                swap(a, x, y);
-                swap(b, x, y);
-                swap(c, x, y);
-            };
-        case 3:
-            return (a, x, y) => {
-                swap(a, x, y);
-                swap(b, x, y);
-                swap(c, x, y);
-                swap(d, x, y);
-            };
-        default:
-            return (a, x, y) => {
-                swap(a, x, y);
-                for (let i = n; i-- > 0;)
-                    swap(xs[i], x, y);
-            };
-    }
+const multiSwap = (...xs) => {
+  const [b, c, d] = xs;
+  const n = xs.length;
+  switch (n) {
+    case 0:
+      return swap;
+    case 1:
+      return (a, x, y) => {
+        swap(a, x, y);
+        swap(b, x, y);
+      };
+    case 2:
+      return (a, x, y) => {
+        swap(a, x, y);
+        swap(b, x, y);
+        swap(c, x, y);
+      };
+    case 3:
+      return (a, x, y) => {
+        swap(a, x, y);
+        swap(b, x, y);
+        swap(c, x, y);
+        swap(d, x, y);
+      };
+    default:
+      return (a, x, y) => {
+        swap(a, x, y);
+        for (let i = n; i-- > 0; )
+          swap(xs[i], x, y);
+      };
+  }
+};
+export {
+  multiSwap,
+  swap
 };

package/swizzle.js

@@ -1,56 +1,34 @@
-/**
- * Returns optimized function to immutably select, repeat, reshape and /
- * or reorder array / object values in the specified index order.
- *
- * @remarks
- * Fast paths for up to 8 indices are provided, before a loop based
- * approach is used.
- *
- * @example
- * ```ts
- * swizzle([0, 0, 0])([1, 2, 3, 4])    // [ 1, 1, 1 ]
- * swizzle([1, 1, 3, 3])([1, 2, 3, 4]) // [ 2, 2, 4, 4 ]
- * swizzle([2, 0])([1, 2, 3])          // [ 3, 1 ]
- * ```
- *
- * @example
- * Objects can be used as input to the generated function, but the
- * result will always be in array form.
-
- * ```ts
- * swizzle(["a", "c", "b"])({a: 1, b: 2, c: 3}) // [ 1, 3, 2 ]
- * ```
- *
- * @param order - indices
- */
-export const swizzle = (order) => {
-    const [a, b, c, d, e, f, g, h] = order;
-    switch (order.length) {
-        case 0:
-            return () => [];
-        case 1:
-            return (x) => [x[a]];
-        case 2:
-            return (x) => [x[a], x[b]];
-        case 3:
-            return (x) => [x[a], x[b], x[c]];
-        case 4:
-            return (x) => [x[a], x[b], x[c], x[d]];
-        case 5:
-            return (x) => [x[a], x[b], x[c], x[d], x[e]];
-        case 6:
-            return (x) => [x[a], x[b], x[c], x[d], x[e], x[f]];
-        case 7:
-            return (x) => [x[a], x[b], x[c], x[d], x[e], x[f], x[g]];
-        case 8:
-            return (x) => [x[a], x[b], x[c], x[d], x[e], x[f], x[g], x[h]];
-        default:
-            return (x) => {
-                const res = [];
-                for (let i = order.length; i-- > 0;) {
-                    res[i] = x[order[i]];
-                }
-                return res;
-            };
-    }
+const swizzle = (order) => {
+  const [a, b, c, d, e, f, g, h] = order;
+  switch (order.length) {
+    case 0:
+      return () => [];
+    case 1:
+      return (x) => [x[a]];
+    case 2:
+      return (x) => [x[a], x[b]];
+    case 3:
+      return (x) => [x[a], x[b], x[c]];
+    case 4:
+      return (x) => [x[a], x[b], x[c], x[d]];
+    case 5:
+      return (x) => [x[a], x[b], x[c], x[d], x[e]];
+    case 6:
+      return (x) => [x[a], x[b], x[c], x[d], x[e], x[f]];
+    case 7:
+      return (x) => [x[a], x[b], x[c], x[d], x[e], x[f], x[g]];
+    case 8:
+      return (x) => [x[a], x[b], x[c], x[d], x[e], x[f], x[g], x[h]];
+    default:
+      return (x) => {
+        const res = [];
+        for (let i = order.length; i-- > 0; ) {
+          res[i] = x[order[i]];
+        }
+        return res;
+      };
+  }
+};
+export {
+  swizzle
 };

package/threshold.js

@@ -1,50 +1,18 @@
-/**
- * Higher order function. Takes an object of threshold values and their target
- * values, as well as a default value. Returns a new function which then matches
- * a given value against all given thresholds and returns a matching target
- * value, of (if none matched), the given default.
- *
- * @remarks
- * The thresholds will be sorted & matched in ascending order using `<=`
- * comparison.
- *
- * @example
- * ```ts
- * const numColumns = selectThresholdMin({ 480: 1, 640: 2, 960: 3 }, 4);
- *
- * numColumns(320) // 1
- *
- * numColumns(481) // 2
- *
- * numColumns(768) // 3
- *
- * numColumns(1024) // 4
- * ```
- *
- * @param thresholds
- * @param defaultVal
- */
-export const selectThresholdMin = (thresholds, defaultVal) => {
-    const $thresholds = Object.entries(thresholds)
-        .map(([k, v]) => [+k, v])
-        .sort((a, b) => a[0] - b[0]);
-    return (x) => {
-        const res = $thresholds.find((t) => x <= t[0]);
-        return res ? res[1] : defaultVal;
-    };
+const selectThresholdMin = (thresholds, defaultVal) => {
+  const $thresholds = Object.entries(thresholds).map(([k, v]) => [+k, v]).sort((a, b) => a[0] - b[0]);
+  return (x) => {
+    const res = $thresholds.find((t) => x <= t[0]);
+    return res ? res[1] : defaultVal;
+  };
 };
-/**
- * Similar to {@link selectThresholdMin}, but uses `>=` ordering.
- *
- * @param thresholds
- * @param defaultVal
- */
-export const selectThresholdMax = (thresholds, defaultVal) => {
-    const $thresholds = Object.entries(thresholds)
-        .map(([k, v]) => [+k, v])
-        .sort((a, b) => b[0] - a[0]);
-    return (x) => {
-        const res = $thresholds.find((t) => x >= t[0]);
-        return res ? res[1] : defaultVal;
-    };
+const selectThresholdMax = (thresholds, defaultVal) => {
+  const $thresholds = Object.entries(thresholds).map(([k, v]) => [+k, v]).sort((a, b) => b[0] - a[0]);
+  return (x) => {
+    const res = $thresholds.find((t) => x >= t[0]);
+    return res ? res[1] : defaultVal;
+  };
+};
+export {
+  selectThresholdMax,
+  selectThresholdMin
 };

package/topo-sort.js

@@ -1,54 +1,24 @@
 import { illegalState } from "@thi.ng/errors";
-/**
- * Takes an object describing a DAG of nodes of type T with keys being node IDs.
- * Also takes a function which will be applied to each node and either returns
- * an array of node IDs the given node depends on or null if the node has no
- * dependencies. Traverses all nodes in the graph (object) and returns an array
- * of node IDs in topological dependency order.
- *
- * @remarks
- * An error will be thrown if the graph contains cycles. In this case, the full
- * cycle will be part of the error message (see second example below).
- *
- * @example
- * ```ts
- * const graph = {
- *   a: { deps: ["c", "b"] },
- *   b: {},
- *   c: { deps: ["d"] },
- *   d: { deps: ["b"] }
- * };
- * topoSort(graph, (node) => node.deps);
- * // [ "b", "d", "c", "a" ]
- *
- * // An error will be thrown if the graph contains cycles...
- * graph.d.deps.push("a");
- *
- * topoSort(graph, (node) => node.deps);
- * // Uncaught Error: illegal state: dependency cycle: a -> c -> d -> a
- * ```
- *
- * @param nodes
- * @param deps
- * @returns
- */
-export const topoSort = (nodes, deps) => {
-    const cycles = {};
-    const topology = [];
-    const sort = (id, path) => {
-        if (cycles[id])
-            illegalState(`dependency cycle: ${path.join(" -> ")}`);
-        cycles[id] = true;
-        const nodeDeps = deps(nodes[id]);
-        if (nodeDeps) {
-            for (let d of nodeDeps)
-                sort(d, [...path, d]);
-        }
-        cycles[id] = false;
-        if (!topology.includes(id))
-            topology.push(id);
-    };
-    for (let id in nodes)
-        sort(id, [id]);
-    return topology;
+const topoSort = (nodes, deps) => {
+  const cycles = {};
+  const topology = [];
+  const sort = (id, path) => {
+    if (cycles[id])
+      illegalState(`dependency cycle: ${path.join(" -> ")}`);
+    cycles[id] = true;
+    const nodeDeps = deps(nodes[id]);
+    if (nodeDeps) {
+      for (let d of nodeDeps)
+        sort(d, [...path, d]);
+    }
+    cycles[id] = false;
+    if (!topology.includes(id))
+      topology.push(id);
+  };
+  for (let id in nodes)
+    sort(id, [id]);
+  return topology;
+};
+export {
+  topoSort
 };