feat: added missing prng algorithms

Author: jurerotar

README.md

@@ -1,9 +1,6 @@
 # ts-seedrandom
 
-Seeded random number generators for JavaScript, ported to TypeScript. Forked from https://github.com/davidbau/seedrandom.
-
-> [!WARNING]
-> Not all functionality from original package has been ported so far. Currently, only Alea and ARC4 algorithms are available.
+Seeded random number generators for JavaScript, ported to TypeScript. Based on https://github.com/shanewholloway/js-esm-seedrandom.
 
 ## Installation
 
@@ -42,3 +39,17 @@ const state = aleaGenerator.state();
 const secondAleaGenerator = prngAlea('seed', state);
 ```
 
+## Available Algorithms
+
+The following PRNG algorithms are available:
+
+1. `prngAlea`: Alea algorithm
+2. `prngArc4`: ARC4 algorithm
+3. `prngTychei`: Tyche-i algorithm
+4. `prngXor128`: XorShift128 algorithm
+5. `prngXor4096`: XorShift4096 algorithm
+6. `prngXorshift7`: XorShift7 algorithm
+7. `prngXorwow`: Xorwow algorithm
+
+You can import and use any of these algorithms in the same way as demonstrated in the usage examples above.
+

package-lock.json

@@ -1,10 +1,10 @@
 {
   "name": "ts-seedrandom",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "type": "module",
   "description": "Seeded random number generators for JavaScript, ported to TypeScript",
   "author": "Jure Rotar <[email protected]>",
-  "contributors": ["David Bau"],
+  "contributors": ["David Bau", "Shane Holloway"],
   "license": "MIT",
   "homepage": "https://github.com/jurerotar/ts-seedrandom#README",
   "repository": {
@@ -41,7 +41,7 @@
   },
   "devDependencies": {
     "@biomejs/biome": "1.9.3",
-    "seedrandom": "3.0.5",
+    "esm-seedrandom": "^3.0.5",
     "typescript": "5.6.2",
     "vite": "5.4.8",
     "vitest": "2.1.2"

package.json

@@ -1,5 +1,37 @@
 import { alea } from 'src/prng-algorithms/alea';
 import { arc4 } from 'src/prng-algorithms/arc-4';
-import type { AleaGeneratorState, Arc4GeneratorState, PRNGAlgorithm, PRNGFunction } from 'src/types';
+import { tychei } from 'src/prng-algorithms/tychei';
+import { xor128 } from 'src/prng-algorithms/xor-128';
+import { xor4096 } from 'src/prng-algorithms/xor-4096';
+import { xorShift7 } from 'src/prng-algorithms/xor-shift-7';
+import { xorWow } from 'src/prng-algorithms/xor-wow';
+import type {
+  AleaGeneratorState,
+  Arc4GeneratorState,
+  PRNGAlgorithm,
+  PRNGFunction,
+  TycheiGeneratorState,
+  Xor128GeneratorState,
+  Xor4096GeneratorState,
+  XorShift7GeneratorState,
+  XorwowGeneratorState,
+} from 'src/types';
 
-export { alea as prngAlea, arc4 as prngArc4, type PRNGAlgorithm, type PRNGFunction, type AleaGeneratorState, type Arc4GeneratorState };
+export {
+  alea as prngAlea,
+  arc4 as prngArc4,
+  tychei as prngTychei,
+  xor128 as prngXor128,
+  xor4096 as prngXor4096,
+  xorShift7 as prngXorShift7,
+  xorWow as prngXorWow,
+  type PRNGAlgorithm,
+  type PRNGFunction,
+  type AleaGeneratorState,
+  type Arc4GeneratorState,
+  type TycheiGeneratorState,
+  type Xor128GeneratorState,
+  type Xor4096GeneratorState,
+  type XorShift7GeneratorState,
+  type XorwowGeneratorState,
+};

src/index.ts

@@ -1,45 +1,44 @@
 // @ts-ignore
-import seedrandom from 'seedrandom';
-import { prngAlea, prngArc4 } from 'src/index';
+import { prng_alea, prng_arc4, prng_tychei, prng_xor128, prng_xor4096, prng_xorshift7, prng_xorwow } from 'esm-seedrandom';
+import { prngAlea, prngArc4, prngTychei, prngXor128, prngXor4096, prngXorShift7, prngXorWow } from 'src/index';
 import { describe, expect, test } from 'vitest';
 
-// TODO: Uncomment additional tests as more algorithms are ported over
 const prngPairs = [
   {
     name: 'alea',
-    originalPrng: seedrandom.alea,
+    originalPrng: prng_alea,
     portedPrng: prngAlea,
   },
   {
     name: 'arc4',
-    originalPrng: seedrandom,
+    originalPrng: prng_arc4,
     portedPrng: prngArc4,
   },
-  // {
-  //   name: 'tychei',
-  //   originalPrng: seedrandom.tychei,
-  //   portedPrng: prngAlea,
-  // },
-  // {
-  //   name: 'xor128',
-  //   originalPrng: seedrandom.xor128,
-  //   portedPrng: prngAlea,
-  // },
-  // {
-  //   name: 'xor4096',
-  //   originalPrng: seedrandom.xor4096,
-  //   portedPrng: prngAlea,
-  // },
-  // {
-  //   name: 'xorShift7',
-  //   originalPrng: seedrandom.xorShift7,
-  //   portedPrng: prngAlea,
-  // },
-  // {
-  //   name: 'xorWow',
-  //   originalPrng: seedrandom.xorWow,
-  //   portedPrng: prngAlea,
-  // },
+  {
+    name: 'tychei',
+    originalPrng: prng_tychei,
+    portedPrng: prngTychei,
+  },
+  {
+    name: 'xor128',
+    originalPrng: prng_xor128,
+    portedPrng: prngXor128,
+  },
+  {
+    name: 'xor4096',
+    originalPrng: prng_xor4096,
+    portedPrng: prngXor4096,
+  },
+  {
+    name: 'xorShift7',
+    originalPrng: prng_xorshift7,
+    portedPrng: prngXorShift7,
+  },
+  {
+    name: 'xorWow',
+    originalPrng: prng_xorwow,
+    portedPrng: prngXorWow,
+  },
 ];
 
 describe('prng algorithms', () => {
@@ -49,11 +48,11 @@ describe('prng algorithms', () => {
         const originalPrngInstance = originalPrng('seed');
         const portedPrngInstance = portedPrng('seed');
 
-        for (let i = 0; i <= 100; i += 1) {
+        for (let i = 0; i <= 10000; i += 1) {
           const originalPrngNextValue = originalPrngInstance();
           const portedPrngNextValue = portedPrngInstance();
 
-          expect(originalPrngNextValue).toEqual(portedPrngNextValue);
+          expect(originalPrngNextValue, `Failed on iteration ${i}`).toEqual(portedPrngNextValue);
         }
       });
 

src/prng-algorithms/__tests__/prng-algorithms.test.ts

@@ -1,4 +1,5 @@
 import type { AleaGeneratorState, GeneratorInterface, PRNGAlgorithm } from 'src/types';
+import { mash } from 'src/utils';
 
 class AleaGenerator implements GeneratorInterface<AleaGeneratorState> {
   c = 1;
@@ -7,37 +8,23 @@ class AleaGenerator implements GeneratorInterface<AleaGeneratorState> {
   s2;
 
   constructor(seed: string | number = Date.now()) {
-    let n = 0xefc8249d;
-
-    const mash = (seed: string): number => {
-      for (let i = 0; i < seed.length; i++) {
-        n += seed.charCodeAt(i);
-        let 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
-    };
+    const m = mash();
 
     const stringifiedSeed = seed.toString();
 
-    this.s0 = mash(' ');
-    this.s1 = mash(' ');
-    this.s2 = mash(' ');
+    this.s0 = m(' ');
+    this.s1 = m(' ');
+    this.s2 = m(' ');
 
-    this.s0 -= mash(stringifiedSeed);
+    this.s0 -= m(stringifiedSeed);
     if (this.s0 < 0) {
       this.s0 += 1;
     }
-    this.s1 -= mash(stringifiedSeed);
+    this.s1 -= m(stringifiedSeed);
     if (this.s1 < 0) {
       this.s1 += 1;
     }
-    this.s2 -= mash(stringifiedSeed);
+    this.s2 -= m(stringifiedSeed);
     if (this.s2 < 0) {
       this.s2 += 1;
     }

src/prng-algorithms/alea.ts

@@ -0,0 +1,71 @@
+import type { GeneratorInterface, PRNGAlgorithm, TycheiGeneratorState } from 'src/types';
+import { xorDouble } from 'src/utils';
+
+const createTycheiGenerator = (seed: string | number = Date.now()): GeneratorInterface<TycheiGeneratorState> => {
+  let a = 0;
+  let b = 0;
+  let c = 2654435769 | 0;
+  let d = 1367130551;
+
+  const next = (): number => {
+    b = (b << 25) ^ (b >>> 7) ^ c;
+    c = (c - d) | 0;
+    d = (d << 24) ^ (d >>> 8) ^ a;
+    a = (a - b) | 0;
+    b = (b << 20) ^ (b >>> 12) ^ c;
+    c = (c - d) | 0;
+    d = (d << 16) ^ (c >>> 16) ^ a;
+    a = (a - b) | 0;
+
+    return a;
+  };
+
+  const getState = (): TycheiGeneratorState => ({
+    a,
+    b,
+    c,
+    d,
+  });
+
+  const setState = (state: TycheiGeneratorState): void => {
+    a = state.a;
+    b = state.b;
+    c = state.c;
+    d = state.d;
+  };
+
+  if (Number.isInteger(seed)) {
+    const integerSeed = seed as number;
+    a = (integerSeed / 0x100000000) | 0;
+    b = integerSeed | 0;
+  }
+
+  const stringifiedSeed = seed.toString();
+
+  for (let k = 0; k < stringifiedSeed.length + 20; k++) {
+    b ^= stringifiedSeed.charCodeAt(k) | 0;
+    next();
+  }
+
+  return {
+    next,
+    state: getState,
+    setState,
+  };
+};
+
+export const tychei: PRNGAlgorithm<TycheiGeneratorState> = (seed, state) => {
+  const tycheiGenerator = createTycheiGenerator(seed);
+
+  const prng = () => (tycheiGenerator.next() >>> 0) / 0x100000000;
+  prng.quick = () => prng();
+  prng.double = () => xorDouble(tycheiGenerator);
+  prng.int32 = () => tycheiGenerator.next() | 0;
+  prng.state = () => tycheiGenerator.state();
+
+  if (typeof state !== 'undefined') {
+    tycheiGenerator.setState(state);
+  }
+
+  return prng;
+};