superjs-core 0.1.0 → 0.2.0

package/dist/index.js

@@ -346,6 +346,753 @@ function randomInt(min, max) {
 function inRange(value, min, max) {
   return value >= min && value <= max;
 }
+function toDegrees(radians) {
+  return radians * (180 / Math.PI);
+}
+function toRadians(degrees) {
+  return degrees * (Math.PI / 180);
+}
+function sin(angle, unit = "rad") {
+  const rad = unit === "deg" ? toRadians(angle) : angle;
+  return Math.sin(rad);
+}
+function cos(angle, unit = "rad") {
+  const rad = unit === "deg" ? toRadians(angle) : angle;
+  return Math.cos(rad);
+}
+function tan(angle, unit = "rad") {
+  const rad = unit === "deg" ? toRadians(angle) : angle;
+  return Math.tan(rad);
+}
+function asin(value) {
+  if (value < -1 || value > 1) {
+    throw new RangeError("Input to asin must be between -1 and 1");
+  }
+  return Math.asin(value);
+}
+function acos(value) {
+  if (value < -1 || value > 1) {
+    throw new RangeError("Input to acos must be between -1 and 1");
+  }
+  return Math.acos(value);
+}
+function atan(value) {
+  return Math.atan(value);
+}
+function atan2(y, x) {
+  return Math.atan2(y, x);
+}
+function hypot(...values) {
+  return Math.hypot(...values);
+}
+function median(values) {
+  if (values.length === 0) {
+    throw new RangeError("Cannot compute median of an empty array");
+  }
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  if (sorted.length % 2 === 0) {
+    return (sorted[mid - 1] + sorted[mid]) / 2;
+  }
+  return sorted[mid];
+}
+function mode(values) {
+  if (values.length === 0) {
+    throw new RangeError("Cannot compute mode of an empty array");
+  }
+  const freq = /* @__PURE__ */ new Map();
+  let maxFreq = 0;
+  for (const v of values) {
+    const f = (freq.get(v) ?? 0) + 1;
+    freq.set(v, f);
+    if (f > maxFreq) maxFreq = f;
+  }
+  if (maxFreq === 1) return [];
+  return Array.from(freq.entries()).filter(([, f]) => f === maxFreq).map(([v]) => v).sort((a, b) => a - b);
+}
+function percentile(values, p) {
+  if (values.length === 0) {
+    throw new RangeError("Cannot compute percentile of an empty array");
+  }
+  if (p < 0 || p > 100) {
+    throw new RangeError("Percentile must be between 0 and 100");
+  }
+  const sorted = [...values].sort((a, b) => a - b);
+  const index = p / 100 * (sorted.length - 1);
+  const lower = Math.floor(index);
+  const upper = Math.ceil(index);
+  if (lower === upper) return sorted[lower];
+  return sorted[lower] + (sorted[upper] - sorted[lower]) * (index - lower);
+}
+function quartiles(values) {
+  if (values.length === 0) {
+    throw new RangeError("Cannot compute quartiles of an empty array");
+  }
+  const sorted = [...values].sort((a, b) => a - b);
+  if (sorted.length === 1) {
+    return { q1: sorted[0], q2: sorted[0], q3: sorted[0] };
+  }
+  const q2 = median(sorted);
+  const mid = Math.floor(sorted.length / 2);
+  const lowerHalf = sorted.slice(0, mid);
+  const upperHalf = sorted.length % 2 === 0 ? sorted.slice(mid) : sorted.slice(mid + 1);
+  return {
+    q1: median(lowerHalf),
+    q2,
+    q3: median(upperHalf)
+  };
+}
+function variance(values, sample2 = false) {
+  if (values.length === 0) {
+    throw new RangeError("Cannot compute variance of an empty array");
+  }
+  if (sample2 && values.length < 2) {
+    throw new RangeError("Sample variance requires at least 2 values");
+  }
+  const mean = average(values);
+  const sqDiffs = values.map((v) => (v - mean) ** 2);
+  const divisor = sample2 ? values.length - 1 : values.length;
+  return sum(sqDiffs) / divisor;
+}
+function stddev(values, sample2 = false) {
+  return Math.sqrt(variance(values, sample2));
+}
+function covariance(x, y) {
+  if (x.length !== y.length) {
+    throw new RangeError("Arrays must have the same length");
+  }
+  if (x.length < 2) {
+    throw new RangeError("Covariance requires at least 2 values");
+  }
+  const meanX = average(x);
+  const meanY = average(y);
+  let total = 0;
+  for (let i = 0; i < x.length; i++) {
+    total += (x[i] - meanX) * (y[i] - meanY);
+  }
+  return total / (x.length - 1);
+}
+function correlation(x, y) {
+  const cov = covariance(x, y);
+  const stdX = stddev(x, true);
+  const stdY = stddev(y, true);
+  if (stdX === 0 || stdY === 0) return 0;
+  return cov / (stdX * stdY);
+}
+function skewness(values) {
+  if (values.length < 3) {
+    throw new RangeError("Skewness requires at least 3 values");
+  }
+  const mean = average(values);
+  const n = values.length;
+  const m2 = sum(values.map((v) => (v - mean) ** 2)) / n;
+  const m3 = sum(values.map((v) => (v - mean) ** 3)) / n;
+  if (m2 === 0) return 0;
+  return m3 / Math.pow(m2, 1.5) * Math.sqrt(n * (n - 1)) / (n - 2);
+}
+function kurtosis(values) {
+  if (values.length < 4) {
+    throw new RangeError("Kurtosis requires at least 4 values");
+  }
+  const mean = average(values);
+  const n = values.length;
+  const m2 = sum(values.map((v) => (v - mean) ** 2)) / n;
+  const m4 = sum(values.map((v) => (v - mean) ** 4)) / n;
+  if (m2 === 0) return 0;
+  const kurt = m4 / (m2 * m2);
+  const adjustment = (n - 1) * (n + 1) / ((n - 2) * (n - 3));
+  return adjustment * (kurt - 3 * (n - 1) / (n + 1));
+}
+function weightedMean(values, weights) {
+  if (values.length !== weights.length) {
+    throw new RangeError("Values and weights must have the same length");
+  }
+  if (values.length === 0) {
+    throw new RangeError("Cannot compute weighted mean of empty arrays");
+  }
+  const totalWeight = sum(weights);
+  if (totalWeight === 0) {
+    throw new RangeError("Sum of weights cannot be zero");
+  }
+  let total = 0;
+  for (let i = 0; i < values.length; i++) {
+    total += values[i] * weights[i];
+  }
+  return total / totalWeight;
+}
+function geometricMean(values) {
+  if (values.length === 0) {
+    throw new RangeError("Cannot compute geometric mean of an empty array");
+  }
+  if (values.some((v) => v <= 0)) {
+    throw new RangeError("Geometric mean requires positive values only");
+  }
+  const logSum = sum(values.map((v) => Math.log(v)));
+  return Math.exp(logSum / values.length);
+}
+function harmonicMean(values) {
+  if (values.length === 0) {
+    throw new RangeError("Cannot compute harmonic mean of an empty array");
+  }
+  if (values.some((v) => v <= 0)) {
+    throw new RangeError("Harmonic mean requires positive values only");
+  }
+  const reciprocalSum = sum(values.map((v) => 1 / v));
+  return values.length / reciprocalSum;
+}
+function zScore(value, mean, stddev2) {
+  if (stddev2 === 0) return 0;
+  return (value - mean) / stddev2;
+}
+function standardize(values) {
+  if (values.length === 0) return [];
+  const mean = average(values);
+  const sd = stddev(values, true);
+  if (sd === 0) return values.map(() => 0);
+  return values.map((v) => (v - mean) / sd);
+}
+function factorial(n) {
+  if (!Number.isInteger(n) || n < 0) {
+    throw new RangeError("Factorial requires a non-negative integer");
+  }
+  if (n === 0 || n === 1) return 1;
+  let result = 1;
+  for (let i = 2; i <= n; i++) {
+    result *= i;
+  }
+  return result;
+}
+function binomial(n, k) {
+  if (!Number.isInteger(n) || !Number.isInteger(k) || n < 0 || k < 0) {
+    throw new RangeError("Binomial requires non-negative integers");
+  }
+  if (k > n) {
+    throw new RangeError("k cannot be greater than n");
+  }
+  if (k === 0 || k === n) return 1;
+  if (k > n - k) return binomial(n, n - k);
+  let result = 1;
+  for (let i = 1; i <= k; i++) {
+    result = result * (n - k + i) / i;
+  }
+  return result;
+}
+function permutation(n, k) {
+  if (!Number.isInteger(n) || !Number.isInteger(k) || n < 0 || k < 0) {
+    throw new RangeError("Permutation requires non-negative integers");
+  }
+  if (k > n) {
+    throw new RangeError("k cannot be greater than n");
+  }
+  let result = 1;
+  for (let i = n; i > n - k; i--) {
+    result *= i;
+  }
+  return result;
+}
+function gcd(...values) {
+  if (values.length < 2) {
+    throw new RangeError("GCD requires at least 2 values");
+  }
+  const gcd2 = (a, b) => {
+    a = Math.abs(a);
+    b = Math.abs(b);
+    while (b !== 0) {
+      const t = b;
+      b = a % b;
+      a = t;
+    }
+    return a;
+  };
+  return values.reduce((a, b) => gcd2(a, b));
+}
+function lcm(...values) {
+  if (values.length < 2) {
+    throw new RangeError("LCM requires at least 2 values");
+  }
+  const lcm2 = (a, b) => {
+    if (a === 0 || b === 0) return 0;
+    return Math.abs(a * b) / gcd(a, b);
+  };
+  return values.reduce((a, b) => lcm2(a, b));
+}
+function isPrime(n) {
+  if (!Number.isInteger(n) || n < 2) return false;
+  if (n === 2) return true;
+  if (n % 2 === 0) return false;
+  const sqrt = Math.sqrt(n);
+  for (let i = 3; i <= sqrt; i += 2) {
+    if (n % i === 0) return false;
+  }
+  return true;
+}
+function primeFactors(n) {
+  if (!Number.isInteger(n) || n < 2) {
+    throw new RangeError("Prime factors require an integer greater than 1");
+  }
+  const factors = [];
+  let num = n;
+  while (num % 2 === 0) {
+    factors.push(2);
+    num /= 2;
+  }
+  for (let i = 3; i <= Math.sqrt(num); i += 2) {
+    while (num % i === 0) {
+      factors.push(i);
+      num /= i;
+    }
+  }
+  if (num > 1) factors.push(num);
+  return factors;
+}
+function fibonacci(n) {
+  if (!Number.isInteger(n) || n < 0) {
+    throw new RangeError("Fibonacci requires a non-negative integer");
+  }
+  if (n === 0) return 0;
+  if (n === 1) return 1;
+  let a = 0;
+  let b = 1;
+  for (let i = 2; i <= n; i++) {
+    const temp = a + b;
+    a = b;
+    b = temp;
+  }
+  return b;
+}
+function isEven(n) {
+  return n % 2 === 0;
+}
+function isOdd(n) {
+  return n % 2 !== 0;
+}
+function sign(n) {
+  if (n > 0) return 1;
+  if (n < 0) return -1;
+  return 0;
+}
+function validateMatrix(a) {
+  if (a.length === 0) throw new RangeError("Matrix cannot be empty");
+  const cols = a[0].length;
+  if (cols === 0) throw new RangeError("Matrix rows cannot be empty");
+  if (a.some((row) => row.length !== cols)) {
+    throw new RangeError("All rows must have the same length");
+  }
+}
+function matrixAdd(a, b) {
+  if (a.length !== b.length || a[0].length !== b[0].length) {
+    throw new RangeError("Matrices must have same dimensions for addition");
+  }
+  validateMatrix(a);
+  return a.map((row, i) => row.map((val, j) => val + b[i][j]));
+}
+function matrixSub(a, b) {
+  if (a.length !== b.length || a[0].length !== b[0].length) {
+    throw new RangeError("Matrices must have same dimensions for subtraction");
+  }
+  validateMatrix(a);
+  return a.map((row, i) => row.map((val, j) => val - b[i][j]));
+}
+function matrixMul(a, b) {
+  if (a.length !== b.length || a[0].length !== b[0].length) {
+    throw new RangeError("Matrices must have same dimensions for element-wise multiplication");
+  }
+  validateMatrix(a);
+  return a.map((row, i) => row.map((val, j) => val * b[i][j]));
+}
+function matrixScale(a, scalar) {
+  validateMatrix(a);
+  return a.map((row) => row.map((val) => val * scalar));
+}
+function matrixTranspose(a) {
+  if (a.length === 0) return [];
+  validateMatrix(a);
+  return a[0].map((_, j) => a.map((row) => row[j]));
+}
+function matrixDeterminant(a) {
+  validateMatrix(a);
+  const n = a.length;
+  if (a.some((row) => row.length !== n)) {
+    throw new RangeError("Matrix must be square for determinant");
+  }
+  if (n > 3) {
+    throw new RangeError("Determinant only supported for max 3x3 matrices");
+  }
+  if (n === 1) return a[0][0];
+  if (n === 2) return a[0][0] * a[1][1] - a[0][1] * a[1][0];
+  const [a00, a01, a02] = a[0];
+  const [a10, a11, a12] = a[1];
+  const [a20, a21, a22] = a[2];
+  return a00 * (a11 * a22 - a12 * a21) - a01 * (a10 * a22 - a12 * a20) + a02 * (a10 * a21 - a11 * a20);
+}
+function matrixInverse(a) {
+  const det = matrixDeterminant(a);
+  if (det === 0) throw new RangeError("Matrix is singular and cannot be inverted");
+  const n = a.length;
+  if (n === 1) return [[1 / a[0][0]]];
+  if (n === 2) {
+    return [
+      [a[1][1] / det, -a[0][1] / det],
+      [-a[1][0] / det, a[0][0] / det]
+    ];
+  }
+  const [a00, a01, a02] = a[0];
+  const [a10, a11, a12] = a[1];
+  const [a20, a21, a22] = a[2];
+  return [
+    [(a11 * a22 - a12 * a21) / det, -(a01 * a22 - a02 * a21) / det, (a01 * a12 - a02 * a11) / det],
+    [-(a10 * a22 - a12 * a20) / det, (a00 * a22 - a02 * a20) / det, -(a00 * a12 - a02 * a10) / det],
+    [(a10 * a21 - a11 * a20) / det, -(a00 * a21 - a01 * a20) / det, (a00 * a11 - a01 * a10) / det]
+  ];
+}
+function matrixIdentity(n) {
+  if (!Number.isInteger(n) || n < 1) {
+    throw new RangeError("Matrix size must be a positive integer");
+  }
+  return Array.from(
+    { length: n },
+    (_, i) => Array.from({ length: n }, (_2, j) => i === j ? 1 : 0)
+  );
+}
+function matrixMultiply(a, b) {
+  validateMatrix(a);
+  validateMatrix(b);
+  if (a[0].length !== b.length) {
+    throw new RangeError("Matrix dimensions incompatible for multiplication");
+  }
+  const result = Array.from(
+    { length: a.length },
+    () => Array(b[0].length).fill(0)
+  );
+  for (let i = 0; i < a.length; i++) {
+    for (let j = 0; j < b[0].length; j++) {
+      for (let k = 0; k < b.length; k++) {
+        result[i][j] = (result[i][j] ?? 0) + (a[i][k] ?? 0) * (b[k][j] ?? 0);
+      }
+    }
+  }
+  return result;
+}
+function matrixTrace(a) {
+  validateMatrix(a);
+  const n = a.length;
+  if (a.some((row) => row.length !== n)) {
+    throw new RangeError("Matrix must be square for trace");
+  }
+  let trace = 0;
+  for (let i = 0; i < n; i++) {
+    trace += a[i][i];
+  }
+  return trace;
+}
+var Complex = class _Complex {
+  constructor(re, im = 0) {
+    this.re = re;
+    this.im = im;
+  }
+  re;
+  im;
+  /**
+   * Adds another complex number.
+   *
+   * @param other - The complex number to add.
+   * @returns A new Complex instance.
+   */
+  add(other) {
+    return new _Complex(this.re + other.re, this.im + other.im);
+  }
+  /**
+   * Subtracts another complex number.
+   *
+   * @param other - The complex number to subtract.
+   * @returns A new Complex instance.
+   */
+  sub(other) {
+    return new _Complex(this.re - other.re, this.im - other.im);
+  }
+  /**
+   * Multiplies by another complex number.
+   *
+   * @param other - The complex number to multiply by.
+   * @returns A new Complex instance.
+   */
+  mul(other) {
+    return new _Complex(
+      this.re * other.re - this.im * other.im,
+      this.re * other.im + this.im * other.re
+    );
+  }
+  /**
+   * Divides by another complex number.
+   *
+   * @param other - The complex number to divide by.
+   * @returns A new Complex instance.
+   * @throws {DivisionByZeroError} If the divisor is zero.
+   */
+  div(other) {
+    const denom = other.re * other.re + other.im * other.im;
+    if (denom === 0) throw new DivisionByZeroError();
+    return new _Complex(
+      (this.re * other.re + this.im * other.im) / denom,
+      (this.im * other.re - this.re * other.im) / denom
+    );
+  }
+  /**
+   * Computes the magnitude (absolute value) of the complex number.
+   *
+   * @returns The magnitude.
+   */
+  abs() {
+    return Math.sqrt(this.re * this.re + this.im * this.im);
+  }
+  /**
+   * Computes the complex conjugate.
+   *
+   * @returns A new Complex instance with negated imaginary part.
+   */
+  conj() {
+    return new _Complex(this.re, this.im === 0 ? 0 : -this.im);
+  }
+  /**
+   * Computes the argument (phase angle) in radians.
+   *
+   * @returns The phase angle.
+   */
+  arg() {
+    return Math.atan2(this.im, this.re);
+  }
+  /**
+   * Raises the complex number to a real power.
+   *
+   * @param n - The exponent.
+   * @returns A new Complex instance.
+   */
+  pow(n) {
+    const r = this.abs();
+    const theta = this.arg();
+    return _Complex.fromPolar(Math.pow(r, n), theta * n);
+  }
+  /**
+   * Computes the square root of the complex number.
+   *
+   * @returns A new Complex instance.
+   */
+  sqrt() {
+    const r = this.abs();
+    const theta = this.arg();
+    return _Complex.fromPolar(Math.sqrt(r), theta / 2);
+  }
+  /**
+   * Computes e raised to this complex number.
+   *
+   * @returns A new Complex instance.
+   */
+  exp() {
+    return new _Complex(
+      Math.exp(this.re) * Math.cos(this.im),
+      Math.exp(this.re) * Math.sin(this.im)
+    );
+  }
+  /**
+   * Computes the natural logarithm of the complex number.
+   *
+   * @returns A new Complex instance.
+   */
+  log() {
+    return new _Complex(Math.log(this.abs()), this.arg());
+  }
+  /**
+   * Computes the sine of the complex number.
+   *
+   * @returns A new Complex instance.
+   */
+  sin() {
+    return new _Complex(
+      Math.sin(this.re) * Math.cosh(this.im),
+      Math.cos(this.re) * Math.sinh(this.im)
+    );
+  }
+  /**
+   * Computes the cosine of the complex number.
+   *
+   * @returns A new Complex instance.
+   */
+  cos() {
+    return new _Complex(
+      Math.cos(this.re) * Math.cosh(this.im),
+      -Math.sin(this.re) * Math.sinh(this.im)
+    );
+  }
+  /**
+   * Returns a string representation of the complex number.
+   *
+   * @returns String like "a + bi".
+   */
+  toString() {
+    if (this.im === 0) return `${this.re}`;
+    if (this.re === 0) return `${this.im}i`;
+    if (this.im < 0) return `${this.re} - ${Math.abs(this.im)}i`;
+    return `${this.re} + ${this.im}i`;
+  }
+  /**
+   * Creates a complex number from polar coordinates.
+   *
+   * @param r - The magnitude.
+   * @param theta - The angle in radians.
+   * @returns A new Complex instance.
+   */
+  static fromPolar(r, theta) {
+    return new _Complex(r * Math.cos(theta), r * Math.sin(theta));
+  }
+  /** The real part. */
+  get real() {
+    return this.re;
+  }
+  /** The imaginary part. */
+  get imag() {
+    return this.im;
+  }
+};
+function compoundInterest(principal, rate, time, n = 12) {
+  return principal * Math.pow(1 + rate / n, n * time);
+}
+function futureValue(pv, rate, nper) {
+  return pv * Math.pow(1 + rate, nper);
+}
+function presentValue(fv, rate, nper) {
+  return fv / Math.pow(1 + rate, nper);
+}
+function pmt(rate, nper, pv, fv = 0) {
+  if (rate === 0) return -(pv + fv) / nper;
+  const pvif = Math.pow(1 + rate, nper);
+  return -(pv * pvif + fv) / ((pvif - 1) / rate);
+}
+function npv(rate, cashflows) {
+  if (cashflows.length === 0) return 0;
+  let result = 0;
+  for (let i = 0; i < cashflows.length; i++) {
+    result += cashflows[i] / Math.pow(1 + rate, i);
+  }
+  return result;
+}
+function irr(cashflows) {
+  if (cashflows.length < 2) {
+    throw new RangeError("IRR requires at least 2 cashflows");
+  }
+  let guess = 0.1;
+  const tolerance = 1e-7;
+  const maxIter = 1e3;
+  for (let i = 0; i < maxIter; i++) {
+    let npvVal = 0;
+    let dnpv = 0;
+    for (let j = 0; j < cashflows.length; j++) {
+      npvVal += cashflows[j] / Math.pow(1 + guess, j);
+      dnpv -= j * cashflows[j] / Math.pow(1 + guess, j + 1);
+    }
+    if (Math.abs(npvVal) < tolerance) return guess;
+    if (dnpv === 0) return NaN;
+    guess -= npvVal / dnpv;
+  }
+  return NaN;
+}
+function roi(gain, cost) {
+  if (cost === 0) throw new RangeError("Cost cannot be zero");
+  return (gain - cost) / cost;
+}
+function amortizationSchedule(principal, rate, nper) {
+  const payment = -pmt(rate, nper, principal);
+  let balance = principal;
+  const schedule = [];
+  for (let period = 1; period <= nper; period++) {
+    const interest = balance * rate;
+    const principalPart = payment - interest;
+    balance -= principalPart;
+    schedule.push({
+      period,
+      payment: Math.round(payment * 100) / 100,
+      interest: Math.round(interest * 100) / 100,
+      principal: Math.round(principalPart * 100) / 100,
+      balance: Math.round(Math.max(balance, 0) * 100) / 100
+    });
+  }
+  return schedule;
+}
+function randomNormal(mean = 0, stddev2 = 1) {
+  let u = 0;
+  let v = 0;
+  while (u === 0) u = Math.random();
+  while (v === 0) v = Math.random();
+  const z = Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
+  return mean + z * stddev2;
+}
+function randomPoisson(lambda) {
+  if (lambda <= 0) throw new RangeError("Lambda must be positive");
+  const L = Math.exp(-lambda);
+  let k = 0;
+  let p = 1;
+  do {
+    k++;
+    p *= Math.random();
+  } while (p > L);
+  return k - 1;
+}
+function randomBinomial(n, p) {
+  if (!Number.isInteger(n) || n < 0) throw new RangeError("n must be a non-negative integer");
+  if (p < 0 || p > 1) throw new RangeError("p must be between 0 and 1");
+  let successes = 0;
+  for (let i = 0; i < n; i++) {
+    if (Math.random() < p) successes++;
+  }
+  return successes;
+}
+function randomExponential(lambda) {
+  if (lambda <= 0) throw new RangeError("Lambda must be positive");
+  return -Math.log(1 - Math.random()) / lambda;
+}
+function randomUniform(min = 0, max = 1) {
+  return Math.random() * (max - min) + min;
+}
+function derivative(f, x, h = 1e-10) {
+  return (f(x + h) - f(x - h)) / (2 * h);
+}
+function integral(f, a, b, n = 100) {
+  if (n % 2 !== 0) {
+    throw new RangeError("Number of subintervals must be even for Simpson's rule");
+  }
+  const h = (b - a) / n;
+  let sum2 = f(a) + f(b);
+  for (let i = 1; i < n; i++) {
+    const x = a + i * h;
+    sum2 += i % 2 === 0 ? 2 * f(x) : 4 * f(x);
+  }
+  return h / 3 * sum2;
+}
+function trapezoidal(f, a, b, n = 100) {
+  const h = (b - a) / n;
+  let sum2 = (f(a) + f(b)) / 2;
+  for (let i = 1; i < n; i++) {
+    sum2 += f(a + i * h);
+  }
+  return h * sum2;
+}
+function newtonRoot(f, guess, tolerance = 1e-7, maxIter = 100) {
+  let x = guess;
+  for (let i = 0; i < maxIter; i++) {
+    const fx = f(x);
+    if (Math.abs(fx) < tolerance) return x;
+    const df = derivative(f, x);
+    if (df === 0) return NaN;
+    x -= fx / df;
+  }
+  return NaN;
+}
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function mapRange(value, inMin, inMax, outMin, outMax) {
+  if (inMax === inMin) throw new RangeError("Input range cannot be zero");
+  return (value - inMin) / (inMax - inMin) * (outMax - outMin) + outMin;
+}
 
 // src/date/index.ts
 var InvalidDateError = class extends Error {
@@ -1366,21 +2113,28 @@ function getType2(value) {
   return "object";
 }
 export {
+  Complex,
   DivisionByZeroError,
   InvalidDateError,
+  acos,
   add,
   addBusinessDays,
   addDays,
   addMonths,
   addYears,
   allSettledMap,
+  amortizationSchedule,
   approxEqual,
+  asin,
   assertDefined,
   assertType,
+  atan,
+  atan2,
   average,
   base64Decode,
   base64Encode,
   basename,
+  binomial,
   calculateAge,
   camelCase,
   capitalize,
@@ -1389,13 +2143,18 @@ export {
   checksum,
   chunk,
   clamp,
+  compoundInterest,
   constantTimeEqual,
+  correlation,
+  cos,
   countOccurrences,
+  covariance,
   dateDiff,
   debounce,
   deepClone,
   deepMerge,
   deferred,
+  derivative,
   dirname,
   div,
   endOfDay,
@@ -1407,18 +2166,27 @@ export {
   envInt,
   escapeHtml,
   extname,
+  factorial,
+  fibonacci,
   first,
   flatten,
   floor,
   format,
   formatDate,
+  futureValue,
+  gcd,
   generateOTP,
   generateToken,
+  geometricMean,
   getType2 as getType,
   groupBy,
+  harmonicMean,
   hash,
+  hypot,
   identity,
   inRange,
+  integral,
+  irr,
   isAbsolute,
   isAfter,
   isArray,
@@ -1428,6 +2196,7 @@ export {
   isBusinessDay,
   isDate,
   isEmpty,
+  isEven,
   isFunction,
   isLeapYear,
   isMap,
@@ -1435,6 +2204,8 @@ export {
   isNull,
   isNumber,
   isObject,
+  isOdd,
+  isPrime,
   isPromise,
   isRegExp,
   isSet,
@@ -1444,12 +2215,30 @@ export {
   join,
   kebabCase,
   keyBy,
+  kurtosis,
   last,
+  lcm,
+  lerp,
+  mapRange,
+  matrixAdd,
+  matrixDeterminant,
+  matrixIdentity,
+  matrixInverse,
+  matrixMul,
+  matrixMultiply,
+  matrixScale,
+  matrixSub,
+  matrixTrace,
+  matrixTranspose,
+  median,
   memoize,
+  mode,
   mul,
   nanoid,
+  newtonRoot,
   noop,
   normalize,
+  npv,
   omit,
   once,
   orderBy,
@@ -1461,36 +2250,57 @@ export {
   parseCsv,
   parseDate,
   pascalCase,
+  percentile,
+  permutation,
   pick,
   pipeline,
   pluck,
+  pmt,
+  presentValue,
+  primeFactors,
+  quartiles,
   raceWithTimeout,
+  randomBinomial,
+  randomExponential,
   randomHex,
   randomInt,
+  randomNormal,
+  randomPoisson,
+  randomUniform,
   relative,
   resolve,
   retry,
   retryAsync,
   reverse,
+  roi,
   round,
   safeJsonParse,
   sample,
   sampleSize,
   shuffle,
+  sign,
   simpleHash,
+  sin,
+  skewness,
   sleep,
   slugify,
   snakeCase,
   sortBy,
+  standardize,
   startOfDay,
   startOfMonth,
   startOfYear,
+  stddev,
   stringifyCsv,
   sub,
   sum,
+  tan,
   template,
   throttle,
   timeout,
+  toDegrees,
+  toRadians,
+  trapezoidal,
   trim,
   trimEnd,
   trimStart,
@@ -1499,7 +2309,10 @@ export {
   uniq,
   uniqueBy,
   uuid,
+  variance,
+  weightedMean,
   words,
-  xorCipher
+  xorCipher,
+  zScore
 };
 //# sourceMappingURL=index.js.map