@cloudglides/nox 1.1.6 → 2.0.0

package/src/generators/logistic.js

@@ -1,29 +1,34 @@
 export class Logistic {
-   constructor(seed = 0.5, r = 3.99) {
-     if (typeof seed !== 'number' || seed < 0 || seed > 1) {
-       throw new Error('seed must be between 0 and 1');
-     }
-     if (typeof r !== 'number' || r <= 0 || r > 4) {
-       throw new Error('r must be between 0 and 4');
-     }
-     this.x = seed;
-     this.r = r;
-   }
- 
-   next() {
-     this.x = this.r * this.x * (1 - this.x);
-     return this.x;
-   }
- 
-   nextInt(max = 2147483647) {
-     if (max <= 0) {
-       throw new Error('max must be positive');
-     }
-     if (!Number.isInteger(max)) {
-       throw new TypeError('max must be an integer');
-     }
-     return Math.floor(this.next() * max);
-   }
+    constructor(seed = 0.5, r = 3.99) {
+      if (typeof seed !== 'number' || seed < 0 || seed > 1) {
+        throw new Error('seed must be between 0 and 1');
+      }
+      if (typeof r !== 'number' || r <= 0 || r > 4) {
+        throw new Error('r must be between 0 and 4');
+      }
+      this.x = seed;
+      this.r = r;
+    }
+  
+    next() {
+      this.x = this.r * this.x * (1 - this.x);
+      return this.x;
+    }
+  
+    nextInt(max = 2147483647) {
+       if (typeof max !== 'number' || !Number.isInteger(max)) {
+         throw new TypeError('max must be an integer');
+       }
+       if (max <= 0) {
+         throw new RangeError('max must be positive');
+       }
+      const limit = Math.floor(1 / max) * max;
+      let val;
+      do {
+        val = Math.floor(this.next() * Number.MAX_SAFE_INTEGER);
+      } while (val >= limit);
+      return val % max;
+    }
  
    nextFloat() {
      return this.next();

package/src/generators/mixer.js

@@ -24,12 +24,12 @@ export class Mixer {
    }
  
    nextInt(max = 2147483647) {
-     if (max <= 0) {
-       throw new Error('max must be positive');
-     }
-     if (!Number.isInteger(max)) {
-       throw new TypeError('max must be an integer');
-     }
+      if (typeof max !== 'number' || !Number.isInteger(max)) {
+        throw new TypeError('max must be an integer');
+      }
+      if (max <= 0) {
+        throw new RangeError('max must be positive');
+      }
      
      const v1 = this.rng1.nextInt(max);
      const v2 = this.rng2.nextInt(max);
@@ -39,6 +39,6 @@ export class Mixer {
    nextFloat() {
      const f1 = this.rng1.nextFloat();
      const f2 = this.rng2.nextFloat();
-     return Math.abs(f1 - f2);
+     return Math.abs(f1 - f2) % 1.0;
    }
  }

package/src/generators/mt19937.js

@@ -1,5 +1,8 @@
 export class MT19937 {
   constructor(seed = 5489) {
+    if (typeof seed !== 'number' && typeof seed !== 'bigint') {
+      throw new TypeError('Seed must be a number or bigint');
+    }
     this.N = 624;
     this.M = 397;
     this.MATRIX_A = 0x9908b0df;
@@ -52,13 +55,13 @@ export class MT19937 {
   }
 
   nextInt(max = 2147483647) {
-    if (max <= 0) {
-      throw new Error('max must be positive');
-    }
-    
-    if (max < 65536) {
-      return this.next() & 0xFFFF % max;
-    }
+     if (max <= 0) {
+       throw new Error('max must be positive');
+     }
+     
+     if (max < 65536) {
+       return (this.next() & 0xFFFF) % max;
+     }
     
     const limit = Math.floor((0x100000000 / max)) * max;
     let val;

package/src/generators/pcg64.js

@@ -1,11 +1,17 @@
 export class PCG64 {
-  constructor(seed = 1n, inc = 1n) {
-    this.state = 0n;
-    this.inc = ((typeof inc === 'number' ? BigInt(inc) : inc) << 1n) | 1n;
-    this.step();
-    this.state += (typeof seed === 'number' ? BigInt(seed) : seed);
-    this.step();
-  }
+   constructor(seed = 1n, inc = 1n) {
+     if (typeof seed !== 'number' && typeof seed !== 'bigint') {
+       throw new TypeError('Seed must be a number or bigint');
+     }
+     if (typeof inc !== 'number' && typeof inc !== 'bigint') {
+       throw new TypeError('inc must be a number or bigint');
+     }
+     this.state = 0n;
+     this.inc = ((typeof inc === 'number' ? BigInt(inc) : inc) << 1n) | 1n;
+     this.step();
+     this.state += (typeof seed === 'number' ? BigInt(seed) : seed);
+     this.step();
+   }
 
   step() {
     this.state = (this.state * 6364136223846793005n + this.inc) & ((1n << 64n) - 1n);
@@ -15,17 +21,22 @@ export class PCG64 {
     const oldState = this.state;
     this.step();
 
-    const xorShifted = ((oldState >> 18n) ^ oldState) >> 27n;
+    const M = 0x2545F4914F6CDD1Dn;
+    const x = (oldState >> 18n) ^ oldState;
     const rot = oldState >> 59n;
-    const result = (xorShifted >> rot) | ((xorShifted << (64n - rot)) & ((1n << 64n) - 1n));
+    const rotated = (x >> rot) | ((x << (64n - rot)) & ((1n << 64n) - 1n));
+    const result = ((rotated * M) & ((1n << 64n) - 1n)) ^ (rotated >> 29n);
     
     return result;
   }
 
   nextInt(max = 2147483647) {
-    if (max <= 0) {
-      throw new Error('max must be positive');
-    }
+     if (typeof max !== 'number' || !Number.isInteger(max)) {
+       throw new TypeError('max must be an integer');
+     }
+     if (max <= 0) {
+       throw new RangeError('max must be positive');
+     }
     
     if (max < 65536) {
       return Number(this.next() & 0xFFFFn) % max;

package/src/generators/splitmix64.js

@@ -1,7 +1,10 @@
 export class Splitmix64 {
-  constructor(seed = 1) {
-    this.state = BigInt(seed);
-  }
+   constructor(seed = 1) {
+     if (typeof seed !== 'number' && typeof seed !== 'bigint') {
+       throw new TypeError('Seed must be a number or bigint');
+     }
+     this.state = BigInt(seed);
+   }
 
   next() {
     let z = (this.state += 0x9e3779b97f4a7c15n);
@@ -11,9 +14,12 @@ export class Splitmix64 {
   }
 
   nextInt(max = 2147483647) {
-    if (max <= 0) {
-      throw new Error('max must be positive');
-    }
+     if (typeof max !== 'number' || !Number.isInteger(max)) {
+       throw new TypeError('max must be an integer');
+     }
+     if (max <= 0) {
+       throw new RangeError('max must be positive');
+     }
     
     if (max < 65536) {
       return Number(this.next() & 0xFFFFn) % max;

package/src/generators/tent.js

@@ -21,13 +21,18 @@ export class Tent {
    }
  
    nextInt(max = 2147483647) {
-     if (max <= 0) {
-       throw new Error('max must be positive');
-     }
-     if (!Number.isInteger(max)) {
-       throw new TypeError('max must be an integer');
-     }
-     return Math.floor(this.next() * max);
+      if (typeof max !== 'number' || !Number.isInteger(max)) {
+        throw new TypeError('max must be an integer');
+      }
+      if (max <= 0) {
+        throw new RangeError('max must be positive');
+      }
+     const limit = Math.floor(1 / max) * max;
+     let val;
+     do {
+       val = Math.floor(this.next() * Number.MAX_SAFE_INTEGER);
+     } while (val >= limit);
+     return val % max;
    }
  
    nextFloat() {

package/src/generators/xorshift64.js

@@ -17,9 +17,12 @@ export class Xorshift64 {
   }
 
   nextInt(max = 2147483647) {
-    if (max <= 0) {
-      throw new Error('max must be positive');
-    }
+     if (typeof max !== 'number' || !Number.isInteger(max)) {
+       throw new TypeError('max must be an integer');
+     }
+     if (max <= 0) {
+       throw new RangeError('max must be positive');
+     }
     
     if (max < 65536) {
       return Number(this.next() & 0xFFFFn) % max;

package/src/index.d.ts

@@ -29,10 +29,16 @@ export function normal(rng: RNG | IGenerator, mean?: number, stddev?: number): n
 export function exponential(rng: RNG | IGenerator, lambda?: number): number;
 export function uniform(rng: RNG | IGenerator, min: number, max: number): number;
 export function poisson(rng: RNG | IGenerator, lambda: number): number;
+export function normals(rng: RNG | IGenerator, count: number, mean?: number, stddev?: number): number[];
+export function exponentials(rng: RNG | IGenerator, count: number, lambda?: number): number[];
 
 export function shuffle<T>(arr: T[], rng: RNG | IGenerator, inPlace?: boolean): T[];
 export function pick<T>(arr: T[], rng: RNG | IGenerator): T;
 export function sample<T>(arr: T[], count: number, rng: RNG | IGenerator): T[];
+export function sampleWithReplacement<T>(arr: T[], count: number, rng: RNG | IGenerator): T[];
+export function permute<T>(arr: T[], rng: RNG | IGenerator): T[];
+export function range(start: number, end: number, step?: number): number[];
+export function cycle<T>(arr: T[], count: number): T[];
 
 export function saveState(rng: RNG): any;
 export function restoreState(rng: RNG, snapshot: any): void;
@@ -63,6 +69,10 @@ export interface KSTestResult {
 export function meanTest(data: number[], expectedMean?: number): TestResult;
 export function varianceTest(data: number[], expectedVariance?: number): TestResult;
 export function kolmogorovSmirnovTest(data: number[]): KSTestResult;
+export function skewness(data: number[]): number;
+export function kurtosis(data: number[]): number;
+export function median(data: number[]): number;
+export function quantile(data: number[], q: number): number;
 
 export class Xorshift64 {
   constructor(seed?: number | bigint);
@@ -107,8 +117,62 @@ export class Tent {
 }
 
 export class Mixer {
-  constructor(rng1: any, rng2: any);
-  next(): bigint;
-  nextInt(max?: number): number;
-  nextFloat(): number;
+   constructor(rng1: IGenerator, rng2: IGenerator);
+   next(): bigint;
+   nextInt(max?: number): number;
+   nextFloat(): number;
 }
+
+export function beta(rng: RNG | IGenerator, alpha: number, beta: number): number;
+export function gamma(rng: RNG | IGenerator, shape: number, scale?: number): number;
+export function chi2(rng: RNG | IGenerator, k: number): number;
+export function binomial(rng: RNG | IGenerator, n: number, p: number): number;
+export function geometric(rng: RNG | IGenerator, p: number): number;
+export function weibull(rng: RNG | IGenerator, shape: number, scale?: number): number;
+export function lognormal(rng: RNG | IGenerator, mu: number, sigma: number): number;
+export function rayleigh(rng: RNG | IGenerator, sigma?: number): number;
+export function cauchy(rng: RNG | IGenerator, median?: number, scale?: number): number;
+
+export function brownianMotion(rng: RNG | IGenerator, steps: number, dt?: number): number[];
+export function ornsteinUhlenbeck(rng: RNG | IGenerator, steps: number, theta?: number, mu?: number, sigma?: number): number[];
+export function geometricBrownian(rng: RNG | IGenerator, steps: number, mu?: number, sigma?: number, dt?: number): number[];
+
+export function perlin2D(rng: RNG | IGenerator, x: number, y: number, octaves?: number): number;
+export function valueNoise(rng: RNG | IGenerator, x: number, y: number, scale?: number): number;
+
+export function categorical<T>(rng: RNG | IGenerator, categories: T[], probabilities: number[]): T;
+export function multinomial(rng: RNG | IGenerator, n: number, categories: any[], probabilities: number[]): Record<string, number>;
+export function categorical2D(rng: RNG | IGenerator, matrix: number[][]): [number, number];
+
+export function combinations<T>(arr: T[], k: number): T[][];
+export function permutations<T>(arr: T[]): T[][];
+export function kPermutations<T>(arr: T[], k: number): T[][];
+export function randomCombination<T>(arr: T[], k: number, rng: RNG | IGenerator): T[];
+export function randomPermutation<T>(arr: T[], rng: RNG | IGenerator): T[];
+
+export function rotateBits(val: bigint, shift: number | bigint): bigint;
+export function extractBits(val: bigint, start: number, length: number): bigint;
+export function hammingWeight(val: bigint): number;
+export function bitRange(val: bigint, min: number, max: number): bigint;
+export function popcountNum(val: number): number;
+export function clz(val: bigint): number;
+export function ctz(val: bigint): number;
+export function reverseBits(val: bigint, width?: number): bigint;
+export function setBit(val: bigint, pos: number): bigint;
+export function clearBit(val: bigint, pos: number): bigint;
+export function toggleBit(val: bigint, pos: number): bigint;
+
+export class SeedSequence {
+   constructor(entropy?: null | string | number | bigint);
+   next(): bigint;
+   spawn(n?: number): bigint[];
+}
+
+export function seedMultiple(rngClasses: (new (seed?: number | bigint) => IGenerator)[], entropy?: null | string | number | bigint): IGenerator[];
+export function seedFromTime(): bigint;
+export function seedFromEntropy(entropy: string): bigint;
+
+export function chiSquareTest(data: number[], bins?: number): { chi2: number; expected: number; histogram: number[] };
+export function entropy(data: number[], bins?: number): number;
+export function autocorrelation(data: number[], lag: number): number;
+export function runTest(data: number[], threshold?: number): number;

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,154 @@ 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
 } from './core.js';
 
 export {

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)];
    }