@cloudglides/nox 1.1.6 → 3.0.0

package/src/utils/distributions-advanced.js

@@ -0,0 +1,122 @@
+import { gamma } from './distributions-extra.js';
+
+export function dirichlet(r, alpha) {
+  if (!Array.isArray(alpha) || alpha.length === 0) {
+    throw new TypeError('alpha must be a non-empty array');
+  }
+  
+  const k = alpha.length;
+  const samples = new Array(k);
+  let sum = 0;
+
+  for (let i = 0; i < k; i++) {
+    if (typeof alpha[i] !== 'number' || alpha[i] <= 0) {
+      throw new RangeError('all alpha values must be positive');
+    }
+    samples[i] = gamma(r, alpha[i], 1);
+    sum += samples[i];
+  }
+
+  for (let i = 0; i < k; i++) {
+    samples[i] /= sum;
+  }
+
+  return samples;
+}
+
+export function dirichlets(r, alpha, n) {
+  if (typeof n !== 'number' || n < 1) {
+    throw new RangeError('n must be a positive integer');
+  }
+
+  const samples = new Array(n);
+  for (let i = 0; i < n; i++) {
+    samples[i] = dirichlet(r, alpha);
+  }
+  return samples;
+}
+
+export function mixture(r, distributions, weights) {
+  if (!Array.isArray(distributions) || distributions.length === 0) {
+    throw new TypeError('distributions must be a non-empty array');
+  }
+  if (!Array.isArray(weights) || weights.length !== distributions.length) {
+    throw new TypeError('weights length must match distributions');
+  }
+
+  let sum = weights.reduce((a, b) => a + b, 0);
+  if (sum <= 0) {
+    throw new RangeError('weights must sum to positive value');
+  }
+
+  const normalized = weights.map(w => w / sum);
+  let u = r.nextFloat();
+  let cumsum = 0;
+
+  for (let i = 0; i < normalized.length; i++) {
+    cumsum += normalized[i];
+    if (u < cumsum) {
+      return distributions[i](r);
+    }
+  }
+
+  return distributions[distributions.length - 1](r);
+}
+
+export function mixtures(r, distributions, weights, n) {
+  if (typeof n !== 'number' || n < 1) {
+    throw new RangeError('n must be a positive integer');
+  }
+
+  const samples = new Array(n);
+  for (let i = 0; i < n; i++) {
+    samples[i] = mixture(r, distributions, weights);
+  }
+  return samples;
+}
+
+export function studentT(r, df) {
+  if (typeof df !== 'number' || df <= 0) {
+    throw new RangeError('degrees of freedom must be positive');
+  }
+
+  const z = r.normal();
+  const u = r.nextFloat();
+  const chi2Val = -2 * Math.log(u) + (df - 1) * Math.log(1 - 2 * u / df);
+  const v = Math.sqrt((df * chi2Val) / (df + z * z));
+
+  return z / v;
+}
+
+export function studentTs(r, df, n) {
+  if (typeof n !== 'number' || n < 1) {
+    throw new RangeError('n must be a positive integer');
+  }
+
+  const samples = new Array(n);
+  for (let i = 0; i < n; i++) {
+    samples[i] = studentT(r, df);
+  }
+  return samples;
+}
+
+export function betaBinomial(r, n, alpha, beta) {
+  if (typeof n !== 'number' || n < 0 || n !== Math.floor(n)) {
+    throw new RangeError('n must be a non-negative integer');
+  }
+  if (typeof alpha !== 'number' || alpha <= 0) {
+    throw new RangeError('alpha must be positive');
+  }
+  if (typeof beta !== 'number' || beta <= 0) {
+    throw new RangeError('beta must be positive');
+  }
+
+  const p = gamma(r, alpha, 1) / (gamma(r, alpha, 1) + gamma(r, beta, 1));
+  let count = 0;
+
+  for (let i = 0; i < n; i++) {
+    if (r.nextFloat() < p) count++;
+  }
+
+  return count;
+}

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