@cloudglides/nox 1.1.5 → 2.0.0

package/src/utils/rootfinding.js

@@ -0,0 +1,158 @@
+export function bisection(f, a, b, tol = 1e-6, maxIter = 100) {
+  if (typeof f !== 'function') {
+    throw new TypeError('f must be function');
+  }
+  if (typeof a !== 'number' || typeof b !== 'number') {
+    throw new TypeError('a and b must be numbers');
+  }
+  if (a >= b) {
+    throw new RangeError('a must be less than b');
+  }
+
+  const fa = f(a);
+  const fb = f(b);
+
+  if (fa * fb > 0) {
+    throw new RangeError('f(a) and f(b) must have opposite signs');
+  }
+
+  let c, fc;
+  for (let i = 0; i < maxIter; i++) {
+    c = (a + b) / 2;
+    fc = f(c);
+
+    if (Math.abs(fc) < tol || Math.abs(b - a) / 2 < tol) {
+      return { root: c, iterations: i + 1, residual: Math.abs(fc) };
+    }
+
+    if (fa * fc < 0) {
+      b = c;
+      fb = fc;
+    } else {
+      a = c;
+      fa = fc;
+    }
+  }
+
+  return { root: c, iterations: maxIter, residual: Math.abs(fc) };
+}
+
+export function newtonRaphson(f, df, x0, tol = 1e-6, maxIter = 100) {
+  if (typeof f !== 'function' || typeof df !== 'function') {
+    throw new TypeError('f and df must be functions');
+  }
+  if (typeof x0 !== 'number') {
+    throw new TypeError('x0 must be number');
+  }
+
+  let x = x0;
+  for (let i = 0; i < maxIter; i++) {
+    const fx = f(x);
+    const dfx = df(x);
+
+    if (Math.abs(dfx) < 1e-14) {
+      throw new RangeError('derivative too close to zero');
+    }
+
+    const xNew = x - fx / dfx;
+
+    if (Math.abs(xNew - x) < tol) {
+      return { root: xNew, iterations: i + 1, residual: Math.abs(f(xNew)) };
+    }
+
+    x = xNew;
+  }
+
+  return { root: x, iterations: maxIter, residual: Math.abs(f(x)) };
+}
+
+export function secant(f, x0, x1, tol = 1e-6, maxIter = 100) {
+  if (typeof f !== 'function') {
+    throw new TypeError('f must be function');
+  }
+  if (typeof x0 !== 'number' || typeof x1 !== 'number') {
+    throw new TypeError('x0 and x1 must be numbers');
+  }
+
+  let xPrev = x0;
+  let xCurr = x1;
+  let fPrev = f(xPrev);
+  let fCurr = f(xCurr);
+
+  for (let i = 0; i < maxIter; i++) {
+    if (Math.abs(fCurr - fPrev) < 1e-14) {
+      throw new RangeError('denominator too close to zero');
+    }
+
+    const xNext = xCurr - fCurr * (xCurr - xPrev) / (fCurr - fPrev);
+
+    if (Math.abs(xNext - xCurr) < tol) {
+      return { root: xNext, iterations: i + 1, residual: Math.abs(f(xNext)) };
+    }
+
+    xPrev = xCurr;
+    xCurr = xNext;
+    fPrev = fCurr;
+    fCurr = f(xCurr);
+  }
+
+  return { root: xCurr, iterations: maxIter, residual: Math.abs(fCurr) };
+}
+
+export function falsePosition(f, a, b, tol = 1e-6, maxIter = 100) {
+  if (typeof f !== 'function') {
+    throw new TypeError('f must be function');
+  }
+  if (typeof a !== 'number' || typeof b !== 'number') {
+    throw new TypeError('a and b must be numbers');
+  }
+
+  let fa = f(a);
+  let fb = f(b);
+
+  if (fa * fb > 0) {
+    throw new RangeError('f(a) and f(b) must have opposite signs');
+  }
+
+  for (let i = 0; i < maxIter; i++) {
+    const c = a - (fa * (b - a)) / (fb - fa);
+    const fc = f(c);
+
+    if (Math.abs(fc) < tol) {
+      return { root: c, iterations: i + 1, residual: Math.abs(fc) };
+    }
+
+    if (fa * fc < 0) {
+      b = c;
+      fb = fc;
+    } else {
+      a = c;
+      fa = fc;
+    }
+  }
+
+  const c = a - (fa * (b - a)) / (fb - fa);
+  return { root: c, iterations: maxIter, residual: Math.abs(f(c)) };
+}
+
+export function fixedPoint(g, x0, tol = 1e-6, maxIter = 100) {
+  if (typeof g !== 'function') {
+    throw new TypeError('g must be function');
+  }
+  if (typeof x0 !== 'number') {
+    throw new TypeError('x0 must be number');
+  }
+
+  let x = x0;
+  for (let i = 0; i < maxIter; i++) {
+    const xNew = g(x);
+
+    if (Math.abs(xNew - x) < tol) {
+      return { root: xNew, iterations: i + 1, residual: Math.abs(xNew - x) };
+    }
+
+    x = xNew;
+  }
+
+  return { root: x, iterations: maxIter, residual: Math.abs(g(x) - x) };
+}

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;
+  };