@cloudglides/nox 1.1.6 → 3.0.0

package/src/utils/sampling.js

@@ -1,88 +1,97 @@
 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');
+    if (!Array.isArray(arr) || arr.length === 0) {
+      throw new RangeError('arr must be a non-empty array');
+    }
+    if (!Array.isArray(weights) || weights.length === 0) {
+      throw new RangeError('weights must be a non-empty array');
+    }
+    if (arr.length !== weights.length) {
+      throw new RangeError('arr and weights must have same length');
+    }
+    if (!rng || typeof rng.nextFloat !== 'function') {
+      throw new TypeError('rng must be an RNG instance');
+    }
+    
+    let total = 0;
+    for (let i = 0; i < weights.length; i++) {
+      if (typeof weights[i] !== 'number') {
+        throw new TypeError('All weights must be numbers');
+      }
+      total += weights[i];
+    }
+    
+    if (total <= 0) {
+      throw new RangeError('Weights must sum to positive value');
     }
-    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) {
-     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];
+   let rand = rng.nextFloat() * total;
+   let cumsum = 0;
    
-   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);
+   for (let i = 0; i < arr.length; i++) {
+     cumsum += weights[i];
+     if (rand < cumsum) return arr[i];
    }
    
-   return result;
+   return arr[arr.length - 1];
  };
 
-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 weightedSample = (arr, weights, count, rng) => {
+     if (!Array.isArray(arr) || arr.length === 0) {
+       throw new RangeError('arr must be a non-empty array');
+     }
+     if (!Array.isArray(weights) || weights.length === 0) {
+       throw new RangeError('weights must be a non-empty array');
+     }
+     if (arr.length !== weights.length) {
+       throw new RangeError('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 len = arr.length;
+    if (count >= len) {
+      return [...arr];
+    }
+    
+    const remaining = [...arr];
+    const remainingWeights = [...weights];
+    const result = [];
+    
+    for (let i = 0; i < count; i++) {
+      const idx = weightedPickIndexRange(remainingWeights, i, rng);
+      result.push(remaining[i + idx]);
+      
+      const temp = remaining[i];
+      remaining[i] = remaining[i + idx];
+      remaining[i + idx] = temp;
+      
+      const tempW = remainingWeights[i];
+      remainingWeights[i] = remainingWeights[i + idx];
+      remainingWeights[i + idx] = tempW;
+    }
+    
+    return result;
+    };
+
+    const weightedPickIndexRange = (weights, start, rng) => {
+    let total = 0;
+    for (let i = start; i < weights.length; i++) {
+     total += weights[i];
+    }
+    let rand = rng.nextFloat() * total;
+    for (let i = start; i < weights.length; i++) {
+     rand -= weights[i];
+     if (rand <= 0) return i - start;
+    }
+    return weights.length - start - 1;
+    };
 
 export const reservoirSample = (stream, k, rng) => {
    if (!Array.isArray(stream) || stream.length === 0) {

package/src/utils/seed.js

@@ -1,10 +1,16 @@
 export const seedFromTime = () => {
-  return BigInt(Date.now() + Math.random() * 1000000);
-};
+   const time = BigInt(Date.now());
+   const rand = BigInt(Math.floor(Math.random() * 1000000));
+   return (time << 20n) | rand;
+ };
 
 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');
+   if (typeof entropy !== 'string') {
+     throw new TypeError('entropy must be a string');
+   }
+   if (entropy.length === 0) {
+     throw new RangeError('entropy cannot be empty');
+   }
   
   let hash = 5381n;
   for (let i = 0; i < entropy.length; i++) {

package/src/utils/seeding.js

@@ -22,16 +22,28 @@ export class SeedSequence {
   }
 
   spawn(n = 1) {
-    const seeds = [];
-    for (let i = 0; i < n; i++) {
-      seeds.push(this.next());
-    }
-    return seeds;
+     if (typeof n !== 'number' || !Number.isInteger(n)) {
+       throw new TypeError('n must be an integer');
+     }
+     if (n <= 0) {
+       throw new RangeError('n must be positive');
+     }
+     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]));
-};
+  
+  export const seedMultiple = (rngClasses, entropy = null) => {
+    if (!Array.isArray(rngClasses)) {
+      throw new TypeError('rngClasses must be an array');
+    }
+    if (rngClasses.length === 0) {
+      throw new RangeError('rngClasses cannot be empty');
+    }
+    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

@@ -3,7 +3,7 @@ export const shuffle = (arr, rng, inPlace = false) => {
      throw new TypeError('First argument must be array');
    }
    if (!rng || typeof rng.nextInt !== 'function') {
-     throw new TypeError('RNG instance required');
+     throw new TypeError('Second argument must be RNG instance');
    }
    
    const target = inPlace ? arr : [...arr];
@@ -20,43 +20,127 @@ export const shuffle = (arr, rng, inPlace = false) => {
  };
 
 export const pick = (arr, rng) => {
+   if (!Array.isArray(arr)) {
+     throw new TypeError('First argument must be array');
+   }
+   if (arr.length === 0) {
+     throw new RangeError('Array cannot be empty');
+   }
+   if (!rng || typeof rng.nextInt !== 'function') {
+     throw new TypeError('Second argument must be RNG instance');
+   }
+   
+   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 RangeError('Sample count must be positive');
+      }
+      if (count > arr.length) {
+        throw new RangeError('Sample count exceeds array length');
+      }
+      if (!rng || typeof rng.nextInt !== 'function') {
+        throw new TypeError('Second argument must be RNG instance');
+      }
+     
+     const copy = [...arr];
+     const len = copy.length;
+     for (let i = len - 1; i > len - count - 1; i--) {
+       const j = rng.nextInt(i + 1);
+       const temp = copy[i];
+       copy[i] = copy[j];
+       copy[j] = temp;
+     }
+     return copy.slice(len - count);
+   };
+
+export const sampleWithReplacement = (arr, count, rng) => {
   if (!Array.isArray(arr)) {
     throw new TypeError('First argument must be array');
   }
   if (arr.length === 0) {
-    throw new Error('Array cannot be empty');
+    throw new RangeError('Array cannot be empty');
+  }
+  if (typeof count !== 'number' || !Number.isInteger(count)) {
+    throw new TypeError('Sample count must be an integer');
+  }
+  if (count <= 0) {
+    throw new RangeError('Sample count must be positive');
   }
   if (!rng || typeof rng.nextInt !== 'function') {
-    throw new TypeError('RNG instance required');
+    throw new TypeError('rng must be an RNG instance');
   }
-  
-  return arr[rng.nextInt(arr.length)];
+
+  const result = new Array(count);
+  const len = arr.length;
+  for (let i = 0; i < count; i++) {
+    result[i] = arr[rng.nextInt(len)];
+  }
+  return result;
 };
 
-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 = [...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);
- };
+export const permute = (arr, rng) => {
+  if (!Array.isArray(arr)) {
+    throw new TypeError('First argument must be array');
+  }
+  if (!rng || typeof rng.nextInt !== 'function') {
+    throw new TypeError('Second argument must be RNG instance');
+  }
+  return shuffle(arr, rng, false);
+};
+
+export const range = (start, end, step = 1) => {
+  if (typeof start !== 'number' || !Number.isInteger(start)) {
+    throw new TypeError('start must be an integer');
+  }
+  if (typeof end !== 'number' || !Number.isInteger(end)) {
+    throw new TypeError('end must be an integer');
+  }
+  if (typeof step !== 'number' || !Number.isInteger(step)) {
+    throw new TypeError('step must be an integer');
+  }
+  if (step === 0) {
+    throw new RangeError('step cannot be zero');
+  }
+
+  const result = [];
+  if (step > 0) {
+    for (let i = start; i < end; i += step) {
+      result.push(i);
+    }
+  } else {
+    for (let i = start; i > end; i += step) {
+      result.push(i);
+    }
+  }
+  return result;
+};
+
+export const cycle = (arr, count) => {
+  if (!Array.isArray(arr)) {
+    throw new TypeError('First argument must be array');
+  }
+  if (arr.length === 0) {
+    throw new RangeError('Array cannot be empty');
+  }
+  if (typeof count !== 'number' || !Number.isInteger(count)) {
+    throw new TypeError('count must be an integer');
+  }
+  if (count <= 0) {
+    throw new RangeError('count must be positive');
+  }
+
+  const result = new Array(count);
+  const len = arr.length;
+  for (let i = 0; i < count; i++) {
+    result[i] = arr[i % len];
+  }
+  return result;
+};

package/src/utils/state.js

@@ -1,39 +1,51 @@
 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;
-};
+   const gen = rng.gen || rng;
+   if (gen.state === undefined) {
+     throw new Error('Generator does not support state snapshots');
+   }
+   const state = gen.state;
+   return {
+     state: typeof state === 'bigint' ? state.toString() : state,
+     isBigInt: typeof state === 'bigint'
+   };
+ };
+ 
+ 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.isBigInt ? BigInt(snapshot.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;
-};
+    const isRNGWrapper = rng.gen !== undefined;
+    const gen = isRNGWrapper ? rng.gen : rng;
+    const Constructor = gen.constructor;
+    
+    let clonedGen = Object.create(Constructor.prototype);
+    
+    if (Constructor.name === 'PCG64') {
+      clonedGen.state = gen.state;
+      clonedGen.inc = gen.inc;
+    } else if (Constructor.name === 'Logistic') {
+      clonedGen.x = gen.x;
+      clonedGen.r = gen.r;
+    } else if (Constructor.name === 'Tent') {
+      clonedGen.x = gen.x;
+      clonedGen.mu = gen.mu;
+    } else if (Constructor.name === 'Xorshift64' || Constructor.name === 'Splitmix64' || Constructor.name === 'MT19937') {
+      clonedGen.state = gen.state;
+      if (Constructor.name === 'MT19937') {
+        clonedGen.mt = [...gen.mt];
+        clonedGen.mti = gen.mti;
+      }
+    } else if (Constructor.name === 'Mixer') {
+      clonedGen.rng1 = cloneGenerator(gen.rng1);
+      clonedGen.rng2 = cloneGenerator(gen.rng2);
+    } else {
+      clonedGen.state = gen.state;
+    }
+    
+    return isRNGWrapper ? new (rng.constructor)(clonedGen) : clonedGen;
+  };

package/src/utils/statistics.js

@@ -139,5 +139,67 @@ export const varianceTest = (data, expectedVariance = 1 / 12) => {
      expectedVariance,
      chi2Statistic: chi2,
      degreesOfFreedom: data.length - 1
-   };
- };
+     };
+     };
+
+     export const skewness = (data) => {
+     if (!Array.isArray(data) || data.length < 3) {
+     throw new Error('Data must be array with at least 3 elements');
+     }
+
+     const n = data.length;
+     const mean = data.reduce((a, b) => a + b, 0) / n;
+     const m2 = data.reduce((sum, x) => sum + (x - mean) ** 2, 0) / n;
+     const m3 = data.reduce((sum, x) => sum + (x - mean) ** 3, 0) / n;
+     const std = Math.sqrt(m2);
+
+     if (std === 0) return 0;
+     return m3 / (std ** 3);
+     };
+
+     export const kurtosis = (data) => {
+     if (!Array.isArray(data) || data.length < 4) {
+     throw new Error('Data must be array with at least 4 elements');
+     }
+
+     const n = data.length;
+     const mean = data.reduce((a, b) => a + b, 0) / n;
+     const m2 = data.reduce((sum, x) => sum + (x - mean) ** 2, 0) / n;
+     const m4 = data.reduce((sum, x) => sum + (x - mean) ** 4, 0) / n;
+     const std = Math.sqrt(m2);
+
+     if (std === 0) return 0;
+     return m4 / (std ** 4) - 3;
+     };
+
+     export const median = (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);
+     const mid = Math.floor(sorted.length / 2);
+
+     if (sorted.length % 2 === 1) {
+     return sorted[mid];
+     }
+     return (sorted[mid - 1] + sorted[mid]) / 2;
+     };
+
+     export const quantile = (data, q) => {
+     if (!Array.isArray(data) || data.length === 0) {
+     throw new Error('Data must be non-empty array');
+     }
+     if (typeof q !== 'number' || q < 0 || q > 1) {
+     throw new RangeError('Quantile must be between 0 and 1');
+     }
+
+     const sorted = [...data].sort((a, b) => a - b);
+     const idx = q * (sorted.length - 1);
+     const lower = Math.floor(idx);
+     const upper = Math.ceil(idx);
+     const weight = idx % 1;
+
+     if (lower === upper) return sorted[lower];
+     return sorted[lower] * (1 - weight) + sorted[upper] * weight;
+     };