@cloudglides/nox 1.1.5 → 2.0.0

package/src/utils/helpers.js

@@ -0,0 +1,64 @@
+export const repeat = (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(i);
+  }
+  return result;
+};
+
+export const until = (fn, maxIterations = Infinity) => {
+  if (typeof fn !== 'function') {
+    throw new TypeError('fn must be a function');
+  }
+  if (maxIterations !== Infinity && (typeof maxIterations !== 'number' || !Number.isInteger(maxIterations))) {
+    throw new TypeError('maxIterations must be an integer or Infinity');
+  }
+  if (maxIterations <= 0) {
+    throw new RangeError('maxIterations must be positive');
+  }
+
+  let iteration = 0;
+  while (iteration < maxIterations) {
+    const result = fn(iteration);
+    if (result) return iteration;
+    iteration++;
+  }
+  return -1;
+};
+
+export const times = (rng, count, fn) => {
+  if (!rng || typeof rng.nextFloat !== 'function') {
+    throw new TypeError('rng must be an RNG instance');
+  }
+  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(rng, i);
+  }
+  return result;
+};

package/src/utils/hypothesis.js

@@ -0,0 +1,167 @@
+export function tTest(group1, group2, paired = false) {
+  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');
+  }
+
+  if (paired) {
+    if (group1.length !== group2.length) {
+      throw new RangeError('paired samples must have equal length');
+    }
+
+    const diff = new Array(group1.length);
+    for (let i = 0; i < group1.length; i++) {
+      diff[i] = group1[i] - group2[i];
+    }
+
+    const n = diff.length;
+    const mean = diff.reduce((a, b) => a + b, 0) / n;
+    let ss = 0;
+
+    for (let i = 0; i < n; i++) {
+      ss += (diff[i] - mean) ** 2;
+    }
+
+    const se = Math.sqrt(ss / (n * (n - 1)));
+    const t = mean / se;
+
+    return { t, df: n - 1, paired: true };
+  }
+
+  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 pooledVar = ((n1 - 1) * var1 + (n2 - 1) * var2) / (n1 + n2 - 2);
+  const se = Math.sqrt(pooledVar * (1 / n1 + 1 / n2));
+  const t = (mean1 - mean2) / se;
+
+  return { t, df: n1 + n2 - 2, meandiff: mean1 - mean2 };
+}
+
+export function welchTTest(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 se = Math.sqrt(var1 / n1 + var2 / n2);
+  const t = (mean1 - mean2) / se;
+
+  const df = (var1 / n1 + var2 / n2) ** 2 / (
+    (var1 / n1) ** 2 / (n1 - 1) + (var2 / n2) ** 2 / (n2 - 1)
+  );
+
+  return { t, df, meandiff: mean1 - mean2 };
+}
+
+export function mannWhitneyU(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 combined = [...group1.map((x, i) => [x, 0, i]), ...group2.map((x, i) => [x, 1, i])];
+  combined.sort((a, b) => a[0] - b[0]);
+
+  const ranks1 = new Array(group1.length);
+  const ranks2 = new Array(group2.length);
+
+  for (let i = 0; i < combined.length; i++) {
+    if (combined[i][1] === 0) {
+      ranks1[combined[i][2]] = i + 1;
+    } else {
+      ranks2[combined[i][2]] = i + 1;
+    }
+  }
+
+  const r1 = ranks1.reduce((a, b) => a + b, 0);
+  const n1 = group1.length;
+  const n2 = group2.length;
+
+  const u1 = n1 * n2 + (n1 * (n1 + 1)) / 2 - r1;
+  const u2 = n1 * n2 - u1;
+
+  const mu = (n1 * n2) / 2;
+  const sigma = Math.sqrt((n1 * n2 * (n1 + n2 + 1)) / 12);
+  const z = (Math.min(u1, u2) - mu) / sigma;
+
+  return { U: Math.min(u1, u2), z, n1, n2 };
+}
+
+export function oneWayAnova(groups) {
+  if (!Array.isArray(groups) || groups.length < 2) {
+    throw new TypeError('groups must be array of at least 2 arrays');
+  }
+
+  let N = 0;
+  const means = new Array(groups.length);
+
+  for (let i = 0; i < groups.length; i++) {
+    if (!Array.isArray(groups[i]) || groups[i].length === 0) {
+      throw new TypeError('each group must be non-empty array');
+    }
+    means[i] = groups[i].reduce((a, b) => a + b, 0) / groups[i].length;
+    N += groups[i].length;
+  }
+
+  const grandMean = groups.flat().reduce((a, b) => a + b, 0) / N;
+
+  let ssB = 0;
+  for (let i = 0; i < groups.length; i++) {
+    ssB += groups[i].length * (means[i] - grandMean) ** 2;
+  }
+
+  let ssW = 0;
+  for (let i = 0; i < groups.length; i++) {
+    for (let j = 0; j < groups[i].length; j++) {
+      ssW += (groups[i][j] - means[i]) ** 2;
+    }
+  }
+
+  const k = groups.length;
+  const dfB = k - 1;
+  const dfW = N - k;
+
+  const msB = ssB / dfB;
+  const msW = ssW / dfW;
+  const f = msB / msW;
+
+  return { f, dfB, dfW, ssB, ssW, msB, msW };
+}

package/src/utils/integration.js

@@ -0,0 +1,137 @@
+export function trapezoidal(f, a, b, n = 100) {
+  if (typeof f !== 'function') {
+    throw new TypeError('f must be function');
+  }
+  if (typeof a !== 'number' || typeof b !== 'number') {
+    throw new TypeError('a and b must be numbers');
+  }
+  if (typeof n !== 'number' || n < 1) {
+    throw new RangeError('n must be positive integer');
+  }
+
+  const h = (b - a) / n;
+  let sum = (f(a) + f(b)) / 2;
+
+  for (let i = 1; i < n; i++) {
+    sum += f(a + i * h);
+  }
+
+  return h * sum;
+}
+
+export function simpsons(f, a, b, n = 100) {
+  if (typeof f !== 'function') {
+    throw new TypeError('f must be function');
+  }
+  if (typeof a !== 'number' || typeof b !== 'number') {
+    throw new TypeError('a and b must be numbers');
+  }
+  if (typeof n !== 'number' || n < 2 || n % 2 !== 0) {
+    throw new RangeError('n must be even integer >= 2');
+  }
+
+  const h = (b - a) / n;
+  let sum = f(a) + f(b);
+
+  for (let i = 1; i < n; i++) {
+    const coeff = i % 2 === 0 ? 2 : 4;
+    sum += coeff * f(a + i * h);
+  }
+
+  return (h / 3) * sum;
+}
+
+export function adaptiveSimpson(f, a, b, tol = 1e-6, depth = 0, maxDepth = 50) {
+  if (typeof f !== 'function') {
+    throw new TypeError('f must be function');
+  }
+  if (typeof a !== 'number' || typeof b !== 'number') {
+    throw new TypeError('a and b must be numbers');
+  }
+
+  const c = (a + b) / 2;
+  const h = b - a;
+  const fa = f(a);
+  const fb = f(b);
+  const fc = f(c);
+
+  const S = (h / 6) * (fa + 4 * fc + fb);
+  const fd = f((a + c) / 2);
+  const fe = f((c + b) / 2);
+
+  const left = (h / 12) * (fa + 4 * fd + fc);
+  const right = (h / 12) * (fc + 4 * fe + fb);
+
+  if (depth >= maxDepth || Math.abs(left + right - S) <= 15 * tol) {
+    return left + right + (left + right - S) / 15;
+  }
+
+  return adaptiveSimpson(f, a, c, tol / 2, depth + 1, maxDepth) +
+         adaptiveSimpson(f, c, b, tol / 2, depth + 1, maxDepth);
+}
+
+export function gaussQuadrature(f, a, b, n = 5) {
+  if (typeof f !== 'function') {
+    throw new TypeError('f must be function');
+  }
+  if (typeof a !== 'number' || typeof b !== 'number') {
+    throw new TypeError('a and b must be numbers');
+  }
+
+  const weights = getGaussWeights(n);
+  const nodes = getGaussNodes(n);
+
+  let sum = 0;
+  for (let i = 0; i < n; i++) {
+    const x = ((b - a) * nodes[i] + (b + a)) / 2;
+    sum += weights[i] * f(x);
+  }
+
+  return ((b - a) / 2) * sum;
+}
+
+function getGaussWeights(n) {
+  const weights = {
+    1: [2],
+    2: [1, 1],
+    3: [0.5555555556, 0.8888888889, 0.5555555556],
+    4: [0.3478548451, 0.6521451549, 0.6521451549, 0.3478548451],
+    5: [0.2369268851, 0.4786286705, 0.5688888889, 0.4786286705, 0.2369268851]
+  };
+
+  return weights[n] || weights[5];
+}
+
+function getGaussNodes(n) {
+  const nodes = {
+    1: [0],
+    2: [-0.5773502692, 0.5773502692],
+    3: [-0.7745966692, 0, 0.7745966692],
+    4: [-0.8611363116, -0.3399810436, 0.3399810436, 0.8611363116],
+    5: [-0.9061798459, -0.5384693101, 0, 0.5384693101, 0.9061798459]
+  };
+
+  return nodes[n] || nodes[5];
+}
+
+export function numericalDerivative(f, x, h = 1e-5) {
+  if (typeof f !== 'function') {
+    throw new TypeError('f must be function');
+  }
+  if (typeof x !== 'number') {
+    throw new TypeError('x must be number');
+  }
+
+  return (f(x + h) - f(x - h)) / (2 * h);
+}
+
+export function numericalSecondDerivative(f, x, h = 1e-5) {
+  if (typeof f !== 'function') {
+    throw new TypeError('f must be function');
+  }
+  if (typeof x !== 'number') {
+    throw new TypeError('x must be number');
+  }
+
+  return (f(x + h) - 2 * f(x) + f(x - h)) / (h * h);
+}

package/src/utils/interpolation.js

@@ -0,0 +1,221 @@
+export class LinearInterpolator {
+  constructor(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 < 2) {
+      throw new RangeError('x and y must have same length >= 2');
+    }
+
+    const sorted = x.map((xi, i) => [xi, y[i]]).sort((a, b) => a[0] - b[0]);
+    this.x = sorted.map(p => p[0]);
+    this.y = sorted.map(p => p[1]);
+  }
+
+  evaluate(xVal) {
+    if (typeof xVal === 'number') {
+      return this._interpolate(xVal);
+    }
+    if (Array.isArray(xVal)) {
+      return xVal.map(x => this._interpolate(x));
+    }
+    throw new TypeError('xVal must be number or array');
+  }
+
+  _interpolate(xVal) {
+    if (xVal < this.x[0] || xVal > this.x[this.x.length - 1]) {
+      throw new RangeError(`xVal must be in [${this.x[0]}, ${this.x[this.x.length - 1]}]`);
+    }
+
+    let i = 0;
+    while (i < this.x.length - 1 && this.x[i + 1] < xVal) {
+      i++;
+    }
+
+    const x0 = this.x[i];
+    const x1 = this.x[i + 1];
+    const y0 = this.y[i];
+    const y1 = this.y[i + 1];
+
+    return y0 + (y1 - y0) * (xVal - x0) / (x1 - x0);
+  }
+}
+
+export class CubicSplineInterpolator {
+  constructor(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 < 3) {
+      throw new RangeError('x and y must have same length >= 3');
+    }
+
+    const sorted = x.map((xi, i) => [xi, y[i]]).sort((a, b) => a[0] - b[0]);
+    this.x = sorted.map(p => p[0]);
+    this.y = sorted.map(p => p[1]);
+
+    this._computeSplines();
+  }
+
+  _computeSplines() {
+    const n = this.x.length;
+    const h = new Array(n - 1);
+    const alpha = new Array(n - 1);
+
+    for (let i = 0; i < n - 1; i++) {
+      h[i] = this.x[i + 1] - this.x[i];
+    }
+
+    for (let i = 1; i < n - 1; i++) {
+      alpha[i] = (3 / h[i]) * (this.y[i + 1] - this.y[i]) - (3 / h[i - 1]) * (this.y[i] - this.y[i - 1]);
+    }
+
+    const l = new Array(n);
+    const mu = new Array(n);
+    const z = new Array(n);
+
+    l[0] = 1;
+    mu[0] = 0;
+    z[0] = 0;
+
+    for (let i = 1; i < n - 1; i++) {
+      l[i] = 2 * (this.x[i + 1] - this.x[i - 1]) - h[i - 1] * mu[i - 1];
+      mu[i] = h[i] / l[i];
+      z[i] = (alpha[i] - h[i - 1] * z[i - 1]) / l[i];
+    }
+
+    l[n - 1] = 1;
+    z[n - 1] = 0;
+
+    this.c = new Array(n);
+    this.b = new Array(n - 1);
+    this.d = new Array(n - 1);
+
+    this.c[n - 1] = 0;
+
+    for (let i = n - 2; i >= 0; i--) {
+      this.c[i] = z[i] - mu[i] * this.c[i + 1];
+      this.b[i] = (this.y[i + 1] - this.y[i]) / h[i] - h[i] * (this.c[i + 1] + 2 * this.c[i]) / 3;
+      this.d[i] = (this.c[i + 1] - this.c[i]) / (3 * h[i]);
+    }
+  }
+
+  evaluate(xVal) {
+    if (typeof xVal === 'number') {
+      return this._interpolate(xVal);
+    }
+    if (Array.isArray(xVal)) {
+      return xVal.map(x => this._interpolate(x));
+    }
+    throw new TypeError('xVal must be number or array');
+  }
+
+  _interpolate(xVal) {
+    if (xVal < this.x[0] || xVal > this.x[this.x.length - 1]) {
+      throw new RangeError(`xVal must be in [${this.x[0]}, ${this.x[this.x.length - 1]}]`);
+    }
+
+    let i = 0;
+    while (i < this.x.length - 1 && this.x[i + 1] < xVal) {
+      i++;
+    }
+
+    const dx = xVal - this.x[i];
+    return this.y[i] + this.b[i] * dx + this.c[i] * dx * dx + this.d[i] * dx * dx * dx;
+  }
+}
+
+export function lagrangeInterpolation(x, y, xVal) {
+  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');
+  }
+
+  if (typeof xVal === 'number') {
+    return _lagrange(x, y, xVal);
+  }
+  if (Array.isArray(xVal)) {
+    return xVal.map(x => _lagrange(x, y, x));
+  }
+  throw new TypeError('xVal must be number or array');
+}
+
+function _lagrange(x, y, xVal) {
+  let result = 0;
+  const n = x.length;
+
+  for (let i = 0; i < n; i++) {
+    let term = y[i];
+    for (let j = 0; j < n; j++) {
+      if (i !== j) {
+        term *= (xVal - x[j]) / (x[i] - x[j]);
+      }
+    }
+    result += term;
+  }
+
+  return result;
+}
+
+export function polynomialFit(x, y, degree) {
+  if (!Array.isArray(x) || !Array.isArray(y)) {
+    throw new TypeError('x and y must be arrays');
+  }
+  if (x.length !== y.length || x.length <= degree) {
+    throw new RangeError('need at least degree+1 points');
+  }
+  if (typeof degree !== 'number' || degree < 1) {
+    throw new RangeError('degree must be positive integer');
+  }
+
+  const n = x.length;
+  const A = new Array(degree + 1);
+
+  for (let i = 0; i <= degree; i++) {
+    A[i] = new Array(degree + 2);
+    for (let j = 0; j <= degree; j++) {
+      let sum = 0;
+      for (let k = 0; k < n; k++) {
+        sum += Math.pow(x[k], i + j);
+      }
+      A[i][j] = sum;
+    }
+
+    let sum = 0;
+    for (let k = 0; k < n; k++) {
+      sum += y[k] * Math.pow(x[k], i);
+    }
+    A[i][degree + 1] = sum;
+  }
+
+  for (let i = 0; i <= degree; i++) {
+    let maxRow = i;
+    for (let k = i + 1; k <= degree; k++) {
+      if (Math.abs(A[k][i]) > Math.abs(A[maxRow][i])) {
+        maxRow = k;
+      }
+    }
+
+    [A[i], A[maxRow]] = [A[maxRow], A[i]];
+
+    for (let k = i + 1; k <= degree; k++) {
+      const factor = A[k][i] / A[i][i];
+      for (let j = i; j <= degree + 1; j++) {
+        A[k][j] -= factor * A[i][j];
+      }
+    }
+  }
+
+  const coeffs = new Array(degree + 1);
+  for (let i = degree; i >= 0; i--) {
+    coeffs[i] = A[i][degree + 1];
+    for (let j = i + 1; j <= degree; j++) {
+      coeffs[i] -= A[i][j] * coeffs[j];
+    }
+    coeffs[i] /= A[i][i];
+  }
+
+  return coeffs;
+}