@cloudglides/nox 1.1.5 → 2.0.0

package/test/comprehensive-new.js

@@ -0,0 +1,126 @@
+import { rng, deterministic, normal, exponential, poisson, uniform } from '../src/index.js';
+import { shuffle, pick, sample } from '../src/index.js';
+import { PCG64, Xorshift64, Splitmix64, MT19937 } from '../src/index.js';
+
+const assert = (condition, msg) => {
+  if (!condition) {
+    throw new Error(`✗ ${msg}`);
+  }
+  console.log(`✓ ${msg}`);
+};
+
+console.log('\n=== BASIC OPERATIONS ===');
+const r = rng();
+assert(typeof r.nextFloat() === 'number', 'nextFloat returns number');
+assert(r.nextFloat() >= 0 && r.nextFloat() <= 1, 'nextFloat in [0,1]');
+assert(typeof r.nextInt(100) === 'number', 'nextInt returns number');
+assert(r.int(1, 10) >= 1 && r.int(1, 10) <= 10, 'int in range');
+assert(typeof r.bool() === 'boolean', 'bool returns boolean');
+
+console.log('\n=== DETERMINISTIC ===');
+const d1 = deterministic(12345);
+const d2 = deterministic(12345);
+const seq1 = d1.floats(100);
+const seq2 = d2.floats(100);
+assert(seq1.length === 100, 'deterministic generates correct count');
+assert(JSON.stringify(seq1) === JSON.stringify(seq2), 'same seed produces same sequence');
+
+console.log('\n=== GENERATORS ===');
+const gens = [
+  { name: 'PCG64', Gen: PCG64 },
+  { name: 'Xorshift64', Gen: Xorshift64 },
+  { name: 'Splitmix64', Gen: Splitmix64 },
+  { name: 'MT19937', Gen: MT19937 }
+];
+
+for (const {name, Gen} of gens) {
+  const g = new Gen(42);
+  const vals = Array.from({length: 1000}, () => g.nextFloat());
+  const mean = vals.reduce((a, b) => a + b) / 1000;
+  assert(mean > 0.3 && mean < 0.7, `${name} mean ${mean.toFixed(3)} reasonable`);
+  assert(vals.every(v => v >= 0 && v <= 1), `${name} values in [0,1]`);
+}
+
+console.log('\n=== DISTRIBUTIONS ===');
+const r2 = rng();
+const normal5 = Array.from({length: 1000}, () => normal(r2));
+assert(normal5.length === 1000, 'normal generates correct count');
+const hasNegative = normal5.some(v => v < 0);
+const hasPositive = normal5.some(v => v > 0);
+assert(hasNegative && hasPositive, 'normal has both positive and negative values');
+
+const exp5 = Array.from({length: 100}, () => exponential(r2));
+assert(exp5.every(v => v >= 0), 'exponential all positive');
+
+const poi = Array.from({length: 100}, () => poisson(r2, 5));
+assert(poi.every(v => Number.isInteger(v) && v >= 0), 'poisson returns non-negative integers');
+
+const uni = uniform(r2, 10, 20);
+assert(uni >= 10 && uni <= 20, 'uniform in range');
+
+console.log('\n=== ARRAY OPERATIONS ===');
+const r3 = rng();
+const arr = [1,2,3,4,5];
+const shuffled = shuffle(arr, r3);
+assert(shuffled.length === 5, 'shuffle preserves length');
+assert(shuffled.some((v, i) => v !== arr[i]), 'shuffle actually shuffles');
+
+const picked = pick(arr, r3);
+assert(arr.includes(picked), 'pick returns array element');
+
+const sampled = sample(arr, 3, r3);
+assert(sampled.length === 3, 'sample returns correct count');
+assert(sampled.every(v => arr.includes(v)), 'sample contains array elements');
+
+console.log('\n=== BATCH OPERATIONS ===');
+const r4 = rng();
+const floats = r4.floats(100);
+assert(floats.length === 100, 'floats correct length');
+assert(floats.every(v => typeof v === 'number'), 'floats all numbers');
+
+const ints = r4.ints(50, 100);
+assert(ints.length === 50, 'ints correct length');
+assert(ints.every(v => v >= 0 && v < 100), 'ints in range');
+
+const bools = r4.bools(50);
+assert(bools.length === 50, 'bools correct length');
+assert(bools.every(v => typeof v === 'boolean'), 'bools all booleans');
+
+console.log('\n=== EDGE CASES ===');
+const r5 = rng();
+try {
+  r5.int(1, 1);
+  assert(r5.int(1, 1) === 1, 'int(1,1) returns 1');
+} catch (e) {
+  assert(false, 'int(1,1) should not throw');
+}
+
+try {
+  shuffle([], r5);
+  assert(true, 'shuffle([]) doesnt crash');
+} catch (e) {
+  assert(false, 'shuffle([]) shouldnt throw');
+}
+
+const r6 = rng();
+const batch = r6.batch(5, (rng, i) => i * rng.nextInt(10));
+assert(batch.length === 5, 'batch with custom function');
+
+console.log('\n=== PERFORMANCE CHECK ===');
+const r7 = rng();
+const start = performance.now();
+for (let i = 0; i < 1000000; i++) {
+  r7.nextFloat();
+}
+const elapsed = performance.now() - start;
+console.log(`✓ 1M nextFloat in ${elapsed.toFixed(0)}ms (${(1000000/elapsed|0).toLocaleString()}/sec)`);
+
+const r8 = rng();
+const start2 = performance.now();
+for (let i = 0; i < 100000; i++) {
+  normal(r8);
+}
+const elapsed2 = performance.now() - start2;
+console.log(`✓ 100k normal in ${elapsed2.toFixed(0)}ms (${(100000/elapsed2|0).toLocaleString()}/sec)`);
+
+console.log('\n✅ All tests passed\n');

package/test/comprehensive.js

@@ -61,10 +61,11 @@ console.log(`  State restored correctly: ${val2 === val2_restored}`);
 
 console.log('\n7. Generator Cloning');
 const orig = deterministic(12345);
-const origSeq = orig.floats(3);
+orig.floats(3);
 const cloned = cloneGenerator(orig);
-const clonedSeq = cloned.floats(3);
-console.log(`  Clone has same sequence: ${JSON.stringify(origSeq) === JSON.stringify(clonedSeq)}`);
+const origNext = orig.floats(3);
+const clonedNext = cloned.floats(3);
+console.log(`  Clone has same sequence: ${JSON.stringify(origNext) === JSON.stringify(clonedNext)}`);
 
 console.log('\n8. Weighted Sampling');
 const items = ['A', 'B', 'C'];

package/test/error-handling.js

@@ -0,0 +1,49 @@
+import { rng, deterministic, normal, exponential, uniform, shuffle, pick, sample } from '../src/index.js';
+
+const test = (name, fn) => {
+  try {
+    fn();
+    console.log(`✗ ${name} - should have thrown`);
+  } catch (e) {
+    console.log(`✓ ${name}`);
+  }
+};
+
+console.log('=== ERROR HANDLING ===\n');
+
+const r = rng();
+
+// RNG methods
+test('int() with non-number min', () => r.int('a', 100));
+test('int() with non-number max', () => r.int(1, 'b'));
+test('int() with non-integer min', () => r.int(1.5, 100));
+test('bool() with invalid probability', () => r.bool(1.5));
+test('bool() with negative probability', () => r.bool(-0.5));
+test('range() with non-number min', () => r.range('a', 10, 1));
+test('range() with negative step', () => r.range(1, 10, -1));
+test('choice() with empty array', () => r.choice([]));
+test('choice() with non-array', () => r.choice('notarray'));
+
+// Batch operations
+test('floats() with negative count', () => r.floats(-5));
+test('ints() with non-integer count', () => r.ints(5.5, 100));
+test('bools() with string count', () => r.bools('5'));
+test('batch() with non-function', () => r.batch(5, 'notfn'));
+
+// Distributions
+test('normal() with invalid rng', () => normal({}, 0, 1));
+test('exponential() with zero lambda', () => exponential(r, 0));
+test('uniform() with min > max', () => uniform(r, 100, 10));
+
+// Array operations
+test('shuffle() with non-array', () => shuffle({}, r));
+test('shuffle() with invalid rng', () => shuffle([1,2,3], {}));
+test('pick() with empty array', () => pick([], r));
+test('sample() with count > length', () => sample([1,2], 5, r));
+test('sample() with zero count', () => sample([1,2], 0, r));
+
+// Deterministic
+test('deterministic() with no seed', () => deterministic());
+test('deterministic() with null seed', () => deterministic(null));
+
+console.log('\n✅ All error cases handled correctly\n');

package/test/new-features.js

@@ -0,0 +1,52 @@
+import { rng, binomial, geometric, normals, exponentials, sampleWithReplacement, permute, range, cycle, clz, ctz, popcountNum, reverseBits, setBit, clearBit, toggleBit } from '../src/index.js';
+
+console.log('=== NEW FEATURES TEST ===\n');
+
+const r = rng();
+
+console.log('1. Binomial Distribution');
+const binom = binomial(r, 20, 0.5);
+console.log(`   binomial(20, 0.5): ${binom} (between 0-20)`);
+
+console.log('\n2. Geometric Distribution');
+const geom = geometric(r, 0.3);
+console.log(`   geometric(0.3): ${geom} (number of trials)`);
+
+console.log('\n3. Batch Normal Distribution (with caching)');
+const normals_arr = normals(r, 5);
+console.log(`   normals(5): [${normals_arr.map(n => n.toFixed(2)).join(', ')}]`);
+
+console.log('\n4. Batch Exponential Distribution');
+const exps = exponentials(r, 4, 1);
+console.log(`   exponentials(4): [${exps.map(e => e.toFixed(2)).join(', ')}]`);
+
+console.log('\n5. Sampling with Replacement');
+const sampled = sampleWithReplacement(['A', 'B', 'C'], 8, r);
+console.log(`   sampleWithReplacement([A,B,C], 8): [${sampled.join(', ')}]`);
+
+console.log('\n6. Permutation (alias for shuffle)');
+const perm = permute([1, 2, 3, 4], r);
+console.log(`   permute([1,2,3,4]): [${perm.join(', ')}]`);
+
+console.log('\n7. Range Generation');
+const r1 = range(0, 5);
+const r2 = range(10, 5, -1);
+console.log(`   range(0, 5): [${r1.join(', ')}]`);
+console.log(`   range(10, 5, -1): [${r2.join(', ')}]`);
+
+console.log('\n8. Cycle (repeat array)');
+const cyc = cycle(['X', 'Y'], 6);
+console.log(`   cycle([X, Y], 6): [${cyc.join(', ')}]`);
+
+console.log('\n9. Bit Operations');
+const val = 0b11010110n;
+console.log(`   Value: 0b11010110`);
+console.log(`   clz(): ${clz(val)}`);
+console.log(`   ctz(): ${ctz(val)}`);
+console.log(`   popcountNum(214): ${popcountNum(214)}`);
+console.log(`   reverseBits() [8-bit]: 0b${reverseBits(val, 8).toString(2).padStart(8, '0')}`);
+console.log(`   setBit(0b11010110, 0): 0b${setBit(val, 0).toString(2).padStart(8, '0')}`);
+console.log(`   clearBit(0b11010110, 1): 0b${clearBit(val, 1).toString(2).padStart(8, '0')}`);
+console.log(`   toggleBit(0b11010110, 4): 0b${toggleBit(val, 4).toString(2).padStart(8, '0')}`);
+
+console.log('\n✓ All new features working correctly');

package/IMPROVEMENTS.md

@@ -1,58 +0,0 @@
-# Improvements Made (Hour 2)
-
-## Batch Operations
-- Added `batch(count, fn)` - Execute custom function n times
-- Added `floats(count)` - Generate array of floats
-- Added `ints(count, max)` - Generate array of integers
-- Added `bools(count, probability)` - Generate array of booleans
-
-## RNG API Enhancements
-- Added `range(min, max, step)` - Pick random value from stepped range
-- Added `choice(arr)` - Pick random element from array
-- Better error messages with TypeError vs RangeError distinctions
-
-## Statistical Improvements
-- Added `kolmogorovSmirnovTest(data)` - KS goodness-of-fit test
-- Added `meanTest(data, expected)` - Test mean of distribution
-- Added `varianceTest(data, expected)` - Test variance of distribution
-- All tests return detailed result objects with pass/fail indicators
-
-## Sampling Enhancements
-- Improved `weightedPick()` with comprehensive validation
-- Improved `weightedSample()` with type checking
-- Improved `reservoirSample()` with better error handling
-
-## Generator Optimizations
-- Removed modulo bias in `nextInt()` - uses rejection sampling instead
-- Applied to: PCG64, Xorshift64, Splitmix64, MT19937
-- Ensures uniform distribution across all ranges
-
-## Performance & Caching
-- Added crypto cache in entropy source for performance
-- Added `clearCryptoCache()` export for testing
-- Better entropy mixing with proper BigInt operations
-
-## Type Safety
-- Added `IGenerator` interface for type consistency
-- Added `GeneratorConstructor` type definition
-- Added generic types to shuffle, pick, sample functions
-- Added test result interfaces: `TestResult`, `KSTestResult`
-- Complete TypeScript definitions for all new APIs
-
-## Documentation
-- Updated README with batch operations examples
-- Added weighted sampling section
-- Added statistical tests section
-- Enhanced generator selection documentation
-
-## Testing
-- Added comprehensive test suite (test/comprehensive.js)
-- Added advanced features test (test/advanced.js)
-- All tests pass successfully
-
-## Code Quality
-- Total lines: 1107 → 1318 (+211)
-- Files modified: 10
-- Lines added/changed: 286
-- Consistent error handling patterns
-- Full backward compatibility maintained