superjs-core 0.2.0 → 0.3.0

package/dist/math/index.js

@@ -85,841 +85,20 @@ 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, sample = false) {
-  if (values.length === 0) {
-    throw new RangeError("Cannot compute variance of an empty array");
-  }
-  if (sample && 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 = sample ? values.length - 1 : values.length;
-  return sum(sqDiffs) / divisor;
-}
-function stddev(values, sample = false) {
-  return Math.sqrt(variance(values, sample));
-}
-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 normalize(values) {
-  if (values.length === 0) return [];
-  const min = Math.min(...values);
-  const max = Math.max(...values);
-  if (max === min) return values.map(() => 0);
-  return values.map((v) => (v - min) / (max - min));
-}
-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;
-}
 export {
-  Complex,
   DivisionByZeroError,
-  acos,
   add,
-  amortizationSchedule,
   approxEqual,
-  asin,
-  atan,
-  atan2,
   average,
-  binomial,
   ceil,
   clamp,
-  compoundInterest,
-  correlation,
-  cos,
-  covariance,
-  derivative,
   div,
-  factorial,
-  fibonacci,
   floor,
-  futureValue,
-  gcd,
-  geometricMean,
-  harmonicMean,
-  hypot,
   inRange,
-  integral,
-  irr,
-  isEven,
-  isOdd,
-  isPrime,
-  kurtosis,
-  lcm,
-  lerp,
-  mapRange,
-  matrixAdd,
-  matrixDeterminant,
-  matrixIdentity,
-  matrixInverse,
-  matrixMul,
-  matrixMultiply,
-  matrixScale,
-  matrixSub,
-  matrixTrace,
-  matrixTranspose,
-  median,
-  mode,
   mul,
-  newtonRoot,
-  normalize,
-  npv,
-  percentile,
-  permutation,
-  pmt,
-  presentValue,
-  primeFactors,
-  quartiles,
-  randomBinomial,
-  randomExponential,
   randomInt,
-  randomNormal,
-  randomPoisson,
-  randomUniform,
-  roi,
   round,
-  sign,
-  sin,
-  skewness,
-  standardize,
-  stddev,
   sub,
-  sum,
-  tan,
-  toDegrees,
-  toRadians,
-  trapezoidal,
-  variance,
-  weightedMean,
-  zScore
+  sum
 };
 //# sourceMappingURL=index.js.map