initial commit

2024-05-04 01:19:44 +02:00
commit a172e6a50f
16 changed files with 6514 additions and 0 deletions
--- a/src/random.ts
+++ b/src/random.ts
@@ -0,0 +1,137 @@
+import { BitArray } from "./bitarray.js";
+import { asArray } from "./utils.js";
+
+export interface ElementPredicate<T = any> {
+  (index: number, obj: T): boolean;
+}
+
+export interface ElementWeight<T = any> {
+  (index: number, obj: T): number;
+}
+
+export interface RandomGenerator {
+  (): number;
+}
+
+export interface RandomOptions<T> {
+  predicate?: ElementPredicate<T>;
+  weight?: ElementWeight<T>;
+  random?: RandomGenerator;
+};
+
+export const alwaysTrue: ElementPredicate = () => true;
+export const weightOfOne: ElementWeight = () => 1.0;
+export const mathRandom: RandomGenerator = () => Math.random();
+
+const defaultOptions = Object.freeze<Required<RandomOptions<any>>>({
+  predicate: alwaysTrue,
+  weight: weightOfOne,
+  random: mathRandom
+});
+
+function mergeOptions<T>(first: RandomOptions<T> | undefined, second: RandomOptions<T> | undefined): RandomOptions<T> | undefined {
+  if (!first) {
+    return second;
+  }
+
+  if (!second) {
+    return first;
+  }
+
+  const firstPredicate = first.predicate;
+  const secondPredicate = second.predicate;
+
+  return {
+    predicate: firstPredicate ? secondPredicate ? (i, o) => firstPredicate(i, o) && secondPredicate(i, o) : firstPredicate : secondPredicate,
+    weight: first.weight ?? second.weight,
+    random: first.random ?? second.random
+  };
+}
+
+function withDefaultOptions<T>(options: RandomOptions<T> | undefined): Required<RandomOptions<T>> {
+  if (!options) {
+    return { ...defaultOptions };
+  }
+
+  return {
+    predicate: options.predicate ?? defaultOptions.predicate,
+    weight: options.weight ?? defaultOptions.weight,
+    random: options.random ?? defaultOptions.random
+  };
+}
+
+export function getRandomElement<T>(sequence: Iterable<T>, options?: RandomOptions<T>) {
+  const { predicate, weight, random } = withDefaultOptions(options);
+
+  let result: T | undefined = undefined;
+  let resultIndex = -1;
+  let index = 0;
+  let weightAcc = 0.0;
+
+  for (const element of sequence) {
+    const currentIndex = index++;
+
+    if (predicate(currentIndex, element)) {
+      const w = weight(currentIndex, element);
+
+      if (w <= 0.0) {
+        continue;
+      }
+
+      weightAcc += w;
+
+      if (random() * weightAcc < w) {
+        result = element;
+        resultIndex = currentIndex;
+      }
+    }
+  }
+
+  return { element: result, index: resultIndex };
+}
+
+export class RandomPicker<T> {
+  readonly #elements: Iterable<T>;
+  readonly #flags: BitArray;
+  readonly #options: RandomOptions<T>;
+
+  public constructor(elements: T[], options?: RandomOptions<T>) {
+    this.#elements = elements;
+    this.#flags = new BitArray(elements.length);
+    this.#options = withDefaultOptions(mergeOptions({ predicate: (i, o) => this.#flags.get(i) }, options));
+
+    this.reset();
+  }
+
+  public static from<T>(iterable: Iterable<T>, options?: RandomOptions<T>) {
+    return new this<T>(asArray(iterable), options);
+  }
+
+  public static of<T>(options?: RandomOptions<T>, ...values: T[]) {
+    return new this<T>(values, options);
+  }
+
+  public get state() {
+    return this.#flags;
+  }
+
+  public reset() {
+    this.#flags.fill(true);
+  }
+
+  public next() {
+    const result = getRandomElement(this.#elements, this.#options);
+
+    if (result.index < 0) {
+      this.reset();
+    } else {
+      this.#flags.set(result.index, false);
+
+      if (this.#flags.isEmpty()) {
+        this.reset();
+      }
+    }
+
+    return result.element;
+  }
+}