Seedable Pseudorandom Number Generator with Typescript


Often I run into scenarios1 where I want to have a seedable random number generator. So I went looking for prior work and found Alea.2 In 2010 Johannes Baag√łe proposed Alea, a variation on Multiply-with-carry that was designed to account for JavaScript’s quaint notion of numbers. You can find the original JavaScript version of this generator along with a more detailed description of the algorithm on his website via archive.org or a github mirror. This is my port of the algorithm to TypeScript along with a few helper functions to generate common data types.3

export type Rng = {
  seed: Array<string>;
  random: () => number;
};

export const Rng = (seed: string, ...extraSeed: Array<string>): Rng => {
  const args = [seed, ...extraSeed];

  let mash = Mash();
  let s0 = mash(' ');
  let s1 = mash(' ');
  let s2 = mash(' ');
  let c = 1;

  for (let i = 0; i < args.length; ++i) {
    s0 -= mash(args[i]);
    if (s0 < 0) { s0 += 1; }
    s1 -= mash(args[i]);
    if (s1 < 0) { s1 += 1; }
    s2 -= mash(args[i]);
    if (s2 < 0) { s2 += 1; }
  }

  return <Rng>{
    seed: args,
    random: () => {
      let t = 2091639 * s0 + c * 2.3283064365386963e-10; // 2^-32
      s0 = s1;
      s1 = s2;
      return s2 = t - (c = t | 0);
    },
  }
};

export const shuffleInPlace = <T>(r: Rng, a: Array<T>): void => {
  for (let i = a.length - 1; i > 0; --i) {
    const j = Math.floor(r.random() * i);
    const tmp = a[i];
    a[i] = a[j];
    a[j] = tmp;
  }
};

export const select = <T>(r: Rng, a: Array<T>): T => a[uint32(r) % a.length];
export const selectIndex = <_>(r: Rng, a: Array<T>): number => uint32(r) % a.length;

export const str = (() => {
  const charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz ';
  return (r: Rng, min: number, max: number): string => {
    let result = '';
    let l = range(r, min, max);
    for(let i = 0; i < l; ++i) {
      result += charset.charAt(Math.floor(r.random() * charset.length));
    }
    return result;
  }
})();

export const range = (r: Rng, min: number, max: number): number => min + r.random() * (max - min);
export const uint32 = (r: Rng): number => r.random() * 0x100000000; // 2^32
export const fract53 = (r: Rng): number => r.random() + (r.random() * 0x200000 | 0) * 1.1102230246251565e-16; // 2^-53

const Mash = (): ((data: string) => number) => {
  var n = 0xefc8249d;

  return ((data: string): number => {
    for (var i = 0; i < data.length; i++) {
      n += data.charCodeAt(i);
      var h = 0.02519603282416938 * n;
      n = h >>> 0;
      h -= n;
      h *= n;
      n = h >>> 0;
      h -= n;
      n += h * 0x100000000; // 2^32
    }
    return (n >>> 0) * 2.3283064365386963e-10; // 2^-32
  });
};

  1. Database seeding with a markov chain based name generator, selecting mutations when using evolutionary algorithms, or sharing procedurally generated levels in a game to name a few.
  2. Many of the more modern libraries add too many abstractions for supporting a wide variety of algorithms, add a large graph of dependencies, or are otherwise opaque. So I opted to avoid any of the libraries published on NPM and instead focused on the algorithm itself rather than a specific implementation.
  3. random.ts if you prefer to just download the file directly.