@cloudglides/nox 2.0.0 → 3.0.0

package/example/package.json

@@ -9,7 +9,7 @@
     "preview": "vite preview"
   },
   "dependencies": {
-    "@cloudglides/nox": "^1.1.3",
+    "@cloudglides/nox": "workspace:*",
     "react": "^18.2.0",
     "react-dom": "^18.2.0"
   },

package/example/src/App.jsx

@@ -8,7 +8,7 @@ import {
   tTest, welchTTest, oneWayAnova,
   LinearRegression, MultipleRegression,
   diff, lag, sma, ema, acf,
-  matrixAdd, matrixMul, determinant, inverse,
+  matrixAdd, matrixMul, determinant, matrixInverse,
   trapezoidal, simpsons, numericalDerivative,
   LinearInterpolator, CubicSplineInterpolator,
   bisection, newtonRaphson, brent,
@@ -170,7 +170,7 @@ export default function App() {
       const sum = matrixAdd(A, B)
       const prod = matrixMul(A, B)
       const det = determinant(A)
-      const inv = inverse(A)
+      const inv = matrixInverse(A)
       
       setResults({
         title: 'Matrix Operations',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudglides/nox",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "Unpredictable random number generator with multiple algorithms and distributions",
   "type": "module",
   "main": "src/index.js",

package/pnpm-workspace.yaml

@@ -0,0 +1,3 @@
+packages:
+  - '.'
+  - 'example'

package/src/core.browser.js

@@ -1,18 +1,43 @@
 export { rng, RNG } from './rng.browser.js';
 export { deterministic } from './presets.browser.js';
 
-export { normal, exponential, uniform, poisson } from './utils/distributions.js';
-export { beta, gamma, chi2 } from './utils/distributions-extra.js';
+export { normal, exponential, uniform, poisson, normals, exponentials } from './utils/distributions.js';
+export { beta, gamma, chi2, binomial, geometric } from './utils/distributions-extra.js';
 export { weibull, lognormal, rayleigh, cauchy } from './utils/distributions-special.js';
-export { shuffle, pick, sample } from './utils/sequence.js';
+export { dirichlet, dirichlets, mixture, mixtures, studentT, studentTs, betaBinomial } from './utils/distributions-advanced.js';
+export { shuffle, pick, sample, sampleWithReplacement, permute, range, cycle } from './utils/sequence.js';
 export { saveState, restoreState, cloneGenerator } from './utils/state.js';
 export { weightedPick, weightedSample, reservoirSample } from './utils/sampling.js';
-export { meanTest, varianceTest, kolmogorovSmirnovTest, chiSquareTest, entropy, autocorrelation, runTest } from './utils/statistics.js';
+export { meanTest, varianceTest, kolmogorovSmirnovTest, chiSquareTest, entropy, autocorrelation, runTest, skewness, kurtosis, median, quantile } from './utils/statistics.js';
 export { combined, clearCryptoCache } from './utils/entropy.browser.js';
 export { brownianMotion, ornsteinUhlenbeck, geometricBrownian } from './utils/stochastic.js';
 export { categorical, multinomial, categorical2D } from './utils/categorical.js';
 export { perlin2D, valueNoise } from './utils/noise.js';
 export { combinations, permutations, kPermutations, randomCombination, randomPermutation } from './utils/combinatorics.js';
-export { rotateBits, extractBits, hammingWeight, bitRange } from './utils/bits.js';
+export { rotateBits, extractBits, hammingWeight, bitRange, popcountNum, clz, ctz, reverseBits, setBit, clearBit, toggleBit } from './utils/bits.js';
 export { SeedSequence, seedMultiple } from './utils/seeding.js';
 export { seedFromTime, seedFromEntropy } from './utils/seed.js';
+export { repeat, until, times } from './utils/helpers.js';
+export { bootstrap, jackknife, crossValidation, permutationTest } from './utils/resampling.js';
+export { stratifiedSample, stratifiedSampleProportional, stratify } from './utils/stratified.js';
+export { cdf, ppf, sf } from './utils/probability.js';
+export { WeightedDistribution, CategoricalDistribution, NormalDistribution } from './utils/precomputed.js';
+export { bootstrapCI, meanCI, proportionCI } from './utils/confidence.js';
+export { cohensD, hedgesG, correlation, cramersV, etaSquared, glasssDelta } from './utils/effects.js';
+export { sum, mean, min, max, unique, chunk, flatten, zip, transpose, partition } from './utils/arrays.js';
+export { tTest, welchTTest, mannWhitneyU, oneWayAnova } from './utils/hypothesis.js';
+export { zscore, standardize, minMaxScale, logTransform, sqrtTransform, rank, robustScale } from './utils/transforms.js';
+export { LinearRegression, MultipleRegression } from './utils/regression.js';
+export { diff, lag, shift, sma, ema, acf, pacf } from './utils/timeseries.js';
+export { matrixAdd, matrixSub, matrixMul, elementwiseMul, scalarMul, determinant, trace, norm, inverse as matrixInverse } from './utils/matrix.js';
+export { trapezoidal, simpsons, adaptiveSimpson, gaussQuadrature, numericalDerivative, numericalSecondDerivative } from './utils/integration.js';
+export { LinearInterpolator, CubicSplineInterpolator, lagrangeInterpolation, polynomialFit } from './utils/interpolation.js';
+export { bisection, newtonRaphson, secant, falsePosition, fixedPoint } from './utils/rootfinding.js';
+export { eulerMethod, rk4, systemEuler, systemRK4, rk45Adaptive } from './utils/odesolvers.js';
+export { svd, qr, cholesky, lu } from './utils/decomposition.js';
+export { gradientDescent, momentumDescent, adam, simplex, brent } from './utils/optimization.js';
+export { tTestPValue, zTestPValue, fTestPValue, chi2PValue, uTestPValue, pearsonPValue } from './utils/pvalues.js';
+export { residualDiagnostics, leverageValues, cookDistance, durwinWatson, vif } from './utils/diagnostics.js';
+export { LogisticRegression } from './utils/logistic.js';
+export { PolynomialRegression } from './utils/polynomial.js';
+export { KMeans } from './utils/clustering.js';

package/src/core.js

@@ -36,3 +36,8 @@ export { bisection, newtonRaphson, secant, falsePosition, fixedPoint } from './u
 export { eulerMethod, rk4, systemEuler, systemRK4, rk45Adaptive } from './utils/odesolvers.js';
 export { svd, qr, cholesky, lu } from './utils/decomposition.js';
 export { gradientDescent, momentumDescent, adam, simplex, brent } from './utils/optimization.js';
+export { tTestPValue, zTestPValue, fTestPValue, chi2PValue, uTestPValue, pearsonPValue } from './utils/pvalues.js';
+export { residualDiagnostics, leverageValues, cookDistance, durwinWatson, vif } from './utils/diagnostics.js';
+export { LogisticRegression } from './utils/logistic.js';
+export { PolynomialRegression } from './utils/polynomial.js';
+export { KMeans } from './utils/clustering.js';

package/src/index.browser.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,
+  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.browser.js';
 
 export {

package/src/index.js

@@ -170,7 +170,21 @@ export {
   momentumDescent,
   adam,
   simplex,
-  brent
+  brent,
+  tTestPValue,
+  zTestPValue,
+  fTestPValue,
+  chi2PValue,
+  uTestPValue,
+  pearsonPValue,
+  residualDiagnostics,
+  leverageValues,
+  cookDistance,
+  durwinWatson,
+  vif,
+  LogisticRegression,
+  PolynomialRegression,
+  KMeans
 } from './core.js';
 
 export {
@@ -182,3 +196,4 @@ export {
   Tent,
   Mixer
 } from './generators/index.js';
+

package/src/utils/clustering.js

@@ -0,0 +1,143 @@
+export class KMeans {
+  constructor(k, maxIter = 100, tol = 1e-6) {
+    if (typeof k !== 'number' || k < 1) {
+      throw new RangeError('k must be positive integer');
+    }
+    if (typeof maxIter !== 'number' || maxIter < 1) {
+      throw new RangeError('maxIter must be positive integer');
+    }
+
+    this.k = k;
+    this.maxIter = maxIter;
+    this.tol = tol;
+    this.centroids = null;
+    this.labels = null;
+    this.inertia = null;
+  }
+
+  fit(X) {
+    if (!Array.isArray(X) || X.length === 0) {
+      throw new TypeError('X must be non-empty array');
+    }
+    if (!Array.isArray(X[0]) || X[0].length === 0) {
+      throw new TypeError('X must be array of numeric arrays');
+    }
+
+    const n = X.length;
+    const d = X[0].length;
+
+    if (this.k > n) {
+      throw new RangeError('k cannot exceed number of samples');
+    }
+
+    this.centroids = this._initializeCentroids(X);
+    let prevInertia = Infinity;
+
+    for (let iter = 0; iter < this.maxIter; iter++) {
+      this.labels = this._assignClusters(X);
+      const newCentroids = this._updateCentroids(X);
+      
+      this.inertia = this._calculateInertia(X);
+
+      if (Math.abs(prevInertia - this.inertia) < this.tol) {
+        break;
+      }
+
+      prevInertia = this.inertia;
+      this.centroids = newCentroids;
+    }
+
+    return this;
+  }
+
+  predict(X) {
+    if (this.centroids === null) {
+      throw new Error('Model not fitted. Call fit() first.');
+    }
+    if (!Array.isArray(X) || X.length === 0) {
+      throw new TypeError('X must be non-empty array');
+    }
+
+    return this._assignClusters(X);
+  }
+
+  _initializeCentroids(X) {
+    const indices = new Set();
+    while (indices.size < this.k) {
+      indices.add(Math.floor(Math.random() * X.length));
+    }
+
+    return Array.from(indices).map(i => [...X[i]]);
+  }
+
+  _assignClusters(X) {
+    const labels = new Array(X.length);
+
+    for (let i = 0; i < X.length; i++) {
+      let minDist = Infinity;
+      let bestCluster = 0;
+
+      for (let j = 0; j < this.k; j++) {
+        const dist = this._euclideanDistance(X[i], this.centroids[j]);
+        if (dist < minDist) {
+          minDist = dist;
+          bestCluster = j;
+        }
+      }
+
+      labels[i] = bestCluster;
+    }
+
+    return labels;
+  }
+
+  _updateCentroids(X) {
+    const newCentroids = [];
+    const d = X[0].length;
+
+    for (let j = 0; j < this.k; j++) {
+      const clusterPoints = [];
+
+      for (let i = 0; i < X.length; i++) {
+        if (this.labels[i] === j) {
+          clusterPoints.push(X[i]);
+        }
+      }
+
+      if (clusterPoints.length === 0) {
+        newCentroids.push([...this.centroids[j]]);
+      } else {
+        const centroid = new Array(d).fill(0);
+        for (let dim = 0; dim < d; dim++) {
+          let sum = 0;
+          for (let point of clusterPoints) {
+            sum += point[dim];
+          }
+          centroid[dim] = sum / clusterPoints.length;
+        }
+        newCentroids.push(centroid);
+      }
+    }
+
+    return newCentroids;
+  }
+
+  _euclideanDistance(a, b) {
+    let sum = 0;
+    for (let i = 0; i < a.length; i++) {
+      sum += (a[i] - b[i]) ** 2;
+    }
+    return Math.sqrt(sum);
+  }
+
+  _calculateInertia(X) {
+    let inertia = 0;
+
+    for (let i = 0; i < X.length; i++) {
+      const dist = this._euclideanDistance(X[i], this.centroids[this.labels[i]]);
+      inertia += dist * dist;
+    }
+
+    return inertia;
+  }
+}