@cloudglides/nox 1.1.5 → 2.0.0

package/src/utils/distributions-extra.js

@@ -1,21 +1,59 @@
 export const beta = (rng, alpha, beta) => {
-  const u = -Math.log(rng.nextFloat()) / alpha;
-  const v = -Math.log(rng.nextFloat()) / beta;
-  return u / (u + v);
-};
+    if (!rng || typeof rng.nextFloat !== 'function') {
+      throw new TypeError('First argument must be RNG instance');
+    }
+    if (typeof alpha !== 'number') {
+      throw new TypeError('alpha must be a number');
+    }
+    if (alpha <= 0) {
+      throw new RangeError('alpha must be positive');
+    }
+    if (typeof beta !== 'number') {
+      throw new TypeError('beta must be a number');
+    }
+    if (beta <= 0) {
+      throw new RangeError('beta must be positive');
+    }
+   let u = rng.nextFloat();
+   while (u === 0 || u === 1) {
+     u = rng.nextFloat();
+   }
+   let v = rng.nextFloat();
+   while (v === 0 || v === 1) {
+     v = rng.nextFloat();
+   }
+   const uVal = -Math.log(u) / alpha;
+   const vVal = -Math.log(v) / beta;
+   return uVal / (uVal + vVal);
+ };
 
 export const gamma = (rng, shape, scale = 1) => {
-  if (shape < 1) {
-    return gamma(rng, shape + 1, scale) * Math.pow(rng.nextFloat(), 1 / shape);
-  }
+    if (!rng || typeof rng.nextFloat !== 'function') {
+      throw new TypeError('First argument must be RNG instance');
+    }
+    if (typeof shape !== 'number') {
+      throw new TypeError('shape must be a number');
+    }
+    if (shape <= 0) {
+      throw new RangeError('shape must be positive');
+    }
+    if (typeof scale !== 'number') {
+      throw new TypeError('scale must be a number');
+    }
+    if (scale <= 0) {
+      throw new RangeError('scale must be positive');
+    }
+   if (shape < 1) {
+     return gamma(rng, shape + 1, scale) * Math.pow(rng.nextFloat(), 1 / shape);
+   }
   
   const d = shape - 1 / 3;
   const c = 1 / Math.sqrt(9 * d);
   
-  let z, v, u;
+  let z, v, u, x;
   do {
     do {
-      const x = (rng.nextFloat() * 2 - 1);
+      x = (rng.nextFloat() * 2 - 1);
       v = 1 + c * x;
     } while (v <= 0);
     
@@ -28,5 +66,58 @@ export const gamma = (rng, shape, scale = 1) => {
 };
 
 export const chi2 = (rng, k) => {
-  return gamma(rng, k / 2, 2);
-};
+     if (!rng || typeof rng.nextFloat !== 'function') {
+       throw new TypeError('First argument must be RNG instance');
+     }
+     if (typeof k !== 'number') {
+       throw new TypeError('k must be a number');
+     }
+     if (k <= 0) {
+       throw new RangeError('k must be positive');
+     }
+     return gamma(rng, k / 2, 2);
+   };
+
+export const binomial = (rng, n, p) => {
+     if (!rng || typeof rng.nextFloat !== 'function') {
+       throw new TypeError('First argument must be RNG instance');
+     }
+     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');
+     }
+     if (typeof p !== 'number') {
+       throw new TypeError('p must be a number');
+     }
+     if (p < 0 || p > 1) {
+       throw new RangeError('p must be between 0 and 1');
+     }
+
+     if (p === 0) return 0;
+     if (p === 1) return n;
+     if (n > 30 && p > 0.1 && p < 0.9) {
+       return Math.round(n * p + Math.sqrt(n * p * (1 - p)) * (rng.nextFloat() * 2 - 1));
+     }
+
+     let count = 0;
+     for (let i = 0; i < n; i++) {
+       if (rng.nextFloat() < p) count++;
+     }
+     return count;
+   };
+
+export const geometric = (rng, p) => {
+     if (!rng || typeof rng.nextFloat !== 'function') {
+       throw new TypeError('First argument must be RNG instance');
+     }
+     if (typeof p !== 'number') {
+       throw new TypeError('p must be a number');
+     }
+     if (p <= 0 || p > 1) {
+       throw new RangeError('p must be between 0 and 1 (exclusive 0)');
+     }
+
+     return Math.floor(Math.log(rng.nextFloat()) / Math.log(1 - p)) + 1;
+   };

package/src/utils/distributions-special.js

@@ -1,21 +1,78 @@
 export const weibull = (rng, shape, scale = 1) => {
-  const u = rng.nextFloat();
-  return scale * Math.pow(-Math.log(1 - u), 1 / shape);
-};
-
-export const lognormal = (rng, mu, sigma) => {
-  const u1 = rng.nextFloat();
-  const u2 = rng.nextFloat();
-  const z = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
-  return Math.exp(mu + sigma * z);
-};
-
-export const rayleigh = (rng, sigma = 1) => {
-  const u = rng.nextFloat();
-  return sigma * Math.sqrt(-2 * Math.log(u));
-};
-
-export const cauchy = (rng, median = 0, scale = 1) => {
-  const u = rng.nextFloat();
-  return median + scale * Math.tan(Math.PI * (u - 0.5));
-};
+    if (!rng || typeof rng.nextFloat !== 'function') {
+      throw new TypeError('First argument must be RNG instance');
+    }
+    if (typeof shape !== 'number') {
+      throw new TypeError('shape must be a number');
+    }
+    if (shape <= 0) {
+      throw new RangeError('shape must be positive');
+    }
+    if (typeof scale !== 'number') {
+      throw new TypeError('scale must be a number');
+    }
+    if (scale <= 0) {
+      throw new RangeError('scale must be positive');
+    }
+   let u = rng.nextFloat();
+   while (u === 0 || u === 1) {
+     u = rng.nextFloat();
+   }
+   return scale * Math.pow(-Math.log(1 - u), 1 / shape);
+ };
+ 
+ export const lognormal = (rng, mu, sigma) => {
+   if (!rng || typeof rng.nextFloat !== 'function') {
+     throw new TypeError('First argument must be RNG instance');
+   }
+   if (typeof mu !== 'number') {
+     throw new TypeError('mu must be a number');
+   }
+   if (typeof sigma !== 'number') {
+     throw new TypeError('sigma must be a number');
+   }
+   if (sigma <= 0) {
+     throw new RangeError('sigma must be positive');
+   }
+   let u1 = rng.nextFloat();
+   while (u1 === 0 || u1 === 1) {
+     u1 = rng.nextFloat();
+   }
+   const u2 = rng.nextFloat();
+   const z = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+   return Math.exp(mu + sigma * z);
+ };
+ 
+ export const rayleigh = (rng, sigma = 1) => {
+   if (!rng || typeof rng.nextFloat !== 'function') {
+     throw new TypeError('First argument must be RNG instance');
+   }
+   if (typeof sigma !== 'number') {
+     throw new TypeError('sigma must be a number');
+   }
+   if (sigma <= 0) {
+     throw new RangeError('sigma must be positive');
+   }
+   let u = rng.nextFloat();
+   while (u === 0 || u === 1) {
+     u = rng.nextFloat();
+   }
+   return sigma * Math.sqrt(-2 * Math.log(u));
+ };
+ 
+ export const cauchy = (rng, median = 0, scale = 1) => {
+   if (!rng || typeof rng.nextFloat !== 'function') {
+     throw new TypeError('First argument must be RNG instance');
+   }
+   if (typeof median !== 'number') {
+     throw new TypeError('median must be a number');
+   }
+   if (typeof scale !== 'number') {
+     throw new TypeError('scale must be a number');
+   }
+   if (scale <= 0) {
+     throw new RangeError('scale must be positive');
+   }
+   const u = rng.nextFloat();
+   return median + scale * Math.tan(Math.PI * (u - 0.5));
+ };

package/src/utils/distributions.js

@@ -1,15 +1,18 @@
 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');
-   }
+    if (!rng || typeof rng.nextFloat !== 'function') {
+      throw new TypeError('First argument must be RNG instance');
+    }
+    if (typeof mean !== 'number') {
+      throw new TypeError('mean must be a number');
+    }
+    if (typeof stddev !== 'number') {
+      throw new TypeError('stddev must be a number');
+    }
+    if (stddev <= 0) {
+      throw new RangeError('stddev must be positive');
+    }
    
    let u1, u2;
    do {
@@ -22,27 +25,34 @@ export const normal = (rng, mean = 0, stddev = 1) => {
  };
 
 export const exponential = (rng, lambda = 1) => {
-  if (!rng || typeof rng.nextFloat !== 'function') {
-    throw new TypeError('First argument must be RNG instance');
-  }
-  if (typeof lambda !== 'number' || lambda <= 0) {
-    throw new Error('lambda must be a positive number');
-  }
-  
-  let u = rng.nextFloat();
-  while (u === 0 || u === 1) {
-    u = rng.nextFloat();
-  }
-  return -Math.log(1 - u) / lambda;
-};
+    if (!rng || typeof rng.nextFloat !== 'function') {
+      throw new TypeError('First argument must be RNG instance');
+    }
+    if (typeof lambda !== 'number') {
+      throw new TypeError('lambda must be a number');
+    }
+    if (lambda <= 0) {
+      throw new RangeError('lambda must be positive');
+    }
+   
+   let u = rng.nextFloat();
+   while (u === 0 || u === 1) {
+     u = rng.nextFloat();
+   }
+   const result = -Math.log(1 - u) / lambda;
+   return Number.isFinite(result) ? result : -Math.log(u) / lambda;
+ };
 
 export const poisson = (rng, lambda) => {
-  if (!rng || typeof rng.nextFloat !== 'function') {
-    throw new TypeError('First argument must be RNG instance');
-  }
-  if (typeof lambda !== 'number' || lambda <= 0) {
-    throw new Error('lambda must be a positive number');
-  }
+   if (!rng || typeof rng.nextFloat !== 'function') {
+     throw new TypeError('First argument must be RNG instance');
+   }
+   if (typeof lambda !== 'number') {
+     throw new TypeError('lambda must be a number');
+   }
+   if (lambda <= 0) {
+     throw new RangeError('lambda must be positive');
+   }
   
   const L = Math.exp(-lambda);
   let k = 0;
@@ -57,15 +67,69 @@ export const poisson = (rng, lambda) => {
 };
 
 export const uniform = (rng, min, max) => {
-  if (!rng || typeof rng.nextFloat !== 'function') {
-    throw new TypeError('First argument must be RNG instance');
+    if (!rng || typeof rng.nextFloat !== 'function') {
+      throw new TypeError('First argument must be RNG instance');
+    }
+    if (typeof min !== 'number') {
+      throw new TypeError('min must be a number');
+    }
+    if (typeof max !== 'number') {
+      throw new TypeError('max must be a number');
+    }
+    if (min >= max) {
+      throw new RangeError('min must be less than max');
+    }
+   
+    return min + rng.nextFloat() * (max - min);
+  };
+
+export const normals = (rng, count, mean = 0, stddev = 1) => {
+  if (typeof count !== 'number' || !Number.isInteger(count)) {
+    throw new TypeError('count must be an integer');
   }
-  if (typeof min !== 'number' || typeof max !== 'number') {
-    throw new TypeError('min and max must be numbers');
+  if (count <= 0) {
+    throw new RangeError('count must be positive');
   }
-  if (min >= max) {
-    throw new Error('min must be less than max');
+  const result = new Array(count);
+  let cached = null;
+  
+  for (let i = 0; i < count; i++) {
+    if (cached !== null) {
+      result[i] = cached * stddev + mean;
+      cached = null;
+    } else {
+      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);
+      const z1 = Math.sqrt(-2 * Math.log(u1)) * Math.sin(TWO_PI * u2);
+      result[i] = z0 * stddev + mean;
+      cached = z1;
+    }
+  }
+  
+  return result;
+};
+
+export const exponentials = (rng, count, lambda = 1) => {
+  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);
+  
+  for (let i = 0; i < count; i++) {
+    let u = rng.nextFloat();
+    while (u === 0 || u === 1) {
+      u = rng.nextFloat();
+    }
+    result[i] = -Math.log(1 - u) / lambda;
   }
   
-  return min + rng.nextFloat() * (max - min);
+  return result;
 };

package/src/utils/effects.js

@@ -0,0 +1,172 @@
+export function cohensD(group1, group2) {
+  if (!Array.isArray(group1) || group1.length === 0) {
+    throw new TypeError('group1 must be non-empty array');
+  }
+  if (!Array.isArray(group2) || group2.length === 0) {
+    throw new TypeError('group2 must be non-empty array');
+  }
+
+  const n1 = group1.length;
+  const n2 = group2.length;
+
+  const mean1 = group1.reduce((a, b) => a + b, 0) / n1;
+  const mean2 = group2.reduce((a, b) => a + b, 0) / n2;
+
+  let var1 = 0, var2 = 0;
+  for (let i = 0; i < n1; i++) {
+    var1 += (group1[i] - mean1) ** 2;
+  }
+  for (let i = 0; i < n2; i++) {
+    var2 += (group2[i] - mean2) ** 2;
+  }
+
+  var1 /= n1 - 1;
+  var2 /= n2 - 1;
+
+  const pooledStd = Math.sqrt(((n1 - 1) * var1 + (n2 - 1) * var2) / (n1 + n2 - 2));
+
+  return (mean1 - mean2) / pooledStd;
+}
+
+export function hedgesG(group1, group2) {
+  const d = cohensD(group1, group2);
+  const n1 = group1.length;
+  const n2 = group2.length;
+  const n = n1 + n2;
+  const correction = 1 - (3 / (4 * n - 9));
+
+  return d * correction;
+}
+
+export function correlation(x, y) {
+  if (!Array.isArray(x) || !Array.isArray(y)) {
+    throw new TypeError('x and y must be arrays');
+  }
+  if (x.length !== y.length || x.length === 0) {
+    throw new RangeError('x and y must have same non-zero length');
+  }
+
+  const n = x.length;
+  const meanX = x.reduce((a, b) => a + b, 0) / n;
+  const meanY = y.reduce((a, b) => a + b, 0) / n;
+
+  let sumXY = 0, sumX2 = 0, sumY2 = 0;
+
+  for (let i = 0; i < n; i++) {
+    const dx = x[i] - meanX;
+    const dy = y[i] - meanY;
+    sumXY += dx * dy;
+    sumX2 += dx * dx;
+    sumY2 += dy * dy;
+  }
+
+  return sumXY / Math.sqrt(sumX2 * sumY2);
+}
+
+export function cramersV(contingencyTable) {
+  if (!Array.isArray(contingencyTable) || contingencyTable.length === 0) {
+    throw new TypeError('contingencyTable must be non-empty array');
+  }
+
+  const rows = contingencyTable.length;
+  const cols = contingencyTable[0].length;
+
+  let n = 0;
+  for (let i = 0; i < rows; i++) {
+    for (let j = 0; j < cols; j++) {
+      if (typeof contingencyTable[i][j] !== 'number') {
+        throw new TypeError('all table entries must be numbers');
+      }
+      n += contingencyTable[i][j];
+    }
+  }
+
+  let chi2 = 0;
+  const rowTotals = new Array(rows);
+  const colTotals = new Array(cols);
+
+  for (let i = 0; i < rows; i++) {
+    rowTotals[i] = 0;
+    for (let j = 0; j < cols; j++) {
+      rowTotals[i] += contingencyTable[i][j];
+    }
+  }
+
+  for (let j = 0; j < cols; j++) {
+    colTotals[j] = 0;
+    for (let i = 0; i < rows; i++) {
+      colTotals[j] += contingencyTable[i][j];
+    }
+  }
+
+  for (let i = 0; i < rows; i++) {
+    for (let j = 0; j < cols; j++) {
+      const expected = (rowTotals[i] * colTotals[j]) / n;
+      const diff = contingencyTable[i][j] - expected;
+      chi2 += (diff * diff) / expected;
+    }
+  }
+
+  const minDim = Math.min(rows, cols) - 1;
+  return Math.sqrt(chi2 / (n * minDim));
+}
+
+export function etaSquared(groups) {
+  if (!Array.isArray(groups) || groups.length === 0) {
+    throw new TypeError('groups must be non-empty array of arrays');
+  }
+
+  let totalN = 0;
+  const groupMeans = new Array(groups.length);
+  const groupSizes = new Array(groups.length);
+
+  for (let i = 0; i < groups.length; i++) {
+    if (!Array.isArray(groups[i])) {
+      throw new TypeError('each group must be an array');
+    }
+    groupSizes[i] = groups[i].length;
+    totalN += groupSizes[i];
+    groupMeans[i] = groups[i].reduce((a, b) => a + b, 0) / groupSizes[i];
+  }
+
+  const grandMean = groups.flat().reduce((a, b) => a + b, 0) / totalN;
+
+  let ssB = 0;
+  for (let i = 0; i < groups.length; i++) {
+    ssB += groupSizes[i] * (groupMeans[i] - grandMean) ** 2;
+  }
+
+  let ssT = 0;
+  for (let i = 0; i < groups.length; i++) {
+    for (let j = 0; j < groups[i].length; j++) {
+      ssT += (groups[i][j] - grandMean) ** 2;
+    }
+  }
+
+  return ssB / ssT;
+}
+
+export function glasssDelta(control, treatment, pooledStd = null) {
+  if (!Array.isArray(control) || control.length === 0) {
+    throw new TypeError('control must be non-empty array');
+  }
+  if (!Array.isArray(treatment) || treatment.length === 0) {
+    throw new TypeError('treatment must be non-empty array');
+  }
+
+  const meanControl = control.reduce((a, b) => a + b, 0) / control.length;
+  const meanTreatment = treatment.reduce((a, b) => a + b, 0) / treatment.length;
+
+  let std = pooledStd;
+
+  if (std === null) {
+    let varControl = 0;
+    for (let i = 0; i < control.length; i++) {
+      varControl += (control[i] - meanControl) ** 2;
+    }
+    varControl /= control.length - 1;
+    std = Math.sqrt(varControl);
+  }
+
+  return (meanTreatment - meanControl) / std;
+}

package/src/utils/entropy.browser.js

@@ -1,5 +1,6 @@
 let cryptoCache = null;
 let cryptoCacheTime = 0;
+let cryptoCacheBytes = 0;
 
 export const fromPerformance = () => {
   try {
@@ -18,12 +19,12 @@ export const fromMemory = () => {
 };
 
 export const fromCrypto = (bytes = 8) => {
-  try {
-    const now = Date.now();
-    
-    if (cryptoCache && (now - cryptoCacheTime) < 100) {
-      return cryptoCache;
-    }
+   try {
+     const now = Date.now();
+     
+     if (cryptoCache && (now - cryptoCacheTime) < 100 && cryptoCacheBytes === bytes) {
+       return cryptoCache;
+     }
     
     let val = 0n;
     
@@ -39,25 +40,27 @@ export const fromCrypto = (bytes = 8) => {
     
     cryptoCache = val;
     cryptoCacheTime = now;
+    cryptoCacheBytes = bytes;
     return val;
-  } catch {
+    } catch {
     return BigInt(Math.random() * Number.MAX_SAFE_INTEGER);
-  }
-};
-
-export const combined = () => {
-  const perf = fromPerformance();
-  const mem = fromMemory();
-  const crypto = fromCrypto();
-  
-  let mix = perf ^ mem ^ crypto;
-  mix = mix ^ (mix >> 33n);
-  mix = (mix * 0xff51afd7ed558ccdn) & ((1n << 64n) - 1n);
-  
-  return mix !== 0n ? mix : 1n;
-};
-
-export const clearCryptoCache = () => {
-  cryptoCache = null;
-  cryptoCacheTime = 0;
-};
+    }
+    };
+    
+    export const combined = () => {
+    const perf = fromPerformance();
+    const mem = fromMemory();
+    const crypto = fromCrypto();
+    
+    let mix = perf ^ mem ^ crypto;
+    mix = mix ^ (mix >> 33n);
+    mix = (mix * 0xff51afd7ed558ccdn) & ((1n << 64n) - 1n);
+    
+    return mix !== 0n ? mix : 1n;
+    };
+    
+    export const clearCryptoCache = () => {
+    cryptoCache = null;
+    cryptoCacheTime = 0;
+    cryptoCacheBytes = 0;
+    };

package/src/utils/entropy.js

@@ -1,5 +1,6 @@
 let cryptoCache = null;
 let cryptoCacheTime = 0;
+let cryptoCacheBytes = 0;
 
 const isNode = typeof process !== 'undefined' && process.versions && process.versions.node;
 const isBrowser = typeof window !== 'undefined';
@@ -46,13 +47,20 @@ export const fromMemory = () => {
 };
 
 export const fromCrypto = (bytes = 8) => {
-  try {
-    const now = Date.now();
-    
-    if (cryptoCache && (now - cryptoCacheTime) < 100) {
-      return cryptoCache;
+    if (typeof bytes !== 'number' || !Number.isInteger(bytes)) {
+      throw new TypeError('bytes must be an integer');
+    }
+    if (bytes <= 0) {
+      throw new RangeError('bytes must be positive');
     }
     
+    try {
+      const now = Date.now();
+      
+      if (cryptoCache && (now - cryptoCacheTime) < 100 && cryptoCacheBytes === bytes) {
+        return cryptoCache;
+      }
+    
     let val = 0n;
     
     if (randomBytesImpl) {
@@ -72,6 +80,7 @@ export const fromCrypto = (bytes = 8) => {
     
     cryptoCache = val;
     cryptoCacheTime = now;
+    cryptoCacheBytes = bytes;
     return val;
   } catch {
     return BigInt(Math.random() * Number.MAX_SAFE_INTEGER);
@@ -91,6 +100,7 @@ export const combined = () => {
 };
 
 export const clearCryptoCache = () => {
-  cryptoCache = null;
-  cryptoCacheTime = 0;
-};
+   cryptoCache = null;
+   cryptoCacheTime = 0;
+   cryptoCacheBytes = 0;
+ };