@cloudglides/nox 1.1.4 → 1.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudglides/nox",
-  "version": "1.1.4",
+  "version": "1.1.5",
   "description": "Unpredictable random number generator with multiple algorithms and distributions",
   "type": "module",
   "main": "src/index.js",

package/src/generators/mt19937.js

@@ -55,15 +55,12 @@ export class MT19937 {
     if (max <= 0) {
       throw new Error('max must be positive');
     }
-    if (!Number.isInteger(max)) {
-      throw new TypeError('max must be an integer');
-    }
     
-    if (max > 0x100000000) {
-      throw new Error('max must be <= 2^32');
+    if (max < 65536) {
+      return this.next() & 0xFFFF % max;
     }
     
-    const limit = Math.floor((0x100000000 - (0x100000000 % max)) / max) * max;
+    const limit = Math.floor((0x100000000 / max)) * max;
     let val;
     
     do {

package/src/generators/pcg64.js

@@ -26,24 +26,24 @@ export class PCG64 {
     if (max <= 0) {
       throw new Error('max must be positive');
     }
-    if (!Number.isInteger(max)) {
-      throw new TypeError('max must be an integer');
+    
+    if (max < 65536) {
+      return Number(this.next() & 0xFFFFn) % max;
     }
     
     const maxBig = BigInt(max);
-    const mask = (1n << 64n) - 1n;
-    const limit = (mask / maxBig) * maxBig;
+    const limit = ((1n << 64n) / maxBig) * maxBig;
     
-    let val = this.next() & mask;
+    let val = this.next();
     while (val >= limit) {
-      val = this.next() & mask;
+      val = this.next();
     }
     
     return Number(val % maxBig);
   }
 
   nextFloat() {
-    const val = this.next() & ((1n << 53n) - 1n);
-    return Number(val) / 9007199254740992.0;
+    const val = this.next() & 0x1FFFFFFFFFFFFFn;
+    return Number(val) * (1.0 / 9007199254740992.0);
   }
 }

package/src/generators/splitmix64.js

@@ -14,24 +14,24 @@ export class Splitmix64 {
     if (max <= 0) {
       throw new Error('max must be positive');
     }
-    if (!Number.isInteger(max)) {
-      throw new TypeError('max must be an integer');
+    
+    if (max < 65536) {
+      return Number(this.next() & 0xFFFFn) % max;
     }
     
     const maxBig = BigInt(max);
-    const mask = (1n << 64n) - 1n;
-    const limit = (mask / maxBig) * maxBig;
+    const limit = ((1n << 64n) / maxBig) * maxBig;
     
-    let val = this.next() & mask;
+    let val = this.next();
     while (val >= limit) {
-      val = this.next() & mask;
+      val = this.next();
     }
     
     return Number(val % maxBig);
   }
 
   nextFloat() {
-    const val = this.next() & ((1n << 53n) - 1n);
-    return Number(val) / 9007199254740992.0;
+    const val = this.next() & 0x1FFFFFFFFFFFFFn;
+    return Number(val) * (1.0 / 9007199254740992.0);
   }
 }

package/src/generators/xorshift64.js

@@ -20,24 +20,24 @@ export class Xorshift64 {
     if (max <= 0) {
       throw new Error('max must be positive');
     }
-    if (!Number.isInteger(max)) {
-      throw new TypeError('max must be an integer');
+    
+    if (max < 65536) {
+      return Number(this.next() & 0xFFFFn) % max;
     }
     
     const maxBig = BigInt(max);
-    const mask = (1n << 64n) - 1n;
-    const limit = (mask / maxBig) * maxBig;
+    const limit = ((1n << 64n) / maxBig) * maxBig;
     
-    let val = this.next() & mask;
+    let val = this.next();
     while (val >= limit) {
-      val = this.next() & mask;
+      val = this.next();
     }
     
     return Number(val % maxBig);
   }
 
   nextFloat() {
-    const val = this.next() & ((1n << 53n) - 1n);
-    return Number(val) / 9007199254740992.0;
+    const val = this.next() & 0x1FFFFFFFFFFFFFn;
+    return Number(val) * (1.0 / 9007199254740992.0);
   }
 }

package/src/rng.browser.js

@@ -70,74 +70,78 @@ export class RNG {
   }
 
   choice(arr) {
-    if (!Array.isArray(arr) || arr.length === 0) {
-      throw new TypeError('choice() requires non-empty array');
-    }
-    return arr[this.nextInt(arr.length)];
-  }
+     if (!Array.isArray(arr)) {
+       throw new TypeError('choice() requires array');
+     }
+     const len = arr.length;
+     if (len === 0) {
+       throw new TypeError('choice() requires non-empty array');
+     }
+     return arr[this.nextInt(len)];
+   }
 
   batch(count, fn) {
-    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 (typeof fn !== 'function') {
-      throw new TypeError('fn must be a function');
-    }
+     if (typeof count !== 'number' || !Number.isInteger(count)) {
+       throw new TypeError('count must be an integer');
+     }
+     if (count <= 0) {
+       return [];
+     }
+     if (typeof fn !== 'function') {
+       throw new TypeError('fn must be a function');
+     }
 
-    const result = [];
-    for (let i = 0; i < count; i++) {
-      result.push(fn(this, i));
-    }
-    return result;
-  }
+     const result = new Array(count);
+     for (let i = 0; i < count; i++) {
+       result[i] = fn(this, i);
+     }
+     return result;
+   }
 
-  floats(count) {
-    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');
-    }
+   floats(count) {
+     if (typeof count !== 'number' || !Number.isInteger(count)) {
+       throw new TypeError('count must be an integer');
+     }
+     if (count <= 0) {
+       return [];
+     }
 
-    const result = new Array(count);
-    for (let i = 0; i < count; i++) {
-      result[i] = this.nextFloat();
-    }
-    return result;
-  }
+     const result = new Array(count);
+     for (let i = 0; i < count; i++) {
+       result[i] = this.nextFloat();
+     }
+     return result;
+   }
 
-  ints(count, max = 2147483647) {
-    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');
-    }
+   ints(count, max = 2147483647) {
+     if (typeof count !== 'number' || !Number.isInteger(count)) {
+       throw new TypeError('count must be an integer');
+     }
+     if (count <= 0) {
+       return [];
+     }
 
-    const result = new Array(count);
-    for (let i = 0; i < count; i++) {
-      result[i] = this.nextInt(max);
-    }
-    return result;
-  }
+     const result = new Array(count);
+     for (let i = 0; i < count; i++) {
+       result[i] = this.nextInt(max);
+     }
+     return result;
+   }
 
-  bools(count, probability = 0.5) {
-    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');
-    }
+   bools(count, probability = 0.5) {
+     if (typeof count !== 'number' || !Number.isInteger(count)) {
+       throw new TypeError('count must be an integer');
+     }
+     if (count <= 0) {
+       return [];
+     }
 
-    const result = new Array(count);
-    for (let i = 0; i < count; i++) {
-      result[i] = this.bool(probability);
-    }
-    return result;
-  }
+     const result = new Array(count);
+     for (let i = 0; i < count; i++) {
+       result[i] = this.bool(probability);
+     }
+     return result;
+   }
 }
 
 export const rng = () => new RNG();

package/src/rng.js

@@ -70,74 +70,78 @@ export class RNG {
   }
 
   choice(arr) {
-    if (!Array.isArray(arr) || arr.length === 0) {
-      throw new TypeError('choice() requires non-empty array');
-    }
-    return arr[this.nextInt(arr.length)];
-  }
+     if (!Array.isArray(arr)) {
+       throw new TypeError('choice() requires array');
+     }
+     const len = arr.length;
+     if (len === 0) {
+       throw new TypeError('choice() requires non-empty array');
+     }
+     return arr[this.nextInt(len)];
+   }
 
   batch(count, fn) {
-    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 (typeof fn !== 'function') {
-      throw new TypeError('fn must be a function');
-    }
+     if (typeof count !== 'number' || !Number.isInteger(count)) {
+       throw new TypeError('count must be an integer');
+     }
+     if (count <= 0) {
+       return [];
+     }
+     if (typeof fn !== 'function') {
+       throw new TypeError('fn must be a function');
+     }
 
-    const result = [];
-    for (let i = 0; i < count; i++) {
-      result.push(fn(this, i));
-    }
-    return result;
-  }
+     const result = new Array(count);
+     for (let i = 0; i < count; i++) {
+       result[i] = fn(this, i);
+     }
+     return result;
+   }
 
   floats(count) {
-    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 (typeof count !== 'number' || !Number.isInteger(count)) {
+       throw new TypeError('count must be an integer');
+     }
+     if (count <= 0) {
+       return [];
+     }
 
-    const result = new Array(count);
-    for (let i = 0; i < count; i++) {
-      result[i] = this.nextFloat();
-    }
-    return result;
-  }
+     const result = new Array(count);
+     for (let i = 0; i < count; i++) {
+       result[i] = this.nextFloat();
+     }
+     return result;
+   }
 
-  ints(count, max = 2147483647) {
-    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');
-    }
+   ints(count, max = 2147483647) {
+     if (typeof count !== 'number' || !Number.isInteger(count)) {
+       throw new TypeError('count must be an integer');
+     }
+     if (count <= 0) {
+       return [];
+     }
 
-    const result = new Array(count);
-    for (let i = 0; i < count; i++) {
-      result[i] = this.nextInt(max);
-    }
-    return result;
-  }
+     const result = new Array(count);
+     for (let i = 0; i < count; i++) {
+       result[i] = this.nextInt(max);
+     }
+     return result;
+   }
 
-  bools(count, probability = 0.5) {
-    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');
-    }
+   bools(count, probability = 0.5) {
+     if (typeof count !== 'number' || !Number.isInteger(count)) {
+       throw new TypeError('count must be an integer');
+     }
+     if (count <= 0) {
+       return [];
+     }
 
-    const result = new Array(count);
-    for (let i = 0; i < count; i++) {
-      result[i] = this.bool(probability);
-    }
-    return result;
-  }
+     const result = new Array(count);
+     for (let i = 0; i < count; i++) {
+       result[i] = this.bool(probability);
+     }
+     return result;
+   }
 }
 
 export const rng = () => new RNG();

package/src/utils/distributions.js

@@ -1,23 +1,25 @@
+const TWO_PI = 2 * Math.PI;
+
 export const normal = (rng, mean = 0, stddev = 1) => {
-  if (!rng || typeof rng.nextFloat !== 'function') {
-    throw new TypeError('First argument must be RNG instance');
-  }
-  if (typeof mean !== 'number' || typeof stddev !== 'number') {
-    throw new TypeError('mean and stddev must be numbers');
-  }
-  if (stddev <= 0) {
-    throw new Error('stddev must be positive');
-  }
-  
-  let u1, u2;
-  do {
-    u1 = rng.nextFloat();
-    u2 = rng.nextFloat();
-  } while (u1 <= 0 || u2 <= 0);
-  
-  const z0 = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
-  return z0 * stddev + mean;
-};
+   if (!rng || typeof rng.nextFloat !== 'function') {
+     throw new TypeError('First argument must be RNG instance');
+   }
+   if (typeof mean !== 'number' || typeof stddev !== 'number') {
+     throw new TypeError('mean and stddev must be numbers');
+   }
+   if (stddev <= 0) {
+     throw new Error('stddev must be positive');
+   }
+   
+   let u1, u2;
+   do {
+     u1 = rng.nextFloat();
+     u2 = rng.nextFloat();
+   } while (u1 <= 0 || u2 <= 0);
+   
+   const z0 = Math.sqrt(-2 * Math.log(u1)) * Math.cos(TWO_PI * u2);
+   return z0 * stddev + mean;
+ };
 
 export const exponential = (rng, lambda = 1) => {
   if (!rng || typeof rng.nextFloat !== 'function') {

package/src/utils/sampling.js

@@ -34,38 +34,43 @@ export const weightedPick = (arr, weights, rng) => {
 };
 
 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;
-};
+   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) {
+     return [];
+   }
+   if (!rng || typeof rng.nextFloat !== 'function') {
+     throw new TypeError('rng must be an RNG instance');
+   }
+   
+   const result = [];
+   const len = arr.length;
+   if (count >= len) {
+     return [...arr];
+   }
+   
+   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);

package/src/utils/sequence.js

@@ -1,21 +1,23 @@
 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;
-};
+   if (!Array.isArray(arr)) {
+     throw new TypeError('First argument must be array');
+   }
+   if (!rng || typeof rng.nextInt !== 'function') {
+     throw new TypeError('RNG instance required');
+   }
+   
+   const target = inPlace ? arr : [...arr];
+   const len = target.length;
+   for (let i = len - 1; i > 0; i--) {
+     const j = rng.nextInt(i + 1);
+     if (i !== j) {
+       const temp = target[i];
+       target[i] = target[j];
+       target[j] = temp;
+     }
+   }
+   return target;
+ };
 
 export const pick = (arr, rng) => {
   if (!Array.isArray(arr)) {
@@ -32,22 +34,29 @@ export const pick = (arr, rng) => {
 };
 
 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);
-};
+   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 = [...arr];
+   const len = copy.length;
+   for (let i = len - 1; i >= len - count; i--) {
+     const j = rng.nextInt(i + 1);
+     const temp = copy[i];
+     copy[i] = copy[j];
+     copy[j] = temp;
+   }
+   return copy.slice(len - count);
+ };