@cloudglides/nox 1.1.5 → 2.0.0

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 };
+}

package/src/utils/optimization.js

@@ -0,0 +1,215 @@
+export function gradientDescent(f, df, x0, learningRate = 0.01, iterations = 100, tol = 1e-6) {
+  if (typeof f !== 'function' || typeof df !== 'function') {
+    throw new TypeError('f and df must be functions');
+  }
+  if (typeof x0 !== 'number') {
+    throw new TypeError('x0 must be number');
+  }
+
+  let x = x0;
+  const history = [x];
+
+  for (let i = 0; i < iterations; i++) {
+    const grad = df(x);
+    const xNew = x - learningRate * grad;
+
+    if (Math.abs(xNew - x) < tol) {
+      history.push(xNew);
+      return { x: xNew, iterations: i + 1, value: f(xNew), history };
+    }
+
+    x = xNew;
+    history.push(x);
+  }
+
+  return { x, iterations, value: f(x), history };
+}
+
+export function momentumDescent(f, df, x0, learningRate = 0.01, momentum = 0.9, iterations = 100, tol = 1e-6) {
+  if (typeof f !== 'function' || typeof df !== 'function') {
+    throw new TypeError('f and df must be functions');
+  }
+  if (typeof x0 !== 'number') {
+    throw new TypeError('x0 must be number');
+  }
+
+  let x = x0;
+  let velocity = 0;
+  const history = [x];
+
+  for (let i = 0; i < iterations; i++) {
+    const grad = df(x);
+    velocity = momentum * velocity + learningRate * grad;
+    const xNew = x - velocity;
+
+    if (Math.abs(xNew - x) < tol) {
+      history.push(xNew);
+      return { x: xNew, iterations: i + 1, value: f(xNew), history };
+    }
+
+    x = xNew;
+    history.push(x);
+  }
+
+  return { x, iterations, value: f(x), history };
+}
+
+export function adam(f, df, x0, learningRate = 0.001, iterations = 100, beta1 = 0.9, beta2 = 0.999, eps = 1e-8, tol = 1e-6) {
+  if (typeof f !== 'function' || typeof df !== 'function') {
+    throw new TypeError('f and df must be functions');
+  }
+  if (typeof x0 !== 'number') {
+    throw new TypeError('x0 must be number');
+  }
+
+  let x = x0;
+  let m = 0;
+  let v = 0;
+  const history = [x];
+
+  for (let t = 1; t <= iterations; t++) {
+    const grad = df(x);
+    
+    m = beta1 * m + (1 - beta1) * grad;
+    v = beta2 * v + (1 - beta2) * grad * grad;
+
+    const mHat = m / (1 - Math.pow(beta1, t));
+    const vHat = v / (1 - Math.pow(beta2, t));
+
+    const xNew = x - learningRate * mHat / (Math.sqrt(vHat) + eps);
+
+    if (Math.abs(xNew - x) < tol) {
+      history.push(xNew);
+      return { x: xNew, iterations: t, value: f(xNew), history };
+    }
+
+    x = xNew;
+    history.push(x);
+  }
+
+  return { x, iterations, value: f(x), history };
+}
+
+export function simplex(f, vertices, maxIter = 1000, tol = 1e-6) {
+  if (typeof f !== 'function') {
+    throw new TypeError('f must be function');
+  }
+  if (!Array.isArray(vertices) || vertices.length < 2) {
+    throw new TypeError('vertices must be array of points');
+  }
+
+  const n = vertices[0].length;
+  let currentVertices = vertices.map(v => [...v]);
+
+  for (let iter = 0; iter < maxIter; iter++) {
+    const values = currentVertices.map(f);
+    
+    const sorted = currentVertices.map((v, i) => [v, values[i]])
+      .sort((a, b) => a[1] - b[1]);
+
+    if (sorted[sorted.length - 1][1] - sorted[0][1] < tol) {
+      return { min: sorted[0][0], value: sorted[0][1], iterations: iter };
+    }
+
+    const best = sorted.slice(0, n).map(x => x[0]);
+    const worst = sorted[sorted.length - 1][0];
+
+    const centroid = new Array(n);
+    for (let i = 0; i < n; i++) {
+      centroid[i] = best.reduce((sum, v) => sum + v[i], 0) / n;
+    }
+
+    const reflected = centroid.map((x, i) => x + (x - worst[i]));
+    const reflectedValue = f(reflected);
+
+    if (reflectedValue < sorted[0][1]) {
+      currentVertices = [...best, reflected];
+    } else if (reflectedValue < sorted[n - 1][1]) {
+      currentVertices = [...best, reflected];
+    } else {
+      const contracted = centroid.map((x, i) => x + 0.5 * (worst[i] - x));
+      currentVertices = [...best, contracted];
+    }
+  }
+
+  const values = currentVertices.map(f);
+  const minIdx = values.indexOf(Math.min(...values));
+  return { min: currentVertices[minIdx], value: values[minIdx], iterations: maxIter };
+}
+
+export function brent(f, a, b, tol = 1e-6, maxIter = 100) {
+  if (typeof f !== 'function') {
+    throw new TypeError('f must be function');
+  }
+  
+  let fa = f(a);
+  let fb = f(b);
+  
+  if (fa * fb > 0) {
+    throw new RangeError('f(a) and f(b) must have opposite signs');
+  }
+
+  if (Math.abs(fa) < Math.abs(fb)) {
+    [a, b] = [b, a];
+    [fa, fb] = [fb, fa];
+  }
+
+  let c = a;
+  let fc = fa;
+  let d = b - a;
+  let e = d;
+
+  for (let i = 0; i < maxIter; i++) {
+    if (Math.abs(fc) < Math.abs(fb)) {
+      a = b;
+      b = c;
+      c = a;
+      fa = fb;
+      fb = fc;
+      fc = fa;
+    }
+
+    const tol1 = tol * Math.abs(b) + 1e-12;
+    const xm = 0.5 * (c - b);
+
+    if (Math.abs(xm) <= tol1 || Math.abs(fb) < 1e-14) {
+      return { root: b, iterations: i + 1, residual: Math.abs(fb) };
+    }
+
+    if (Math.abs(e) >= tol1 && Math.abs(fa) > Math.abs(fb)) {
+      let s = fb / fa;
+      let p, q;
+
+      if (Math.abs(a - c) < 1e-14) {
+        p = 2 * xm * s;
+        q = 1 - s;
+      } else {
+        q = fa / fc;
+        const r = fb / fc;
+        p = s * (2 * xm * q * (q - r) - (b - a) * (r - 1));
+        q = (q - 1) * (r - 1) * (s - 1);
+      }
+
+      if (p > 0) q = -q;
+      else p = -p;
+
+      if (2 * p < 3 * xm * q - Math.abs(tol1 * q) && p < Math.abs(0.5 * e * q)) {
+        e = d;
+        d = p / q;
+      } else {
+        d = xm;
+        e = d;
+      }
+    } else {
+      d = xm;
+      e = d;
+    }
+
+    a = b;
+    fa = fb;
+    b += Math.abs(d) > tol1 ? d : (xm > 0 ? tol1 : -tol1);
+    fb = f(b);
+  }
+
+  return { root: b, iterations: maxIter, residual: Math.abs(fb) };
+}