@cloudglides/nox 1.0.1

package/test/basic.js

@@ -0,0 +1,13 @@
+import { rng, deterministic, normal, exponential, shuffle } from '../src/index.js';
+
+const r = rng();
+console.log('Default:', r.int(1, 100), r.bool());
+
+const d = deterministic(42);
+console.log('Deterministic:', d.nextFloat());
+
+const arr = [1, 2, 3, 4, 5];
+console.log('Shuffle:', shuffle(arr, r));
+
+const r2 = rng();
+console.log('Distributions:', normal(r2), exponential(r2));

package/test/benchmark.js

@@ -0,0 +1,35 @@
+import { Xorshift64, Logistic, Tent, Splitmix64, PCG64, MT19937 } from '../src/index.js';
+import { chiSquareTest, entropy, autocorrelation, runTest } from '../src/utils/statistics.js';
+
+const SAMPLES = 10000;
+
+const benchmarkGenerator = (name, GeneratorClass, seed) => {
+  console.log(`\n=== ${name} ===`);
+  
+  const rng = new GeneratorClass(seed);
+  const data = [];
+  
+  const start = performance.now();
+  for (let i = 0; i < SAMPLES; i++) {
+    data.push(rng.nextFloat());
+  }
+  const elapsed = performance.now() - start;
+  
+  const { chi2, histogram } = chiSquareTest(data, 20);
+  const ent = entropy(data, 20);
+  const autocorr = autocorrelation(data, 1);
+  const runs = runTest(data);
+  
+  console.log(`Time: ${elapsed.toFixed(2)}ms (${(SAMPLES/elapsed*1000).toFixed(0)} ops/sec)`);
+  console.log(`Chi2: ${chi2.toFixed(2)} (good: <31.4)`);
+  console.log(`Entropy: ${ent.toFixed(4)} (max: ~${Math.log2(20).toFixed(4)})`);
+  console.log(`Autocorr(lag=1): ${autocorr.toFixed(6)} (good: close to 0)`);
+  console.log(`Runs: ${runs} (expect ~${Math.ceil(SAMPLES/2)})`);
+};
+
+benchmarkGenerator('Xorshift64', Xorshift64, 42);
+benchmarkGenerator('Splitmix64', Splitmix64, 42);
+benchmarkGenerator('PCG64', PCG64, 42);
+benchmarkGenerator('MT19937', MT19937, 42);
+benchmarkGenerator('Logistic', Logistic, 0.5);
+benchmarkGenerator('Tent', Tent, 0.5);

package/test/comprehensive.js

@@ -0,0 +1,100 @@
+import { 
+  rng, 
+  deterministic,
+  RNG,
+  PCG64,
+  normal,
+  exponential,
+  shuffle,
+  pick,
+  sample,
+  saveState,
+  restoreState,
+  cloneGenerator,
+  weightedPick,
+  reservoirSample,
+  meanTest,
+  varianceTest,
+  kolmogorovSmirnovTest
+} from '../src/index.js';
+
+console.log('=== Comprehensive nox Test Suite ===\n');
+
+console.log('1. Core RNG Methods');
+const r = rng();
+console.log(`  nextFloat(): ${r.nextFloat().toFixed(6)}`);
+console.log(`  nextInt(100): ${r.nextInt(100)}`);
+console.log(`  int(1, 100): ${r.int(1, 100)}`);
+console.log(`  bool(0.7): ${r.bool(0.7)}`);
+
+console.log('\n2. Utility Methods');
+console.log(`  range(5, 15, 3): ${r.range(5, 15, 3)}`);
+console.log(`  choice(['red', 'blue', 'green']): ${r.choice(['red', 'blue', 'green'])}`);
+
+console.log('\n3. Batch Operations');
+const floats = r.floats(3).map(x => x.toFixed(6));
+console.log(`  floats(3): [${floats.join(', ')}]`);
+const ints = r.ints(3, 10);
+console.log(`  ints(3, 10): [${ints.join(', ')}]`);
+const bools = r.bools(3, 0.5);
+console.log(`  bools(3): [${bools.join(', ')}]`);
+
+console.log('\n4. Sequence Operations');
+const arr = [1, 2, 3, 4, 5];
+console.log(`  shuffle(${JSON.stringify(arr)}): ${JSON.stringify(shuffle([...arr], r))}`);
+console.log(`  pick(['a','b','c']): ${pick(['a','b','c'], r)}`);
+console.log(`  sample([1,2,3,4,5], 3): ${JSON.stringify(sample([...arr], 3, r))}`);
+
+console.log('\n5. Statistical Distributions');
+const r2 = rng();
+console.log(`  normal(0, 1): ${normal(r2).toFixed(6)}`);
+console.log(`  exponential(1): ${exponential(r2).toFixed(6)}`);
+
+console.log('\n6. State Management');
+const r3 = rng();
+const val1 = r3.nextFloat();
+const state = saveState(r3);
+const val2 = r3.nextFloat();
+restoreState(r3, state);
+const val2_restored = r3.nextFloat();
+console.log(`  State restored correctly: ${val2 === val2_restored}`);
+
+console.log('\n7. Generator Cloning');
+const orig = deterministic(12345);
+const origSeq = orig.floats(3);
+const cloned = cloneGenerator(orig);
+const clonedSeq = cloned.floats(3);
+console.log(`  Clone has same sequence: ${JSON.stringify(origSeq) === JSON.stringify(clonedSeq)}`);
+
+console.log('\n8. Weighted Sampling');
+const items = ['A', 'B', 'C'];
+const weights = [0.6, 0.3, 0.1];
+console.log(`  weightedPick(['A','B','C'], [0.6,0.3,0.1]): ${weightedPick(items, weights, rng())}`);
+
+console.log('\n9. Reservoir Sampling');
+const largeStream = Array.from({length: 1000}, (_, i) => i);
+const sample5 = reservoirSample(largeStream, 5, rng());
+console.log(`  reservoirSample(0..999, k=5): [${sample5.join(', ')}]`);
+
+console.log('\n10. Statistical Tests');
+const testData = rng().floats(500);
+const meanRes = meanTest(testData);
+const varRes = varianceTest(testData);
+const ksRes = kolmogorovSmirnovTest(testData);
+console.log(`  Mean: ${meanRes.mean.toFixed(6)} (expected: 0.5)`);
+console.log(`  Variance: ${varRes.variance.toFixed(6)} (expected: 0.083333)`);
+console.log(`  KS Test passes (α=0.05): ${ksRes.pass_0_05}`);
+
+console.log('\n11. Deterministic Mode');
+const d1 = deterministic(42);
+const seq1 = d1.ints(5, 100);
+const d2 = deterministic(42);
+const seq2 = d2.ints(5, 100);
+console.log(`  Sequences identical: ${JSON.stringify(seq1) === JSON.stringify(seq2)}`);
+console.log(`  Sequence: ${JSON.stringify(seq1)}`);
+
+console.log('\n12. Custom Generators');
+const custom = new RNG(PCG64, 999n);
+console.log(`  Custom PCG64 RNG initialized: ${custom.nextFloat().toFixed(6)}`);
+
+console.log('\n✓ All tests completed successfully');

package/test/profile.js

@@ -0,0 +1,73 @@
+import { rng, quality, MT19937, Xorshift64, Splitmix64, PCG64 } from '../src/index.js';
+
+const ITERATIONS = 100000;
+
+const profile = (name, fn) => {
+  const start = performance.now();
+  fn();
+  const elapsed = performance.now() - start;
+  const opsPerSec = (ITERATIONS / elapsed * 1000).toFixed(0);
+  console.log(`${name}: ${elapsed.toFixed(2)}ms (${opsPerSec} ops/sec)`);
+};
+
+console.log(`\n=== Generating ${ITERATIONS} values ===\n`);
+
+profile('RNG.nextFloat()', () => {
+  const r = rng();
+  for (let i = 0; i < ITERATIONS; i++) r.nextFloat();
+});
+
+profile('RNG.nextInt()', () => {
+  const r = rng();
+  for (let i = 0; i < ITERATIONS; i++) r.nextInt(100);
+});
+
+profile('RNG.int(1,100)', () => {
+  const r = rng();
+  for (let i = 0; i < ITERATIONS; i++) r.int(1, 100);
+});
+
+profile('RNG.bool()', () => {
+  const r = rng();
+  for (let i = 0; i < ITERATIONS; i++) r.bool();
+});
+
+console.log('\n=== Generator comparison (nextFloat) ===\n');
+
+profile('Xorshift64', () => {
+  const r = new Xorshift64(42);
+  for (let i = 0; i < ITERATIONS; i++) r.nextFloat();
+});
+
+profile('Splitmix64', () => {
+  const r = new Splitmix64(42);
+  for (let i = 0; i < ITERATIONS; i++) r.nextFloat();
+});
+
+profile('PCG64', () => {
+  const r = new PCG64(42n);
+  for (let i = 0; i < ITERATIONS; i++) r.nextFloat();
+});
+
+profile('MT19937', () => {
+  const r = new MT19937(42);
+  for (let i = 0; i < ITERATIONS; i++) r.nextFloat();
+});
+
+console.log('\n=== Batch operations ===\n');
+
+profile('floats(100) x1000', () => {
+  const r = rng();
+  for (let i = 0; i < 1000; i++) r.floats(100);
+});
+
+profile('ints(100, 100) x1000', () => {
+  const r = rng();
+  for (let i = 0; i < 1000; i++) r.ints(100, 100);
+});
+
+profile('shuffle([1..10]) x10000', () => {
+  const r = rng();
+  const arr = Array.from({ length: 10 }, (_, i) => i);
+  for (let i = 0; i < 10000; i++) r.shuffle(arr);
+});