@cloudglides/nox 1.0.1

package/src/utils/entropy.js

@@ -0,0 +1,95 @@
+let cryptoCache = null;
+let cryptoCacheTime = 0;
+
+const isNode = typeof process !== 'undefined' && process.versions && process.versions.node;
+const isBrowser = typeof window !== 'undefined';
+
+let performanceImpl = typeof performance !== 'undefined' ? performance : null;
+let randomBytesImpl = null;
+
+if (isNode && typeof require !== 'undefined') {
+  try {
+    const perf_hooks = require('perf_hooks');
+    performanceImpl = perf_hooks.performance;
+  } catch {}
+  
+  try {
+    const crypto_mod = require('crypto');
+    randomBytesImpl = crypto_mod.randomBytes;
+  } catch {}
+}
+
+export const fromPerformance = () => {
+  try {
+    if (performanceImpl && performanceImpl.now) {
+      const t = performanceImpl.now();
+      return BigInt(Math.floor(t * 1000)) ^ BigInt(Math.floor(t * 1000000) % 1000000);
+    }
+  } catch {
+    // fallback
+  }
+  return BigInt(Date.now());
+};
+
+export const fromMemory = () => {
+  try {
+    if (isNode && typeof process !== 'undefined' && process.memoryUsage) {
+      const mem = process.memoryUsage();
+      const total = mem.heapUsed + mem.external + mem.heapTotal;
+      return BigInt(Math.floor(total)) ^ BigInt(Date.now());
+    }
+  } catch {
+    // fallback
+  }
+  return BigInt(Date.now());
+};
+
+export const fromCrypto = (bytes = 8) => {
+  try {
+    const now = Date.now();
+    
+    if (cryptoCache && (now - cryptoCacheTime) < 100) {
+      return cryptoCache;
+    }
+    
+    let val = 0n;
+    
+    if (randomBytesImpl) {
+      const buf = randomBytesImpl(Math.max(bytes, 8));
+      for (let i = 0; i < buf.length; i++) {
+        val = (val << 8n) | BigInt(buf[i]);
+      }
+    } else if (isBrowser && typeof crypto !== 'undefined' && crypto.getRandomValues) {
+      const arr = new Uint8Array(Math.max(bytes, 8));
+      crypto.getRandomValues(arr);
+      for (let i = 0; i < arr.length; i++) {
+        val = (val << 8n) | BigInt(arr[i]);
+      }
+    } else {
+      return BigInt(Math.random() * Number.MAX_SAFE_INTEGER);
+    }
+    
+    cryptoCache = val;
+    cryptoCacheTime = now;
+    return val;
+  } catch {
+    return BigInt(Math.random() * Number.MAX_SAFE_INTEGER);
+  }
+};
+
+export const combined = () => {
+  const perf = fromPerformance();
+  const mem = fromMemory();
+  const crypto = fromCrypto();
+  
+  let mix = perf ^ mem ^ crypto;
+  mix = mix ^ (mix >> 33n);
+  mix = (mix * 0xff51afd7ed558ccdn) & ((1n << 64n) - 1n);
+  
+  return mix !== 0n ? mix : 1n;
+};
+
+export const clearCryptoCache = () => {
+  cryptoCache = null;
+  cryptoCacheTime = 0;
+};

package/src/utils/index.js

@@ -0,0 +1,30 @@
+export { seedFromTime, seedFromEntropy } from './seed.js';
+export { normal, exponential, poisson, uniform } from './distributions.js';
+export { beta, gamma, chi2 } from './distributions-extra.js';
+export { weibull, lognormal, rayleigh, cauchy } from './distributions-special.js';
+export { shuffle, pick, sample } from './sequence.js';
+export { fromPerformance, fromMemory, fromCrypto, combined, clearCryptoCache } from './entropy.js';
+export { rotateBits, extractBits, hammingWeight, bitRange } from './bits.js';
+export { brownianMotion, ornsteinUhlenbeck, geometricBrownian } from './stochastic.js';
+export { chiSquareTest, entropy, autocorrelation, runTest, kolmogorovSmirnovTest, meanTest, varianceTest } from './statistics.js';
+export { perlin2D, valueNoise } from './noise.js';
+export { weightedPick, weightedSample, reservoirSample } from './sampling.js';
+export { saveState, restoreState, cloneGenerator } from './state.js';
+export { SeedSequence, seedMultiple } from './seeding.js';
+export { combinations, permutations, kPermutations, randomCombination, randomPermutation } from './combinatorics.js';
+export { categorical, multinomial, categorical2D } from './categorical.js';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

package/src/utils/noise.js

@@ -0,0 +1,81 @@
+const permutation = [151,160,137,91,90,15,131,13,201,95,96,53,194,233,7,225,
+140,36,103,30,69,142,8,99,37,240,21,10,23,190,6,148,
+247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,
+57,177,33,88,237,149,56,87,174,20,125,136,171,168,68,175,
+74,165,71,134,139,48,27,166,77,146,158,231,83,111,229,122,
+60,211,133,230,206,39,323,234,35,158,234,144,12,234,165,
+35,38,112,106,43,23,147,126,65,189,235,64,211,205,230,108,
+248,191,227,21,205,45,94,2,32,284,239,210,246,24,97,78,
+101,40,71,224,255,326,167,21,213,2,223,166,205,57,130,180,
+51,108,203,190,57,74,76,88,207,208,239,170,251,67,77,51,
+133,69,249,2,127,80,60,159,168,81,163,64,143,146,157,41,
+244,8,51,153,78,130,83,142,46,168,134,55,63,160,166,56,
+172,85,24,254,192,221,100,495,32,163,244,236,37,46,28,141,
+149,34,69,193,70,199,154,159,147,12,130,199,10,154,27,112];
+
+const fade = (t) => t * t * t * (t * (t * 6 - 15) + 10);
+const lerp = (t, a, b) => a + t * (b - a);
+const grad = (hash, x, y) => {
+  const h = hash & 15;
+  const u = h < 8 ? x : y;
+  const v = h < 8 ? y : x;
+  return ((h & 1) === 0 ? u : -u) + ((h & 2) === 0 ? v : -v);
+};
+
+export const perlin2D = (rng, x, y, octaves = 1) => {
+  let value = 0;
+  let amplitude = 1;
+  let frequency = 1;
+  let maxValue = 0;
+
+  for (let i = 0; i < octaves; i++) {
+    const xi = Math.floor((x * frequency) % 256);
+    const yi = Math.floor((y * frequency) % 256);
+
+    const xf = (x * frequency) - Math.floor(x * frequency);
+    const yf = (y * frequency) - Math.floor(y * frequency);
+
+    const u = fade(xf);
+    const v = fade(yf);
+
+    const p0 = permutation[xi];
+    const p1 = permutation[(xi + 1) & 255];
+
+    const g00 = grad(permutation[(p0 + yi) & 255], xf, yf);
+    const g10 = grad(permutation[(p1 + yi) & 255], xf - 1, yf);
+    const g01 = grad(permutation[(p0 + yi + 1) & 255], xf, yf - 1);
+    const g11 = grad(permutation[(p1 + yi + 1) & 255], xf - 1, yf - 1);
+
+    const nx0 = lerp(u, g00, g10);
+    const nx1 = lerp(u, g01, g11);
+    const nxy = lerp(v, nx0, nx1);
+
+    value += nxy * amplitude;
+    maxValue += amplitude;
+    amplitude *= 0.5;
+    frequency *= 2;
+  }
+
+  return value / maxValue;
+};
+
+export const valueNoise = (rng, x, y, scale = 1) => {
+  const sx = Math.floor(x * scale);
+  const sy = Math.floor(y * scale);
+
+  const n00 = Math.sin(sx * 12.9898 + sy * 78.233) * 43758.5453;
+  const n10 = Math.sin((sx + 1) * 12.9898 + sy * 78.233) * 43758.5453;
+  const n01 = Math.sin(sx * 12.9898 + (sy + 1) * 78.233) * 43758.5453;
+  const n11 = Math.sin((sx + 1) * 12.9898 + (sy + 1) * 78.233) * 43758.5453;
+
+  const fx = x * scale - sx;
+  const fy = y * scale - sy;
+
+  const u = fade(fx);
+  const v = fade(fy);
+
+  const nx0 = lerp(u, n00 - Math.floor(n00), n10 - Math.floor(n10));
+  const nx1 = lerp(u, n01 - Math.floor(n01), n11 - Math.floor(n11));
+
+  return lerp(v, nx0, nx1);
+};

package/src/utils/sampling.js

@@ -0,0 +1,106 @@
+export const weightedPick = (arr, weights, rng) => {
+  if (!Array.isArray(arr) || arr.length === 0) {
+    throw new TypeError('arr must be a non-empty array');
+  }
+  if (!Array.isArray(weights) || weights.length === 0) {
+    throw new TypeError('weights must be a non-empty array');
+  }
+  if (arr.length !== weights.length) {
+    throw new Error('arr and weights must have same length');
+  }
+  if (!rng || typeof rng.nextFloat !== 'function') {
+    throw new TypeError('rng must be an RNG instance');
+  }
+  
+  const total = weights.reduce((a, b) => {
+    if (typeof a !== 'number' || typeof b !== 'number') {
+      throw new TypeError('All weights must be numbers');
+    }
+    return a + b;
+  }, 0);
+  
+  if (total <= 0) {
+    throw new Error('Weights must sum to positive value');
+  }
+  
+  let rand = rng.nextFloat() * total;
+  
+  for (let i = 0; i < arr.length; i++) {
+    rand -= weights[i];
+    if (rand <= 0) return arr[i];
+  }
+  
+  return arr[arr.length - 1];
+};
+
+export const weightedSample = (arr, weights, count, rng) => {
+  if (!Array.isArray(arr) || arr.length === 0) {
+    throw new TypeError('arr must be a non-empty array');
+  }
+  if (!Array.isArray(weights) || weights.length === 0) {
+    throw new TypeError('weights must be a non-empty array');
+  }
+  if (arr.length !== weights.length) {
+    throw new Error('arr and weights must have same length');
+  }
+  if (typeof count !== 'number' || !Number.isInteger(count)) {
+    throw new TypeError('count must be an integer');
+  }
+  if (count < 0) {
+    throw new RangeError('count must be non-negative');
+  }
+  if (!rng || typeof rng.nextFloat !== 'function') {
+    throw new TypeError('rng must be an RNG instance');
+  }
+  
+  const result = [];
+  const remaining = [...arr];
+  const remainingWeights = [...weights];
+  
+  for (let i = 0; i < count && remaining.length > 0; i++) {
+    const idx = weightedPickIndex(remainingWeights, rng);
+    result.push(remaining[idx]);
+    remaining.splice(idx, 1);
+    remainingWeights.splice(idx, 1);
+  }
+  
+  return result;
+};
+
+const weightedPickIndex = (weights, rng) => {
+  const total = weights.reduce((a, b) => a + b, 0);
+  let rand = rng.nextFloat() * total;
+  
+  for (let i = 0; i < weights.length; i++) {
+    rand -= weights[i];
+    if (rand <= 0) return i;
+  }
+  
+  return weights.length - 1;
+};
+
+export const reservoirSample = (stream, k, rng) => {
+  if (!Array.isArray(stream) || stream.length === 0) {
+    throw new TypeError('stream must be a non-empty array');
+  }
+  if (typeof k !== 'number' || !Number.isInteger(k)) {
+    throw new TypeError('k must be an integer');
+  }
+  if (k <= 0) {
+    throw new RangeError('k must be positive');
+  }
+  if (!rng || typeof rng.nextInt !== 'function') {
+    throw new TypeError('rng must be an RNG instance');
+  }
+  
+  const reservoir = stream.slice(0, Math.min(k, stream.length));
+  
+  for (let i = k; i < stream.length; i++) {
+    const j = rng.nextInt(i + 1);
+    if (j < k) {
+      reservoir[j] = stream[i];
+    }
+  }
+  
+  return reservoir;
+};

package/src/utils/seed.js

@@ -0,0 +1,14 @@
+export const seedFromTime = () => {
+  return BigInt(Date.now() + Math.random() * 1000000);
+};
+
+export const seedFromEntropy = (entropy) => {
+  if (typeof entropy !== 'string') throw new TypeError('Entropy must be string');
+  if (entropy.length === 0) throw new Error('Entropy cannot be empty');
+  
+  let hash = 5381n;
+  for (let i = 0; i < entropy.length; i++) {
+    hash = ((hash << 5n) + hash) ^ BigInt(entropy.charCodeAt(i));
+  }
+  return hash % (1n << 32n);
+};

package/src/utils/seeding.js

@@ -0,0 +1,37 @@
+import { seedFromTime, seedFromEntropy } from './seed.js';
+import { fromPerformance, fromMemory, fromCrypto, combined } from './entropy.js';
+
+export class SeedSequence {
+  constructor(entropy = null) {
+    if (entropy === null) {
+      this.seed = combined();
+    } else if (typeof entropy === 'string') {
+      this.seed = seedFromEntropy(entropy);
+    } else if (typeof entropy === 'bigint' || typeof entropy === 'number') {
+      this.seed = BigInt(entropy);
+    } else {
+      this.seed = entropy;
+    }
+    this.counter = 0n;
+  }
+
+  next() {
+    const val = this.seed ^ BigInt(this.counter);
+    this.counter += 1n;
+    return val;
+  }
+
+  spawn(n = 1) {
+    const seeds = [];
+    for (let i = 0; i < n; i++) {
+      seeds.push(this.next());
+    }
+    return seeds;
+  }
+}
+
+export const seedMultiple = (rngClasses, entropy = null) => {
+  const seq = new SeedSequence(entropy);
+  const seeds = seq.spawn(rngClasses.length);
+  return rngClasses.map((RngClass, i) => new RngClass(seeds[i]));
+};

package/src/utils/sequence.js

@@ -0,0 +1,53 @@
+export const shuffle = (arr, rng, inPlace = false) => {
+  if (!Array.isArray(arr)) {
+    throw new TypeError('First argument must be array');
+  }
+  if (!rng || typeof rng.nextInt !== 'function') {
+    throw new TypeError('RNG instance required');
+  }
+  if (typeof inPlace !== 'boolean') {
+    throw new TypeError('inPlace must be boolean');
+  }
+  
+  const target = inPlace ? arr : [...arr];
+  for (let i = target.length - 1; i > 0; i--) {
+    const j = rng.nextInt(i + 1);
+    [target[i], target[j]] = [target[j], target[i]];
+  }
+  return target;
+};
+
+export const pick = (arr, rng) => {
+  if (!Array.isArray(arr)) {
+    throw new TypeError('First argument must be array');
+  }
+  if (arr.length === 0) {
+    throw new Error('Array cannot be empty');
+  }
+  if (!rng || typeof rng.nextInt !== 'function') {
+    throw new TypeError('RNG instance required');
+  }
+  
+  return arr[rng.nextInt(arr.length)];
+};
+
+export const sample = (arr, count, rng) => {
+  if (!Array.isArray(arr)) {
+    throw new TypeError('First argument must be array');
+  }
+  if (typeof count !== 'number' || !Number.isInteger(count)) {
+    throw new TypeError('Sample count must be an integer');
+  }
+  if (count <= 0) {
+    throw new Error('Sample count must be positive');
+  }
+  if (count > arr.length) {
+    throw new Error('Sample count exceeds array length');
+  }
+  if (!rng || typeof rng.nextInt !== 'function') {
+    throw new TypeError('RNG instance required');
+  }
+  
+  const copy = shuffle(arr, rng);
+  return copy.slice(0, count);
+};

package/src/utils/state.js

@@ -0,0 +1,39 @@
+export const saveState = (rng) => {
+  const gen = rng.gen || rng;
+  if (gen.state === undefined) {
+    throw new Error('Generator does not support state snapshots');
+  }
+  return { state: gen.state };
+};
+
+export const restoreState = (rng, snapshot) => {
+  const gen = rng.gen || rng;
+  if (gen.state === undefined) {
+    throw new Error('Generator does not support state snapshots');
+  }
+  gen.state = snapshot.state;
+};
+
+export const cloneGenerator = (rng) => {
+  const isRNGWrapper = rng.gen !== undefined;
+  const gen = isRNGWrapper ? rng.gen : rng;
+  const Constructor = gen.constructor;
+  
+  let clonedGen;
+  
+  if (Constructor.name === 'PCG64') {
+    clonedGen = new Constructor(gen.state, gen.inc);
+  } else if (Constructor.name === 'Logistic') {
+    clonedGen = new Constructor(gen.x, gen.r);
+  } else if (Constructor.name === 'Tent') {
+    clonedGen = new Constructor(gen.x, gen.mu);
+  } else if (Constructor.name === 'Mixer') {
+    const rng1Clone = cloneGenerator(gen.rng1);
+    const rng2Clone = cloneGenerator(gen.rng2);
+    clonedGen = new Constructor(rng1Clone, rng2Clone);
+  } else {
+    clonedGen = new Constructor(gen.state);
+  }
+  
+  return isRNGWrapper ? new (rng.constructor)(Constructor, gen.state) : clonedGen;
+};

package/src/utils/statistics.js

@@ -0,0 +1,127 @@
+export const chiSquareTest = (data, bins = 10) => {
+  const histogram = new Array(bins).fill(0);
+  for (const val of data) {
+    const idx = Math.floor(val * bins);
+    histogram[Math.min(idx, bins - 1)]++;
+  }
+  
+  const expected = data.length / bins;
+  let chi2 = 0;
+  for (const count of histogram) {
+    chi2 += ((count - expected) ** 2) / expected;
+  }
+  
+  return { chi2, expected, histogram };
+};
+
+export const entropy = (data, bins = 10) => {
+  const histogram = new Array(bins).fill(0);
+  for (const val of data) {
+    const idx = Math.floor(val * bins);
+    histogram[Math.min(idx, bins - 1)]++;
+  }
+  
+  let ent = 0;
+  const p = 1 / data.length;
+  for (const count of histogram) {
+    if (count > 0) {
+      const pi = count / data.length;
+      ent -= pi * Math.log2(pi);
+    }
+  }
+  return ent;
+};
+
+export const autocorrelation = (data, lag) => {
+  if (lag < 0 || lag >= data.length) throw new Error('Lag out of range');
+  if (data.length < 2) throw new Error('Need at least 2 data points');
+  
+  const mean = data.reduce((a, b) => a + b, 0) / data.length;
+  let c0 = 0;
+  let cl = 0;
+  
+  for (let i = 0; i < data.length; i++) {
+    c0 += (data[i] - mean) ** 2;
+  }
+  
+  if (c0 === 0) return 0;
+  
+  for (let i = 0; i < data.length - lag; i++) {
+    cl += (data[i] - mean) * (data[i + lag] - mean);
+  }
+  
+  return cl / c0;
+};
+
+export const runTest = (data, threshold = 0.5) => {
+  const binary = data.map(v => v > threshold ? 1 : 0);
+  let runs = 1;
+  for (let i = 1; i < binary.length; i++) {
+    if (binary[i] !== binary[i - 1]) runs++;
+  }
+  return runs;
+};
+
+export const kolmogorovSmirnovTest = (data) => {
+  if (!Array.isArray(data) || data.length === 0) {
+    throw new Error('Data must be non-empty array');
+  }
+  
+  const sorted = [...data].sort((a, b) => a - b);
+  let maxD = 0;
+  
+  for (let i = 0; i < sorted.length; i++) {
+    const empirical = (i + 1) / sorted.length;
+    const theoretical = sorted[i];
+    maxD = Math.max(maxD, Math.abs(empirical - theoretical));
+  }
+  
+  const criticalValues = {
+    0.10: 1.224 / Math.sqrt(data.length),
+    0.05: 1.358 / Math.sqrt(data.length),
+    0.01: 1.627 / Math.sqrt(data.length)
+  };
+  
+  return {
+    statistic: maxD,
+    pass_0_10: maxD < criticalValues[0.10],
+    pass_0_05: maxD < criticalValues[0.05],
+    pass_0_01: maxD < criticalValues[0.01]
+  };
+};
+
+export const meanTest = (data, expectedMean = 0.5) => {
+  if (!Array.isArray(data) || data.length === 0) {
+    throw new Error('Data must be non-empty array');
+  }
+  
+  const mean = data.reduce((a, b) => a + b, 0) / data.length;
+  const variance = data.reduce((a, v) => a + (v - mean) ** 2, 0) / data.length;
+  const stdDev = Math.sqrt(variance);
+  const tStat = (mean - expectedMean) / (stdDev / Math.sqrt(data.length));
+  
+  return {
+    mean,
+    variance,
+    stdDev,
+    tStatistic: tStat,
+    expectedMean
+  };
+};
+
+export const varianceTest = (data, expectedVariance = 1 / 12) => {
+  if (!Array.isArray(data) || data.length === 0) {
+    throw new Error('Data must be non-empty array');
+  }
+  
+  const mean = data.reduce((a, b) => a + b, 0) / data.length;
+  const variance = data.reduce((a, v) => a + (v - mean) ** 2, 0) / data.length;
+  const chi2 = (data.length - 1) * variance / expectedVariance;
+  
+  return {
+    variance,
+    expectedVariance,
+    chi2Statistic: chi2,
+    degreesOfFreedom: data.length - 1
+  };
+};

package/src/utils/stochastic.js

@@ -0,0 +1,32 @@
+export const brownianMotion = (rng, steps, dt = 1) => {
+  const path = [0];
+  for (let i = 0; i < steps; i++) {
+    const drift = -0.5 * dt;
+    const diffusion = Math.sqrt(dt) * (rng.nextFloat() * 2 - 1);
+    const nextVal = path[i] + drift + diffusion;
+    path.push(nextVal);
+  }
+  return path;
+};
+
+export const ornsteinUhlenbeck = (rng, steps, theta = 0.1, mu = 0, sigma = 1) => {
+  const path = [mu];
+  for (let i = 0; i < steps; i++) {
+    const drift = theta * (mu - path[i]);
+    const diffusion = sigma * (rng.nextFloat() * 2 - 1);
+    const nextVal = path[i] + drift + diffusion;
+    path.push(nextVal);
+  }
+  return path;
+};
+
+export const geometricBrownian = (rng, steps, mu = 0.05, sigma = 0.2, dt = 0.01) => {
+  const path = [1];
+  for (let i = 0; i < steps; i++) {
+    const drift = (mu - 0.5 * sigma * sigma) * dt;
+    const diffusion = sigma * Math.sqrt(dt) * (rng.nextFloat() * 2 - 1);
+    const nextVal = path[i] * Math.exp(drift + diffusion);
+    path.push(nextVal);
+  }
+  return path;
+};

package/test/advanced.js

@@ -0,0 +1,71 @@
+import { rng, deterministic } from '../src/index.js';
+import { 
+  weightedPick, 
+  reservoirSample,
+  meanTest,
+  varianceTest,
+  kolmogorovSmirnovTest
+} from '../src/index.js';
+
+console.log('=== Batch Operations ===');
+const r = rng();
+
+const floats = r.floats(5);
+console.log('Batch floats:', floats);
+
+const ints = r.ints(5, 100);
+console.log('Batch ints:', ints);
+
+const bools = r.bools(5, 0.3);
+console.log('Batch bools:', bools);
+
+const custom = r.batch(3, (rng, i) => ({ id: i, val: rng.nextFloat() }));
+console.log('Custom batch:', custom);
+
+console.log('\n=== Utility Methods ===');
+console.log('Range (10-20, step 2):', r.range(10, 20, 2));
+console.log('Choice:', r.choice(['apple', 'banana', 'cherry']));
+
+console.log('\n=== Weighted Sampling ===');
+const items = ['A', 'B', 'C'];
+const weights = [0.5, 0.3, 0.2];
+console.log('Weighted pick:', weightedPick(items, weights, r));
+
+console.log('\n=== Reservoir Sampling ===');
+const stream = Array.from({ length: 100 }, (_, i) => i);
+const sample = reservoirSample(stream, 5, r);
+console.log('Reservoir sample:', sample);
+
+console.log('\n=== Statistical Tests ===');
+const testData = r.floats(1000);
+
+const mean = meanTest(testData);
+console.log('Mean test:', {
+  computed: mean.mean.toFixed(4),
+  expected: mean.expectedMean.toFixed(4),
+  tStat: mean.tStatistic.toFixed(4)
+});
+
+const variance = varianceTest(testData);
+console.log('Variance test:', {
+  computed: variance.variance.toFixed(6),
+  expected: variance.expectedVariance.toFixed(6),
+  chi2: variance.chi2Statistic.toFixed(4)
+});
+
+const ks = kolmogorovSmirnovTest(testData);
+console.log('KS test:', {
+  statistic: ks.statistic.toFixed(6),
+  pass_0_05: ks.pass_0_05
+});
+
+console.log('\n=== Deterministic Reproducibility ===');
+const d1 = deterministic(12345);
+const seq1 = d1.floats(5);
+
+const d2 = deterministic(12345);
+const seq2 = d2.floats(5);
+
+console.log('Sequence 1:', seq1);
+console.log('Sequence 2:', seq2);
+console.log('Identical:', JSON.stringify(seq1) === JSON.stringify(seq2));