@cloudglides/nox 1.1.3 → 1.1.5

package/src/rng.browser.js

@@ -28,15 +28,17 @@ export class RNG {
   }
 
   int(min, max) {
-    if (typeof min !== 'number' || typeof max !== 'number') {
-      throw new TypeError('int() requires two number arguments');
-    }
-    if (!Number.isInteger(min) || !Number.isInteger(max)) {
-      throw new TypeError('int() arguments must be integers');
-    }
-    if (min > max) [min, max] = [max, min];
-    return Math.floor(this.nextFloat() * (max - min + 1)) + min;
-  }
+     if (typeof min !== 'number' || typeof max !== 'number') {
+       throw new TypeError('int() requires two number arguments');
+     }
+     if (!Number.isInteger(min) || !Number.isInteger(max)) {
+       throw new TypeError('int() arguments must be integers');
+     }
+     if (min > max) [min, max] = [max, min];
+     const range = max - min + 1;
+     let val = Math.floor(this.nextFloat() * range);
+     return val + min;
+   }
 
   bool(probability = 0.5) {
     if (typeof probability !== 'number') {
@@ -68,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');
-    }
-
-    const result = [];
-    for (let i = 0; i < count; i++) {
-      result.push(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');
-    }
-
-    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');
-    }
-
-    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');
-    }
-
-    const result = new Array(count);
-    for (let i = 0; i < count; i++) {
-      result[i] = this.bool(probability);
-    }
-    return result;
-  }
+     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 = 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) {
+       return [];
+     }
+
+     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) {
+       return [];
+     }
+
+     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) {
+       return [];
+     }
+
+     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

@@ -28,15 +28,17 @@ export class RNG {
   }
 
   int(min, max) {
-    if (typeof min !== 'number' || typeof max !== 'number') {
-      throw new TypeError('int() requires two number arguments');
-    }
-    if (!Number.isInteger(min) || !Number.isInteger(max)) {
-      throw new TypeError('int() arguments must be integers');
-    }
-    if (min > max) [min, max] = [max, min];
-    return Math.floor(this.nextFloat() * (max - min + 1)) + min;
-  }
+     if (typeof min !== 'number' || typeof max !== 'number') {
+       throw new TypeError('int() requires two number arguments');
+     }
+     if (!Number.isInteger(min) || !Number.isInteger(max)) {
+       throw new TypeError('int() arguments must be integers');
+     }
+     if (min > max) [min, max] = [max, min];
+     const range = max - min + 1;
+     let val = Math.floor(this.nextFloat() * range);
+     return val + min;
+   }
 
   bool(probability = 0.5) {
     if (typeof probability !== 'number') {
@@ -68,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');
-    }
-
-    const result = [];
-    for (let i = 0; i < count; i++) {
-      result.push(fn(this, i));
-    }
-    return result;
-  }
+     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 = 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');
-    }
-
-    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');
-    }
-
-    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');
-    }
-
-    const result = new Array(count);
-    for (let i = 0; i < count; i++) {
-      result[i] = this.bool(probability);
-    }
-    return result;
-  }
+     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;
+   }
+
+   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;
+   }
+
+   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;
+   }
 }
 
 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);
@@ -80,27 +85,30 @@ const weightedPickIndex = (weights, rng) => {
 };
 
 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;
-};
+   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 (k > stream.length) {
+     throw new RangeError('k cannot exceed stream length');
+   }
+   if (!rng || typeof rng.nextInt !== 'function') {
+     throw new TypeError('rng must be an RNG instance');
+   }
+   
+   const reservoir = stream.slice(0, k);
+   
+   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/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);
+ };