@cloudglides/nox 1.1.6 → 3.0.0

package/src/utils/logistic.js

@@ -0,0 +1,91 @@
+export class LogisticRegression {
+  constructor(X, y, learningRate = 0.01, iterations = 1000) {
+    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');
+    }
+    if (!Array.isArray(X[0])) {
+      throw new TypeError('X must be array of arrays (features)');
+    }
+    if (y.some(val => val !== 0 && val !== 1)) {
+      throw new RangeError('y must contain only 0 and 1 (binary classification)');
+    }
+
+    const n = X.length;
+    const p = X[0].length;
+
+    this.coefficients = new Array(p + 1).fill(0);
+    this.learningRate = learningRate;
+    this.iterations = iterations;
+
+    for (let iter = 0; iter < iterations; iter++) {
+      const gradients = new Array(p + 1).fill(0);
+
+      for (let i = 0; i < n; i++) {
+        let z = this.coefficients[0];
+        for (let j = 0; j < p; j++) {
+          z += this.coefficients[j + 1] * X[i][j];
+        }
+
+        const sigmoid = 1 / (1 + Math.exp(-z));
+        const error = sigmoid - y[i];
+
+        gradients[0] += error;
+        for (let j = 0; j < p; j++) {
+          gradients[j + 1] += error * X[i][j];
+        }
+      }
+
+      for (let j = 0; j < p + 1; j++) {
+        this.coefficients[j] -= (learningRate / n) * gradients[j];
+      }
+    }
+
+    this.intercept = this.coefficients[0];
+  }
+
+  predict(X) {
+    if (typeof X[0] === 'number') {
+      let z = this.intercept;
+      for (let i = 0; i < X.length; i++) {
+        z += this.coefficients[i + 1] * X[i];
+      }
+      return 1 / (1 + Math.exp(-z));
+    }
+
+    return X.map(row => {
+      let z = this.intercept;
+      for (let i = 0; i < row.length; i++) {
+        z += this.coefficients[i + 1] * row[i];
+      }
+      return 1 / (1 + Math.exp(-z));
+    });
+  }
+
+  predictClass(X, threshold = 0.5) {
+    const probs = this.predict(X);
+    if (Array.isArray(probs)) {
+      return probs.map(p => p >= threshold ? 1 : 0);
+    }
+    return probs >= threshold ? 1 : 0;
+  }
+
+  evaluate(X, y) {
+    if (X.length !== y.length) {
+      throw new RangeError('X and y must have same length');
+    }
+
+    const predictions = this.predictClass(X);
+    let correct = 0;
+
+    for (let i = 0; i < y.length; i++) {
+      if (predictions[i] === y[i]) {
+        correct++;
+      }
+    }
+
+    return correct / y.length;
+  }
+}

package/src/utils/matrix.js

@@ -0,0 +1,242 @@
+export function matrixAdd(A, B) {
+  if (!Array.isArray(A) || !Array.isArray(B)) {
+    throw new TypeError('A and B must be matrices');
+  }
+  if (A.length !== B.length || A[0].length !== B[0].length) {
+    throw new RangeError('matrices must have same dimensions');
+  }
+
+  const result = new Array(A.length);
+  for (let i = 0; i < A.length; i++) {
+    result[i] = new Array(A[0].length);
+    for (let j = 0; j < A[0].length; j++) {
+      result[i][j] = A[i][j] + B[i][j];
+    }
+  }
+  return result;
+}
+
+export function matrixSub(A, B) {
+  if (!Array.isArray(A) || !Array.isArray(B)) {
+    throw new TypeError('A and B must be matrices');
+  }
+  if (A.length !== B.length || A[0].length !== B[0].length) {
+    throw new RangeError('matrices must have same dimensions');
+  }
+
+  const result = new Array(A.length);
+  for (let i = 0; i < A.length; i++) {
+    result[i] = new Array(A[0].length);
+    for (let j = 0; j < A[0].length; j++) {
+      result[i][j] = A[i][j] - B[i][j];
+    }
+  }
+  return result;
+}
+
+export function matrixMul(A, B) {
+  if (!Array.isArray(A) || !Array.isArray(B)) {
+    throw new TypeError('A and B must be matrices');
+  }
+  if (A[0].length !== B.length) {
+    throw new RangeError('incompatible dimensions for multiplication');
+  }
+
+  const result = new Array(A.length);
+  for (let i = 0; i < A.length; i++) {
+    result[i] = new Array(B[0].length);
+    for (let j = 0; j < B[0].length; j++) {
+      let sum = 0;
+      for (let k = 0; k < B.length; k++) {
+        sum += A[i][k] * B[k][j];
+      }
+      result[i][j] = sum;
+    }
+  }
+  return result;
+}
+
+export function elementwiseMul(A, B) {
+  if (!Array.isArray(A) || !Array.isArray(B)) {
+    throw new TypeError('A and B must be matrices');
+  }
+  if (A.length !== B.length || A[0].length !== B[0].length) {
+    throw new RangeError('matrices must have same dimensions');
+  }
+
+  const result = new Array(A.length);
+  for (let i = 0; i < A.length; i++) {
+    result[i] = new Array(A[0].length);
+    for (let j = 0; j < A[0].length; j++) {
+      result[i][j] = A[i][j] * B[i][j];
+    }
+  }
+  return result;
+}
+
+export function scalarMul(scalar, A) {
+  if (typeof scalar !== 'number') {
+    throw new TypeError('scalar must be number');
+  }
+  if (!Array.isArray(A)) {
+    throw new TypeError('A must be matrix');
+  }
+
+  const result = new Array(A.length);
+  for (let i = 0; i < A.length; i++) {
+    result[i] = new Array(A[0].length);
+    for (let j = 0; j < A[0].length; j++) {
+      result[i][j] = scalar * A[i][j];
+    }
+  }
+  return result;
+}
+
+export function transpose(A) {
+  if (!Array.isArray(A) || A.length === 0) {
+    throw new TypeError('A must be non-empty matrix');
+  }
+
+  const result = new Array(A[0].length);
+  for (let j = 0; j < A[0].length; j++) {
+    result[j] = new Array(A.length);
+    for (let i = 0; i < A.length; i++) {
+      result[j][i] = A[i][j];
+    }
+  }
+  return result;
+}
+
+export function determinant(A) {
+  if (!Array.isArray(A) || A.length !== A[0].length) {
+    throw new TypeError('A must be square matrix');
+  }
+
+  const n = A.length;
+  if (n === 1) return A[0][0];
+  if (n === 2) return A[0][0] * A[1][1] - A[0][1] * A[1][0];
+
+  const M = A.map(row => [...row]);
+  let det = 1;
+
+  for (let i = 0; i < n; i++) {
+    let maxRow = i;
+    for (let k = i + 1; k < n; k++) {
+      if (Math.abs(M[k][i]) > Math.abs(M[maxRow][i])) {
+        maxRow = k;
+      }
+    }
+
+    if (Math.abs(M[maxRow][i]) < 1e-10) {
+      return 0;
+    }
+
+    if (maxRow !== i) {
+      [M[i], M[maxRow]] = [M[maxRow], M[i]];
+      det *= -1;
+    }
+
+    det *= M[i][i];
+
+    for (let k = i + 1; k < n; k++) {
+      const factor = M[k][i] / M[i][i];
+      for (let j = i; j < n; j++) {
+        M[k][j] -= factor * M[i][j];
+      }
+    }
+  }
+
+  return det;
+}
+
+export function trace(A) {
+  if (!Array.isArray(A) || A.length !== A[0].length) {
+    throw new TypeError('A must be square matrix');
+  }
+
+  let sum = 0;
+  for (let i = 0; i < A.length; i++) {
+    sum += A[i][i];
+  }
+  return sum;
+}
+
+export function norm(A, type = 'frobenius') {
+  if (!Array.isArray(A)) {
+    throw new TypeError('A must be matrix');
+  }
+
+  if (type === 'frobenius') {
+    let sum = 0;
+    for (let i = 0; i < A.length; i++) {
+      for (let j = 0; j < A[0].length; j++) {
+        sum += A[i][j] * A[i][j];
+      }
+    }
+    return Math.sqrt(sum);
+  }
+
+  if (type === 'spectral') {
+    let maxNorm = 0;
+    for (let j = 0; j < A[0].length; j++) {
+      let colSum = 0;
+      for (let i = 0; i < A.length; i++) {
+        colSum += Math.abs(A[i][j]);
+      }
+      maxNorm = Math.max(maxNorm, colSum);
+    }
+    return maxNorm;
+  }
+
+  throw new RangeError('unknown norm type');
+}
+
+export function inverse(A) {
+  if (!Array.isArray(A) || A.length !== A[0].length) {
+    throw new TypeError('A must be square matrix');
+  }
+
+  const n = A.length;
+  const aug = A.map((row, i) => {
+    const augRow = [...row];
+    for (let j = 0; j < n; j++) {
+      augRow.push(i === j ? 1 : 0);
+    }
+    return augRow;
+  });
+
+  for (let i = 0; i < n; i++) {
+    let maxRow = i;
+    for (let k = i + 1; k < n; k++) {
+      if (Math.abs(aug[k][i]) > Math.abs(aug[maxRow][i])) {
+        maxRow = k;
+      }
+    }
+
+    if (Math.abs(aug[maxRow][i]) < 1e-10) {
+      throw new RangeError('matrix is singular');
+    }
+
+    [aug[i], aug[maxRow]] = [aug[maxRow], aug[i]];
+
+    const pivot = aug[i][i];
+    for (let j = 0; j < 2 * n; j++) {
+      aug[i][j] /= pivot;
+    }
+
+    for (let k = 0; k < n; k++) {
+      if (k !== i) {
+        const factor = aug[k][i];
+        for (let j = 0; j < 2 * n; j++) {
+          aug[k][j] -= factor * aug[i][j];
+        }
+      }
+    }
+  }
+
+  const result = new Array(n);
+  for (let i = 0; i < n; i++) {
+    result[i] = aug[i].slice(n);
+  }
+  return result;
+}

package/src/utils/noise.js

@@ -1,17 +1,13 @@
-const permutation = [151,160,137,91,90,15,131,13,201,95,96,53,194,233,7,225,
-140,36,103,30,69,142,8,99,37,240,21,10,23,190,6,148,
-247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,
-57,177,33,88,237,149,56,87,174,20,125,136,171,168,68,175,
-74,165,71,134,139,48,27,166,77,146,158,231,83,111,229,122,
-60,211,133,230,206,39,323,234,35,158,234,144,12,234,165,
-35,38,112,106,43,23,147,126,65,189,235,64,211,205,230,108,
-248,191,227,21,205,45,94,2,32,284,239,210,246,24,97,78,
-101,40,71,224,255,326,167,21,213,2,223,166,205,57,130,180,
-51,108,203,190,57,74,76,88,207,208,239,170,251,67,77,51,
-133,69,249,2,127,80,60,159,168,81,163,64,143,146,157,41,
-244,8,51,153,78,130,83,142,46,168,134,55,63,160,166,56,
-172,85,24,254,192,221,100,495,32,163,244,236,37,46,28,141,
-149,34,69,193,70,199,154,159,147,12,130,199,10,154,27,112];
+const permutation = [
+  151,160,137,91,90,15,131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,190,6,148,
+  247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,88,237,149,56,87,174,20,125,136,171,168,68,175,
+  74,165,71,134,139,48,27,166,77,146,158,231,83,111,229,122,60,211,133,230,206,39,223,202,148,35,158,236,156,67,126,65,
+  189,238,72,108,248,191,227,21,205,45,94,2,32,230,239,210,246,24,97,78,101,40,71,224,255,200,167,21,213,2,223,166,
+  205,57,130,180,51,108,203,190,57,74,76,88,207,208,239,170,251,67,77,51,133,69,249,2,127,80,60,159,168,81,163,64,
+  143,146,157,41,244,8,51,153,78,130,83,142,46,168,134,55,63,160,166,56,172,85,24,254,192,221,100,73,32,163,244,236,
+  37,46,28,141,149,34,69,193,70,199,154,159,147,12,130,199,10,154,27,112,44,135,58,137,73,109,35,199,17,92,107,203,
+  190,57,74,76,88,207,208,239,170,251,67,77,51,133,69,249,2,127,80,60,159,168,81,163,64,143,146,157,41,51,51,51,51
+];
 
 const fade = (t) => t * t * t * (t * (t * 6 - 15) + 10);
 const lerp = (t, a, b) => a + t * (b - a);
@@ -23,12 +19,21 @@ const grad = (hash, x, y) => {
 };
 
 export const perlin2D = (rng, x, y, octaves = 1) => {
-  let value = 0;
-  let amplitude = 1;
-  let frequency = 1;
-  let maxValue = 0;
-
-  for (let i = 0; i < octaves; i++) {
+    if (typeof x !== 'number' || typeof y !== 'number') {
+      throw new TypeError('x and y must be numbers');
+    }
+    if (typeof octaves !== 'number' || !Number.isInteger(octaves)) {
+      throw new TypeError('octaves must be an integer');
+    }
+    if (octaves <= 0) {
+      throw new RangeError('octaves must be positive');
+    }
+   let value = 0;
+   let amplitude = 1;
+   let frequency = 1;
+   let maxValue = 0;
+
+   for (let i = 0; i < octaves; i++) {
     const xi = Math.floor((x * frequency) % 256);
     const yi = Math.floor((y * frequency) % 256);
 
@@ -60,8 +65,17 @@ export const perlin2D = (rng, x, y, octaves = 1) => {
 };
 
 export const valueNoise = (rng, x, y, scale = 1) => {
-  const sx = Math.floor(x * scale);
-  const sy = Math.floor(y * scale);
+    if (typeof x !== 'number' || typeof y !== 'number') {
+      throw new TypeError('x and y must be numbers');
+    }
+    if (typeof scale !== 'number') {
+      throw new TypeError('scale must be a number');
+    }
+    if (scale <= 0) {
+      throw new RangeError('scale must be positive');
+    }
+   const sx = Math.floor(x * scale);
+   const sy = Math.floor(y * scale);
 
   const n00 = Math.sin(sx * 12.9898 + sy * 78.233) * 43758.5453;
   const n10 = Math.sin((sx + 1) * 12.9898 + sy * 78.233) * 43758.5453;

package/src/utils/odesolvers.js

@@ -0,0 +1,176 @@
+export function eulerMethod(dydt, y0, t0, tf, h) {
+  if (typeof dydt !== 'function') {
+    throw new TypeError('dydt must be function');
+  }
+  if (typeof y0 !== 'number' || typeof t0 !== 'number' || typeof tf !== 'number') {
+    throw new TypeError('y0, t0, tf must be numbers');
+  }
+  if (typeof h !== 'number' || h <= 0) {
+    throw new RangeError('step size h must be positive');
+  }
+
+  const t = [];
+  const y = [];
+  let tCurrent = t0;
+  let yCurrent = y0;
+
+  while (tCurrent <= tf) {
+    t.push(tCurrent);
+    y.push(yCurrent);
+    yCurrent += h * dydt(tCurrent, yCurrent);
+    tCurrent += h;
+  }
+
+  return { t, y };
+}
+
+export function rk4(dydt, y0, t0, tf, h) {
+  if (typeof dydt !== 'function') {
+    throw new TypeError('dydt must be function');
+  }
+  if (typeof y0 !== 'number' || typeof t0 !== 'number' || typeof tf !== 'number') {
+    throw new TypeError('y0, t0, tf must be numbers');
+  }
+  if (typeof h !== 'number' || h <= 0) {
+    throw new RangeError('step size h must be positive');
+  }
+
+  const t = [];
+  const y = [];
+  let tCurrent = t0;
+  let yCurrent = y0;
+
+  while (tCurrent <= tf) {
+    t.push(tCurrent);
+    y.push(yCurrent);
+
+    const k1 = dydt(tCurrent, yCurrent);
+    const k2 = dydt(tCurrent + h / 2, yCurrent + (h / 2) * k1);
+    const k3 = dydt(tCurrent + h / 2, yCurrent + (h / 2) * k2);
+    const k4 = dydt(tCurrent + h, yCurrent + h * k3);
+
+    yCurrent += (h / 6) * (k1 + 2 * k2 + 2 * k3 + k4);
+    tCurrent += h;
+  }
+
+  return { t, y };
+}
+
+export function systemEuler(dydt, y0, t0, tf, h) {
+  if (typeof dydt !== 'function') {
+    throw new TypeError('dydt must be function');
+  }
+  if (!Array.isArray(y0)) {
+    throw new TypeError('y0 must be array');
+  }
+  if (typeof t0 !== 'number' || typeof tf !== 'number') {
+    throw new TypeError('t0, tf must be numbers');
+  }
+  if (typeof h !== 'number' || h <= 0) {
+    throw new RangeError('step size h must be positive');
+  }
+
+  const t = [];
+  const y = [];
+  let tCurrent = t0;
+  let yCurrent = [...y0];
+
+  while (tCurrent <= tf) {
+    t.push(tCurrent);
+    y.push([...yCurrent]);
+
+    const dydt_val = dydt(tCurrent, yCurrent);
+    for (let i = 0; i < yCurrent.length; i++) {
+      yCurrent[i] += h * dydt_val[i];
+    }
+    tCurrent += h;
+  }
+
+  return { t, y };
+}
+
+export function systemRK4(dydt, y0, t0, tf, h) {
+  if (typeof dydt !== 'function') {
+    throw new TypeError('dydt must be function');
+  }
+  if (!Array.isArray(y0)) {
+    throw new TypeError('y0 must be array');
+  }
+  if (typeof t0 !== 'number' || typeof tf !== 'number') {
+    throw new TypeError('t0, tf must be numbers');
+  }
+  if (typeof h !== 'number' || h <= 0) {
+    throw new RangeError('step size h must be positive');
+  }
+
+  const t = [];
+  const y = [];
+  let tCurrent = t0;
+  let yCurrent = [...y0];
+
+  while (tCurrent <= tf) {
+    t.push(tCurrent);
+    y.push([...yCurrent]);
+
+    const k1 = dydt(tCurrent, yCurrent);
+    const y_k2 = yCurrent.map((yi, i) => yi + (h / 2) * k1[i]);
+    const k2 = dydt(tCurrent + h / 2, y_k2);
+    const y_k3 = yCurrent.map((yi, i) => yi + (h / 2) * k2[i]);
+    const k3 = dydt(tCurrent + h / 2, y_k3);
+    const y_k4 = yCurrent.map((yi, i) => yi + h * k3[i]);
+    const k4 = dydt(tCurrent + h, y_k4);
+
+    for (let i = 0; i < yCurrent.length; i++) {
+      yCurrent[i] += (h / 6) * (k1[i] + 2 * k2[i] + 2 * k3[i] + k4[i]);
+    }
+    tCurrent += h;
+  }
+
+  return { t, y };
+}
+
+export function rk45Adaptive(dydt, y0, t0, tf, tol = 1e-6, hmax = (tf - t0) / 10, hmin = 1e-8) {
+  if (typeof dydt !== 'function') {
+    throw new TypeError('dydt must be function');
+  }
+  if (typeof y0 !== 'number') {
+    throw new TypeError('y0 must be number');
+  }
+
+  const t = [t0];
+  const y = [y0];
+  let tCurrent = t0;
+  let yCurrent = y0;
+  let h = hmax;
+
+  while (tCurrent < tf) {
+    if (tCurrent + h > tf) {
+      h = tf - tCurrent;
+    }
+
+    const k1 = dydt(tCurrent, yCurrent);
+    const k2 = dydt(tCurrent + h / 4, yCurrent + (h / 4) * k1);
+    const k3 = dydt(tCurrent + 3 * h / 8, yCurrent + (3 * h / 32) * k1 + (9 * h / 32) * k2);
+    const k4 = dydt(tCurrent + 12 * h / 13, yCurrent + (1932 * h / 2197) * k1 - (7200 * h / 2197) * k2 + (7296 * h / 2197) * k3);
+    const k5 = dydt(tCurrent + h, yCurrent + (439 * h / 216) * k1 - 8 * h * k2 + (3680 * h / 513) * k3 - (845 * h / 4104) * k4);
+    const k6 = dydt(tCurrent + h / 2, yCurrent - (8 * h / 27) * k1 + 2 * h * k2 - (3544 * h / 2565) * k3 + (1859 * h / 4104) * k4 - (11 * h / 40) * k5);
+
+    const y4 = yCurrent + (25 * h / 216) * k1 + (1408 * h / 2565) * k3 + (2197 * h / 4104) * k4 - (h / 5) * k5;
+    const y5 = yCurrent + (16 * h / 135) * k1 + (6656 * h / 12825) * k3 + (28561 * h / 56430) * k4 - (9 * h / 50) * k5 + (2 * h / 55) * k6;
+
+    const error = Math.abs(y5 - y4);
+    const hNew = h * Math.pow(tol / error, 0.2);
+
+    if (error <= tol) {
+      tCurrent += h;
+      yCurrent = y5;
+      t.push(tCurrent);
+      y.push(yCurrent);
+      h = Math.min(Math.max(hNew, hmin), hmax);
+    } else {
+      h = Math.max(hNew, hmin);
+    }
+  }
+
+  return { t, y };
+}