@thi.ng/transducers 8.1.3 → 8.2.0

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2021-12-13T10:26:00Z
+- **Last updated**: 2021-12-14T09:12:13Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -9,6 +9,16 @@ 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.
 
+## [8.2.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/transducers@8.2.0) (2021-12-14)
+
+#### 🚀 Features
+
+- update/fix/extend streamShuffle() ([dc26203](https://github.com/thi-ng/umbrella/commit/dc26203))
+  - add StreamShuffleOpts, add IRandom opt
+  - fix args for internal shuffle() calls
+  - optimize number of shuffle calls
+  - optimize final buffer drain
+
 ## [8.1.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/transducers@8.1.0) (2021-11-17)
 
 #### 🚀 Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/transducers",
-  "version": "8.1.3",
+  "version": "8.2.0",
   "description": "Lightweight transducer implementations for ES6 / TypeScript",
   "type": "module",
   "module": "./index.js",
@@ -567,5 +567,5 @@
     ],
     "year": 2016
   },
-  "gitHead": "2db9dd34c0c2c60cbfde3dad0bca352b20292f5c\n"
+  "gitHead": "1ba92c6b9509e74e509b4c0b875fc380a97bbbc1\n"
 }

package/stream-shuffle.d.ts

@@ -1,20 +1,44 @@
+import type { IRandom } from "@thi.ng/random";
 import type { Transducer } from "./api.js";
+export interface StreamShuffleOpts {
+    /**
+     * Sliding window size
+     */
+    n: number;
+    /**
+     * Max. shuffle ops per new input (in [0..n] range)
+     *
+     * @defaultValue same as `n`
+     */
+    max?: number;
+    /**
+     * PRNG instance to use for shuffling
+     *
+     * @defaultValue SYSTEM
+     */
+    rnd?: IRandom;
+}
 /**
- * Transducer. Creates internal sliding window of `n` values and
- * performs `maxSwaps` random shuffle operations for each new value and
- * yields values in shuffled order. By default `maxSwaps` is the same as
- * the chosen chunk size.
+ * Transducer. Creates internal sliding window of `n` values and performs
+ * `maxSwaps` random shuffle operations for each new value and yields values in
+ * shuffled order. By default `maxSwaps` is the same as the chosen chunk size.
+ * If given a {@link StreamShuffleOpts} options object, further configurations
+ * are possible.
  *
  * @example
  * ```ts
  * [...streamShuffle(5, range(10))]
  * // [ 3, 2, 5, 0, 8, 7, 1, 6, 4, 9 ]
+ *
+ * [...streamShuffle({ n: 5, rnd: new XsAdd(12345) }, range(10))]
+ * [ 0, 4, 3, 7, 8, 1, 5, 2, 6, 9 ]
  * ```
  *
  * @param n - sliding window size
  * @param maxSwaps - number of swaps per input
  */
 export declare function streamShuffle<T>(n: number, maxSwaps?: number): Transducer<T, T>;
-export declare function streamShuffle<T>(n: number, src: Iterable<T>): IterableIterator<T>;
+export declare function streamShuffle<T>(opts: StreamShuffleOpts): Transducer<T, T>;
+export declare function streamShuffle<T>(opts: number | StreamShuffleOpts, src: Iterable<T>): IterableIterator<T>;
 export declare function streamShuffle<T>(n: number, maxSwaps: number, src: Iterable<T>): IterableIterator<T>;
 //# sourceMappingURL=stream-shuffle.d.ts.map

package/stream-shuffle.js

@@ -1,26 +1,42 @@
 import { shuffle } from "@thi.ng/arrays/shuffle";
+import { isPlainObject } from "@thi.ng/checks";
+import { SYSTEM } from "@thi.ng/random/system";
 import { __iter, iterator } from "./iterator.js";
 import { isReduced } from "./reduced.js";
 export function streamShuffle(...args) {
     return (__iter(streamShuffle, args, iterator) ||
         (([init, complete, reduce]) => {
-            const n = args[0];
-            const maxSwaps = args[1] || n;
+            let n;
+            let maxSwaps;
+            let rnd = SYSTEM;
+            const opts = args[0];
+            if (isPlainObject(opts)) {
+                n = opts.n;
+                maxSwaps = opts.max || n;
+                opts.rnd && (rnd = opts.rnd);
+            }
+            else {
+                n = args[0];
+                maxSwaps = args[1] || n;
+            }
             const buf = [];
             return [
                 init,
                 (acc) => {
-                    while (buf.length && !isReduced(acc)) {
-                        shuffle(buf, maxSwaps);
-                        acc = reduce(acc, buf.shift());
+                    if (buf.length) {
+                        shuffle(buf, Math.min(maxSwaps, buf.length), rnd);
+                        for (let i = 0, n = buf.length; i < n && !isReduced(acc); i++) {
+                            acc = reduce(acc, buf[i]);
+                        }
                     }
+                    buf.length = 0;
                     acc = complete(acc);
                     return acc;
                 },
                 (acc, x) => {
                     buf.push(x);
-                    shuffle(buf, maxSwaps);
                     if (buf.length === n) {
+                        shuffle(buf, Math.min(maxSwaps, n), rnd);
                         acc = reduce(acc, buf.shift());
                     }
                     return acc;