@cloudglides/nox 1.1.6 → 3.0.0

package/src/index.js

@@ -6,9 +6,15 @@ export {
   exponential,
   uniform,
   poisson,
+  normals,
+  exponentials,
   shuffle,
   pick,
   sample,
+  sampleWithReplacement,
+  permute,
+  range,
+  cycle,
   saveState,
   restoreState,
   cloneGenerator,
@@ -17,7 +23,168 @@ export {
   reservoirSample,
   meanTest,
   varianceTest,
-  kolmogorovSmirnovTest
+  kolmogorovSmirnovTest,
+  skewness,
+  kurtosis,
+  median,
+  quantile,
+  beta,
+  gamma,
+  chi2,
+  binomial,
+  geometric,
+  weibull,
+  lognormal,
+  rayleigh,
+  cauchy,
+  dirichlet,
+  dirichlets,
+  mixture,
+  mixtures,
+  studentT,
+  studentTs,
+  betaBinomial,
+  brownianMotion,
+  ornsteinUhlenbeck,
+  geometricBrownian,
+  categorical,
+  multinomial,
+  categorical2D,
+  perlin2D,
+  valueNoise,
+  combinations,
+  permutations,
+  kPermutations,
+  randomCombination,
+  randomPermutation,
+  rotateBits,
+  extractBits,
+  hammingWeight,
+  bitRange,
+  popcountNum,
+  clz,
+  ctz,
+  reverseBits,
+  setBit,
+  clearBit,
+  toggleBit,
+  SeedSequence,
+  seedMultiple,
+  seedFromTime,
+  seedFromEntropy,
+  repeat,
+  until,
+  times,
+  chiSquareTest,
+  entropy,
+  autocorrelation,
+  runTest,
+  clearCryptoCache,
+  combined,
+  bootstrap,
+  jackknife,
+  crossValidation,
+  permutationTest,
+  stratifiedSample,
+  stratifiedSampleProportional,
+  stratify,
+  cdf,
+  ppf,
+  sf,
+  WeightedDistribution,
+  CategoricalDistribution,
+  NormalDistribution,
+  bootstrapCI,
+  meanCI,
+  proportionCI,
+  cohensD,
+  hedgesG,
+  correlation,
+  cramersV,
+  etaSquared,
+  glasssDelta,
+  sum,
+  mean,
+  min,
+  max,
+  unique,
+  chunk,
+  flatten,
+  zip,
+  transpose,
+  partition,
+  tTest,
+  welchTTest,
+  mannWhitneyU,
+  oneWayAnova,
+  zscore,
+  standardize,
+  minMaxScale,
+  logTransform,
+  sqrtTransform,
+  rank,
+  robustScale,
+  LinearRegression,
+  MultipleRegression,
+  diff,
+  lag,
+  shift,
+  sma,
+  ema,
+  acf,
+  pacf,
+  matrixAdd,
+  matrixSub,
+  matrixMul,
+  elementwiseMul,
+  scalarMul,
+  determinant,
+  trace,
+  norm,
+  inverse as matrixInverse,
+  trapezoidal,
+  simpsons,
+  adaptiveSimpson,
+  gaussQuadrature,
+  numericalDerivative,
+  numericalSecondDerivative,
+  LinearInterpolator,
+  CubicSplineInterpolator,
+  lagrangeInterpolation,
+  polynomialFit,
+  bisection,
+  newtonRaphson,
+  secant,
+  falsePosition,
+  fixedPoint,
+  eulerMethod,
+  rk4,
+  systemEuler,
+  systemRK4,
+  rk45Adaptive,
+  svd,
+  qr,
+  cholesky,
+  lu,
+  gradientDescent,
+  momentumDescent,
+  adam,
+  simplex,
+  brent,
+  tTestPValue,
+  zTestPValue,
+  fTestPValue,
+  chi2PValue,
+  uTestPValue,
+  pearsonPValue,
+  residualDiagnostics,
+  leverageValues,
+  cookDistance,
+  durwinWatson,
+  vif,
+  LogisticRegression,
+  PolynomialRegression,
+  KMeans
 } from './core.js';
 
 export {
@@ -29,3 +196,4 @@ export {
   Tent,
   Mixer
 } from './generators/index.js';
+

package/src/rng.browser.js

@@ -36,8 +36,7 @@ export class RNG {
      }
      if (min > max) [min, max] = [max, min];
      const range = max - min + 1;
-     let val = Math.floor(this.nextFloat() * range);
-     return val + min;
+     return min + this.nextInt(range);
    }
 
   bool(probability = 0.5) {
@@ -55,13 +54,13 @@ export class RNG {
       throw new TypeError('min, max, and step must be numbers');
     }
     if (!Number.isInteger(min) || !Number.isInteger(max) || !Number.isInteger(step)) {
-      throw new Error('min, max, and step must be integers');
+      throw new TypeError('min, max, and step must be integers');
     }
     if (step <= 0) {
-      throw new Error('step must be positive');
+      throw new RangeError('step must be positive');
     }
     if (min > max) {
-      throw new Error('min must be less than or equal to max');
+      throw new RangeError('min must be less than or equal to max');
     }
 
     const count = Math.floor((max - min) / step) + 1;
@@ -75,7 +74,7 @@ export class RNG {
      }
      const len = arr.length;
      if (len === 0) {
-       throw new TypeError('choice() requires non-empty array');
+       throw new RangeError('choice() requires non-empty array');
      }
      return arr[this.nextInt(len)];
    }

package/src/rng.js

@@ -28,17 +28,16 @@ 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];
-     const range = max - min + 1;
-     let val = Math.floor(this.nextFloat() * range);
-     return val + 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;
+    return min + this.nextInt(range);
+  }
 
   bool(probability = 0.5) {
     if (typeof probability !== 'number') {
@@ -55,13 +54,13 @@ export class RNG {
       throw new TypeError('min, max, and step must be numbers');
     }
     if (!Number.isInteger(min) || !Number.isInteger(max) || !Number.isInteger(step)) {
-      throw new Error('min, max, and step must be integers');
+      throw new TypeError('min, max, and step must be integers');
     }
     if (step <= 0) {
-      throw new Error('step must be positive');
+      throw new RangeError('step must be positive');
     }
     if (min > max) {
-      throw new Error('min must be less than or equal to max');
+      throw new RangeError('min must be less than or equal to max');
     }
 
     const count = Math.floor((max - min) / step) + 1;
@@ -70,91 +69,93 @@ export class RNG {
   }
 
   choice(arr) {
-     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)];
-   }
+    if (!Array.isArray(arr)) {
+      throw new TypeError('choice() requires array');
+    }
+    const len = arr.length;
+    if (len === 0) {
+      throw new RangeError('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 (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;
-   }
+    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 (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');
-     }
-     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) {
-       throw new RangeError('count must be non-negative');
-     }
-     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) {
-       throw new RangeError('count must be non-negative');
-     }
-     if (count === 0) {
-       return [];
-     }
-
-     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) {
+      throw new RangeError('count must be non-negative');
+    }
+    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) {
+      throw new RangeError('count must be non-negative');
+    }
+    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) {
+      throw new RangeError('count must be non-negative');
+    }
+    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/arrays.js

@@ -0,0 +1,149 @@
+export function sum(arr) {
+  if (!Array.isArray(arr)) {
+    throw new TypeError('arr must be array');
+  }
+  let total = 0;
+  for (let i = 0; i < arr.length; i++) {
+    total += arr[i];
+  }
+  return total;
+}
+
+export function mean(arr) {
+  if (!Array.isArray(arr) || arr.length === 0) {
+    throw new TypeError('arr must be non-empty array');
+  }
+  return sum(arr) / arr.length;
+}
+
+export function min(arr) {
+  if (!Array.isArray(arr) || arr.length === 0) {
+    throw new TypeError('arr must be non-empty array');
+  }
+  let minVal = arr[0];
+  for (let i = 1; i < arr.length; i++) {
+    if (arr[i] < minVal) minVal = arr[i];
+  }
+  return minVal;
+}
+
+export function max(arr) {
+  if (!Array.isArray(arr) || arr.length === 0) {
+    throw new TypeError('arr must be non-empty array');
+  }
+  let maxVal = arr[0];
+  for (let i = 1; i < arr.length; i++) {
+    if (arr[i] > maxVal) maxVal = arr[i];
+  }
+  return maxVal;
+}
+
+export function unique(arr) {
+  if (!Array.isArray(arr)) {
+    throw new TypeError('arr must be array');
+  }
+  const seen = new Set();
+  const result = [];
+  for (let i = 0; i < arr.length; i++) {
+    if (!seen.has(arr[i])) {
+      seen.add(arr[i]);
+      result.push(arr[i]);
+    }
+  }
+  return result;
+}
+
+export function chunk(arr, size) {
+  if (!Array.isArray(arr)) {
+    throw new TypeError('arr must be array');
+  }
+  if (typeof size !== 'number' || size < 1) {
+    throw new RangeError('size must be positive integer');
+  }
+
+  const result = [];
+  for (let i = 0; i < arr.length; i += size) {
+    result.push(arr.slice(i, i + size));
+  }
+  return result;
+}
+
+export function flatten(arr, depth = Infinity) {
+  if (!Array.isArray(arr)) {
+    throw new TypeError('arr must be array');
+  }
+  if (typeof depth !== 'number' || depth < 0) {
+    throw new RangeError('depth must be non-negative number');
+  }
+
+  if (depth === 0) return arr;
+
+  const result = [];
+  for (let i = 0; i < arr.length; i++) {
+    if (Array.isArray(arr[i]) && depth > 0) {
+      result.push(...flatten(arr[i], depth - 1));
+    } else {
+      result.push(arr[i]);
+    }
+  }
+  return result;
+}
+
+export function zip(...arrays) {
+  if (arrays.length === 0) {
+    throw new TypeError('at least one array required');
+  }
+
+  for (let i = 0; i < arrays.length; i++) {
+    if (!Array.isArray(arrays[i])) {
+      throw new TypeError(`argument ${i} must be array`);
+    }
+  }
+
+  const minLen = Math.min(...arrays.map(a => a.length));
+  const result = new Array(minLen);
+
+  for (let i = 0; i < minLen; i++) {
+    result[i] = arrays.map(a => a[i]);
+  }
+  return result;
+}
+
+export function transpose(matrix) {
+  if (!Array.isArray(matrix) || matrix.length === 0) {
+    throw new TypeError('matrix must be non-empty 2D array');
+  }
+
+  const cols = matrix[0].length;
+  const result = new Array(cols);
+
+  for (let j = 0; j < cols; j++) {
+    result[j] = new Array(matrix.length);
+    for (let i = 0; i < matrix.length; i++) {
+      result[j][i] = matrix[i][j];
+    }
+  }
+  return result;
+}
+
+export function partition(arr, predicate) {
+  if (!Array.isArray(arr)) {
+    throw new TypeError('arr must be array');
+  }
+  if (typeof predicate !== 'function') {
+    throw new TypeError('predicate must be function');
+  }
+
+  const truthy = [];
+  const falsy = [];
+
+  for (let i = 0; i < arr.length; i++) {
+    if (predicate(arr[i], i)) {
+      truthy.push(arr[i]);
+    } else {
+      falsy.push(arr[i]);
+    }
+  }
+
+  return [truthy, falsy];
+}