@danielsimonjr/mathts-core 0.3.1 → 0.4.0

package/dist/index.js

@@ -1,557 +1,72 @@
-// src/types/complex.ts
-function isComplex(value) {
-  return value instanceof Complex;
-}
-var Complex = class _Complex {
-  type = "Complex";
-  re;
-  im;
-  constructor(re, im = 0) {
-    this.re = re;
-    this.im = im;
-  }
-  // ============================================================
-  // Static Factory Methods
-  // ============================================================
-  /**
-   * Create a Complex from polar form (r, θ)
-   * @param r - magnitude (radius)
-   * @param theta - angle in radians
-   */
-  static fromPolar(r, theta) {
-    return new _Complex(r * Math.cos(theta), r * Math.sin(theta));
-  }
-  /**
-   * Create a Complex from a real number
-   */
-  static fromNumber(n) {
-    return new _Complex(n, 0);
-  }
-  /**
-   * Create a Complex from a JSON object
-   */
-  static fromJSON(json) {
-    return new _Complex(json.re, json.im);
-  }
-  /**
-   * Parse a complex number from a string
-   * Supports formats: "3+4i", "3-4i", "3", "4i", "-4i", "i", "-i"
-   */
-  static parse(str) {
-    str = str.replace(/\s/g, "");
-    const match = str.match(/^([+-]?[\d.]+)([+-])([\d.]*)i$/);
-    if (match) {
-      const re = parseFloat(match[1]);
-      const sign = match[2] === "-" ? -1 : 1;
-      const imMag = match[3] === "" ? 1 : parseFloat(match[3]);
-      return new _Complex(re, sign * imMag);
-    }
-    if (str.endsWith("i")) {
-      const imStr = str.slice(0, -1);
-      if (imStr === "" || imStr === "+") return new _Complex(0, 1);
-      if (imStr === "-") return new _Complex(0, -1);
-      return new _Complex(0, parseFloat(imStr));
-    }
-    return new _Complex(parseFloat(str), 0);
-  }
-  /**
-   * Compare two complex numbers lexicographically (re first, then im)
-   * @returns -1, 0, or 1
-   */
-  static compare(a, b) {
-    if (a.re > b.re) return 1;
-    if (a.re < b.re) return -1;
-    if (a.im > b.im) return 1;
-    if (a.im < b.im) return -1;
-    return 0;
-  }
-  // ============================================================
-  // Conversion Methods
-  // ============================================================
-  valueOf() {
-    return this.abs();
-  }
-  toString() {
-    if (this.im === 0) return `${this.re}`;
-    if (this.re === 0) {
-      if (this.im === 1) return "i";
-      if (this.im === -1) return "-i";
-      return `${this.im}i`;
-    }
-    const sign = this.im >= 0 ? " + " : " - ";
-    const absIm = Math.abs(this.im);
-    const imStr = absIm === 1 ? "i" : `${absIm}i`;
-    return `${this.re}${sign}${imStr}`;
-  }
-  toJSON() {
-    return { mathjs: "Complex", re: this.re, im: this.im };
-  }
-  /**
-   * Return polar representation
-   */
-  toPolar() {
-    return { r: this.abs(), phi: this.arg() };
-  }
-  /**
-   * Format with options (precision, notation, etc.)
-   */
-  format(options) {
-    const formatNum = (n) => {
-      if (!options) return String(n);
-      if (options.precision !== void 0) {
-        if (options.notation === "exponential") {
-          return n.toExponential(options.precision);
-        }
-        if (options.notation === "fixed") {
-          return n.toFixed(options.precision);
-        }
-        return Number(n.toPrecision(options.precision)).toString();
-      }
-      return String(n);
-    };
-    let re = this.re;
-    let im = this.im;
-    if (options?.precision !== void 0) {
-      const epsilon = Math.pow(10, -options.precision);
-      if (Math.abs(re) < epsilon * Math.abs(im)) re = 0;
-      if (Math.abs(im) < epsilon * Math.abs(re)) im = 0;
-    }
-    if (im === 0) return formatNum(re);
-    if (re === 0) {
-      if (im === 1) return "i";
-      if (im === -1) return "-i";
-      return `${formatNum(im)}i`;
-    }
-    const sign = im < 0 ? " - " : " + ";
-    const absIm = Math.abs(im);
-    if (absIm === 1) {
-      return `${formatNum(re)}${sign}i`;
-    }
-    return `${formatNum(re)}${sign}${formatNum(absIm)}i`;
-  }
-  // ============================================================
-  // Basic Properties
-  // ============================================================
-  /**
-   * Complex conjugate (a + bi → a - bi)
-   */
-  conjugate() {
-    return new _Complex(this.re, -this.im);
-  }
-  /**
-   * Magnitude (absolute value) |z| = √(re² + im²)
-   */
-  abs() {
-    return Math.hypot(this.re, this.im);
-  }
-  /**
-   * Phase angle (argument) in radians, range (-π, π]
-   */
-  arg() {
-    return Math.atan2(this.im, this.re);
-  }
-  /**
-   * Squared magnitude |z|² = re² + im²
-   * More efficient than abs() when you don't need the square root
-   */
-  abs2() {
-    return this.re * this.re + this.im * this.im;
-  }
-  // ============================================================
-  // Arithmetic Operations (Scalar interface)
-  // ============================================================
-  /**
-   * Addition: (a + bi) + (c + di) = (a + c) + (b + d)i
-   */
-  add(other) {
-    if (other instanceof _Complex) {
-      return new _Complex(this.re + other.re, this.im + other.im);
-    }
-    return new _Complex(this.re + Number(other.valueOf()), this.im);
-  }
-  /**
-   * Subtraction: (a + bi) - (c + di) = (a - c) + (b - d)i
-   */
-  subtract(other) {
-    if (other instanceof _Complex) {
-      return new _Complex(this.re - other.re, this.im - other.im);
-    }
-    return new _Complex(this.re - Number(other.valueOf()), this.im);
-  }
-  /**
-   * Multiplication: (a + bi)(c + di) = (ac - bd) + (ad + bc)i
-   */
-  multiply(other) {
-    if (other instanceof _Complex) {
-      return new _Complex(
-        this.re * other.re - this.im * other.im,
-        this.re * other.im + this.im * other.re
-      );
-    }
-    const n = Number(other.valueOf());
-    return new _Complex(this.re * n, this.im * n);
-  }
-  /**
-   * Division: (a + bi)/(c + di) = ((ac + bd) + (bc - ad)i) / (c² + d²)
-   */
-  divide(other) {
-    if (other instanceof _Complex) {
-      const denom = other.re * other.re + other.im * other.im;
-      if (denom === 0) {
-        return new _Complex(
-          this.re !== 0 ? this.re > 0 ? Infinity : -Infinity : NaN,
-          this.im !== 0 ? this.im > 0 ? Infinity : -Infinity : NaN
-        );
-      }
-      return new _Complex(
-        (this.re * other.re + this.im * other.im) / denom,
-        (this.im * other.re - this.re * other.im) / denom
-      );
-    }
-    const n = Number(other.valueOf());
-    if (n === 0) {
-      return new _Complex(
-        this.re !== 0 ? this.re > 0 ? Infinity : -Infinity : NaN,
-        this.im !== 0 ? this.im > 0 ? Infinity : -Infinity : NaN
-      );
-    }
-    return new _Complex(this.re / n, this.im / n);
-  }
-  // ------------------------------------------------------------
-  // Short-name aliases (mathjs-functions calling convention)
-  //
-  // The functions-package typed-function arithmetic (subtractScalar,
-  // multiplyScalar, divideScalar, …) invokes `.add/.sub/.mul/.div/.neg`
-  // on scalars. A core Complex (e.g. produced by `sqrt(-4)`) can flow into
-  // those code paths, so it must answer to the short names too — otherwise
-  // `x.sub is not a function`. Mirrors the Fraction short-alias fix.
-  // ------------------------------------------------------------
-  sub(other) {
-    return this.subtract(other);
-  }
-  mul(other) {
-    return this.multiply(other);
-  }
-  div(other) {
-    return this.divide(other);
-  }
-  neg() {
-    return this.negate();
-  }
-  /**
-   * Negation: -(a + bi) = -a - bi
-   */
-  negate() {
-    return new _Complex(-this.re, -this.im);
-  }
-  /**
-   * Multiplicative inverse: 1/z = z̄/|z|²
-   */
-  inverse() {
-    const denom = this.abs2();
-    if (denom === 0) {
-      return new _Complex(Infinity, Infinity);
-    }
-    return new _Complex(this.re / denom, -this.im / denom);
-  }
-  // ============================================================
-  // Transcendental Functions
-  // ============================================================
-  /**
-   * Square root using principal branch
-   * √z = √r · e^(iθ/2) where r = |z|, θ = arg(z)
-   */
-  sqrt() {
-    const r = this.abs();
-    const theta = this.arg();
-    return _Complex.fromPolar(Math.sqrt(r), theta / 2);
-  }
-  /**
-   * n-th root (returns principal root)
-   */
-  nthRoot(n) {
-    const r = this.abs();
-    const theta = this.arg();
-    return _Complex.fromPolar(Math.pow(r, 1 / n), theta / n);
-  }
-  /**
-   * All n-th roots
-   */
-  nthRoots(n) {
-    const r = this.abs();
-    const theta = this.arg();
-    const rootR = Math.pow(r, 1 / n);
-    const roots = [];
-    for (let k = 0; k < n; k++) {
-      roots.push(_Complex.fromPolar(rootR, (theta + 2 * Math.PI * k) / n));
-    }
-    return roots;
-  }
-  /**
-   * Exponential: e^(a+bi) = e^a · (cos(b) + i·sin(b))
-   */
-  exp() {
-    const ea = Math.exp(this.re);
-    return new _Complex(ea * Math.cos(this.im), ea * Math.sin(this.im));
-  }
-  /**
-   * Natural logarithm: ln(z) = ln|z| + i·arg(z)
-   */
-  log() {
-    return new _Complex(Math.log(this.abs()), this.arg());
-  }
-  /**
-   * Logarithm base 10
-   */
-  log10() {
-    return this.log().divide(new _Complex(Math.LN10, 0));
-  }
-  /**
-   * Logarithm base 2
-   */
-  log2() {
-    return this.log().divide(new _Complex(Math.LN2, 0));
-  }
-  /**
-   * Power: z^w = e^(w·ln(z))
-   */
-  pow(n) {
-    if (typeof n === "number") {
-      if (this.re === 0 && this.im === 0) {
-        return n === 0 ? new _Complex(1, 0) : new _Complex(0, 0);
-      }
-      const r = this.abs();
-      const theta = this.arg();
-      return _Complex.fromPolar(Math.pow(r, n), theta * n);
-    }
-    if (this.re === 0 && this.im === 0) {
-      return new _Complex(0, 0);
-    }
-    return this.log().multiply(n).exp();
-  }
-  // ============================================================
-  // Trigonometric Functions
-  // ============================================================
-  /**
-   * Sine: sin(a + bi) = sin(a)cosh(b) + i·cos(a)sinh(b)
-   */
-  sin() {
-    return new _Complex(
-      Math.sin(this.re) * Math.cosh(this.im),
-      Math.cos(this.re) * Math.sinh(this.im)
-    );
-  }
-  /**
-   * Cosine: cos(a + bi) = cos(a)cosh(b) - i·sin(a)sinh(b)
-   */
-  cos() {
-    return new _Complex(
-      Math.cos(this.re) * Math.cosh(this.im),
-      -Math.sin(this.re) * Math.sinh(this.im)
-    );
-  }
-  /**
-   * Tangent: tan(z) = sin(z) / cos(z)
-   */
-  tan() {
-    return this.sin().divide(this.cos());
-  }
-  /**
-   * Cotangent: cot(z) = cos(z) / sin(z)
-   */
-  cot() {
-    return this.cos().divide(this.sin());
-  }
-  /**
-   * Secant: sec(z) = 1 / cos(z)
-   */
-  sec() {
-    return this.cos().inverse();
-  }
-  /**
-   * Cosecant: csc(z) = 1 / sin(z)
-   */
-  csc() {
-    return this.sin().inverse();
-  }
-  // ============================================================
-  // Hyperbolic Functions
-  // ============================================================
-  /**
-   * Hyperbolic sine: sinh(z) = (e^z - e^(-z)) / 2
-   */
-  sinh() {
-    return new _Complex(
-      Math.sinh(this.re) * Math.cos(this.im),
-      Math.cosh(this.re) * Math.sin(this.im)
-    );
-  }
-  /**
-   * Hyperbolic cosine: cosh(z) = (e^z + e^(-z)) / 2
-   */
-  cosh() {
-    return new _Complex(
-      Math.cosh(this.re) * Math.cos(this.im),
-      Math.sinh(this.re) * Math.sin(this.im)
-    );
-  }
-  /**
-   * Hyperbolic tangent: tanh(z) = sinh(z) / cosh(z)
-   */
-  tanh() {
-    return this.sinh().divide(this.cosh());
-  }
-  /**
-   * Hyperbolic cotangent: coth(z) = cosh(z) / sinh(z)
-   */
-  coth() {
-    return this.cosh().divide(this.sinh());
-  }
-  /**
-   * Hyperbolic secant: sech(z) = 1 / cosh(z)
-   */
-  sech() {
-    return this.cosh().inverse();
-  }
-  /**
-   * Hyperbolic cosecant: csch(z) = 1 / sinh(z)
-   */
-  csch() {
-    return this.sinh().inverse();
-  }
-  // ============================================================
-  // Inverse Trigonometric Functions
-  // ============================================================
-  /**
-   * Arc sine: asin(z) = -i·ln(iz + √(1 - z²))
-   */
-  asin() {
-    const iz = new _Complex(-this.im, this.re);
-    const one = new _Complex(1, 0);
-    const sqrt = one.subtract(this.multiply(this)).sqrt();
-    return iz.add(sqrt).log().multiply(new _Complex(0, -1));
-  }
-  /**
-   * Arc cosine: acos(z) = π/2 - asin(z)
-   */
-  acos() {
-    return new _Complex(Math.PI / 2, 0).subtract(this.asin());
-  }
-  /**
-   * Arc tangent: atan(z) = (i/2)·ln((i + z)/(i - z))
-   */
-  atan() {
-    const i = new _Complex(0, 1);
-    const iHalf = new _Complex(0, 0.5);
-    const num = i.add(this);
-    const denom = i.subtract(this);
-    return num.divide(denom).log().multiply(iHalf);
-  }
-  // ============================================================
-  // Inverse Hyperbolic Functions
-  // ============================================================
-  /**
-   * Inverse hyperbolic sine: asinh(z) = ln(z + √(z² + 1))
-   */
-  asinh() {
-    const one = new _Complex(1, 0);
-    return this.add(this.multiply(this).add(one).sqrt()).log();
-  }
-  /**
-   * Inverse hyperbolic cosine: acosh(z) = ln(z + √(z² - 1))
-   */
-  acosh() {
-    const one = new _Complex(1, 0);
-    return this.add(this.multiply(this).subtract(one).sqrt()).log();
-  }
-  /**
-   * Inverse hyperbolic tangent: atanh(z) = (1/2)·ln((1 + z)/(1 - z))
-   */
-  atanh() {
-    const one = new _Complex(1, 0);
-    const half = new _Complex(0.5, 0);
-    return one.add(this).divide(one.subtract(this)).log().multiply(half);
-  }
-  // ============================================================
-  // Utility Methods
-  // ============================================================
-  /**
-   * Check equality within tolerance
-   */
-  equals(other, epsilon = 1e-12) {
-    return Math.abs(this.re - other.re) < epsilon && Math.abs(this.im - other.im) < epsilon;
-  }
-  /**
-   * Check if this is a real number (im ≈ 0)
-   */
-  isReal(epsilon = 0) {
-    return Math.abs(this.im) <= epsilon;
-  }
-  /**
-   * Check if this is purely imaginary (re ≈ 0, im ≠ 0)
-   */
-  isImaginary(epsilon = 0) {
-    return Math.abs(this.re) <= epsilon && Math.abs(this.im) > epsilon;
-  }
-  /**
-   * Check if this is zero
-   */
-  isZero(epsilon = 0) {
-    return Math.abs(this.re) <= epsilon && Math.abs(this.im) <= epsilon;
-  }
-  /**
-   * Check if this is NaN
-   */
-  isNaN() {
-    return Number.isNaN(this.re) || Number.isNaN(this.im);
-  }
-  /**
-   * Check if this is infinite
-   */
-  isInfinite() {
-    return !this.isNaN() && (!Number.isFinite(this.re) || !Number.isFinite(this.im));
-  }
-  /**
-   * Clone this complex number
-   */
-  clone() {
-    return new _Complex(this.re, this.im);
-  }
-  /**
-   * Round real and imaginary parts to specified decimals
-   */
-  round(decimals = 0) {
-    const factor = Math.pow(10, decimals);
-    return new _Complex(
-      Math.round(this.re * factor) / factor,
-      Math.round(this.im * factor) / factor
-    );
-  }
-  /**
-   * Floor real and imaginary parts
-   */
-  floor() {
-    return new _Complex(Math.floor(this.re), Math.floor(this.im));
-  }
-  /**
-   * Ceil real and imaginary parts
-   */
-  ceil() {
-    return new _Complex(Math.ceil(this.re), Math.ceil(this.im));
-  }
-  /**
-   * Sign function: z / |z| (unit complex number in same direction)
-   */
-  sign() {
-    const r = this.abs();
-    if (r === 0) return new _Complex(0, 0);
-    return new _Complex(this.re / r, this.im / r);
-  }
+import {
+  BIGNUMBER_E,
+  BIGNUMBER_LN10,
+  BIGNUMBER_LN2,
+  BIGNUMBER_NEG_ONE,
+  BIGNUMBER_ONE,
+  BIGNUMBER_PI,
+  BIGNUMBER_TEN,
+  BIGNUMBER_ZERO,
+  BigNumber,
+  COMPLEX_NEG_ONE,
+  COMPLEX_ONE,
+  COMPLEX_ZERO,
+  Complex,
+  DimensionMismatchError,
+  FRACTION_HALF,
+  FRACTION_NEG_ONE,
+  FRACTION_ONE,
+  FRACTION_QUARTER,
+  FRACTION_THIRD,
+  FRACTION_ZERO,
+  Fraction,
+  I,
+  Unit,
+  UnitParseError,
+  abs,
+  addScalar,
+  divideScalar,
+  equal,
+  fix,
+  isBigNumber,
+  isComplex,
+  isFraction,
+  isNumeric,
+  isUnit,
+  multiplyScalar,
+  number,
+  pow,
+  round,
+  subtractScalar
+} from "./chunk-JB4VPWK4.js";
+
+// src/types/dual-rules.ts
+var DUAL_UNARY_RULES = {
+  exp: { primal: Math.exp, deriv: (_x, y) => y },
+  expm1: { primal: Math.expm1, deriv: (_x, y) => y + 1 },
+  log: { primal: Math.log, deriv: (x) => 1 / x },
+  log2: { primal: Math.log2, deriv: (x) => 1 / (x * Math.LN2) },
+  log10: { primal: Math.log10, deriv: (x) => 1 / (x * Math.LN10) },
+  log1p: { primal: Math.log1p, deriv: (x) => 1 / (1 + x) },
+  sin: { primal: Math.sin, deriv: (x) => Math.cos(x) },
+  cos: { primal: Math.cos, deriv: (x) => -Math.sin(x) },
+  tan: { primal: Math.tan, deriv: (x) => 1 / (Math.cos(x) * Math.cos(x)) },
+  asin: { primal: Math.asin, deriv: (x) => 1 / Math.sqrt(1 - x * x) },
+  acos: { primal: Math.acos, deriv: (x) => -1 / Math.sqrt(1 - x * x) },
+  atan: { primal: Math.atan, deriv: (x) => 1 / (1 + x * x) },
+  sinh: { primal: Math.sinh, deriv: (x) => Math.cosh(x) },
+  cosh: { primal: Math.cosh, deriv: (x) => Math.sinh(x) },
+  tanh: { primal: Math.tanh, deriv: (_x, y) => 1 - y * y },
+  asinh: { primal: Math.asinh, deriv: (x) => 1 / Math.sqrt(x * x + 1) },
+  acosh: { primal: Math.acosh, deriv: (x) => 1 / Math.sqrt(x * x - 1) },
+  atanh: { primal: Math.atanh, deriv: (x) => 1 / (1 - x * x) },
+  sqrt: { primal: Math.sqrt, deriv: (_x, y) => 1 / (2 * y) },
+  cbrt: { primal: Math.cbrt, deriv: (_x, y) => 1 / (3 * y * y) },
+  square: { primal: (x) => x * x, deriv: (x) => 2 * x },
+  reciprocal: { primal: (x) => 1 / x, deriv: (x) => -1 / (x * x) },
+  abs: { primal: Math.abs, deriv: (x) => Math.sign(x) },
+  sign: { primal: Math.sign, deriv: () => 0 }
 };
-var I = new Complex(0, 1);
-var COMPLEX_ZERO = new Complex(0, 0);
-var COMPLEX_ONE = new Complex(1, 0);
-var COMPLEX_NEG_ONE = new Complex(-1, 0);
 
 // src/types/dual.ts
 var Dual = class _Dual {
@@ -575,1776 +90,89 @@ var Dual = class _Dual {
   add(o) {
     return new _Dual(this.value + o.value, this.deriv + o.deriv);
   }
-  sub(o) {
-    return new _Dual(this.value - o.value, this.deriv - o.deriv);
-  }
-  mul(o) {
-    return new _Dual(this.value * o.value, this.deriv * o.value + this.value * o.deriv);
-  }
-  div(o) {
-    const d = (this.deriv * o.value - this.value * o.deriv) / (o.value * o.value);
-    return new _Dual(this.value / o.value, d);
-  }
-  neg() {
-    return new _Dual(-this.value, -this.deriv);
-  }
-  /** Power with a constant real exponent: d(xᵏ) = k·xᵏ⁻¹·dx. */
-  powConst(k) {
-    return new _Dual(Math.pow(this.value, k), this.deriv * k * Math.pow(this.value, k - 1));
-  }
-  /** General power a^b: d = a^b·(b'·ln a + b·a'/a). */
-  pow(o) {
-    const v = Math.pow(this.value, o.value);
-    const d = v * (o.deriv * Math.log(this.value) + o.value * this.deriv / this.value);
-    return new _Dual(v, d);
-  }
-  // --- elementary functions ------------------------------------------------
-  sin() {
-    return new _Dual(Math.sin(this.value), this.deriv * Math.cos(this.value));
-  }
-  cos() {
-    return new _Dual(Math.cos(this.value), -this.deriv * Math.sin(this.value));
-  }
-  tan() {
-    const c = Math.cos(this.value);
-    return new _Dual(Math.tan(this.value), this.deriv / (c * c));
-  }
-  exp() {
-    const e = Math.exp(this.value);
-    return new _Dual(e, this.deriv * e);
-  }
-  log() {
-    return new _Dual(Math.log(this.value), this.deriv / this.value);
-  }
-  sqrt() {
-    const s = Math.sqrt(this.value);
-    return new _Dual(s, this.deriv / (2 * s));
-  }
-  square() {
-    return new _Dual(this.value * this.value, 2 * this.value * this.deriv);
-  }
-  abs() {
-    return new _Dual(Math.abs(this.value), this.deriv * Math.sign(this.value));
-  }
-  sinh() {
-    return new _Dual(Math.sinh(this.value), this.deriv * Math.cosh(this.value));
-  }
-  cosh() {
-    return new _Dual(Math.cosh(this.value), this.deriv * Math.sinh(this.value));
-  }
-  tanh() {
-    const t = Math.tanh(this.value);
-    return new _Dual(t, this.deriv * (1 - t * t));
-  }
-  toString() {
-    return `Dual(${this.value}, ${this.deriv})`;
-  }
-};
-function isDual(x) {
-  return x instanceof Dual;
-}
-
-// src/constants.ts
-var PI = Math.PI;
-var E = Math.E;
-var TAU = 2 * Math.PI;
-var PHI = (1 + Math.sqrt(5)) / 2;
-var SQRT2 = Math.SQRT2;
-var SQRT1_2 = Math.SQRT1_2;
-var LN2 = Math.LN2;
-var LN10 = Math.LN10;
-var LOG2E = Math.LOG2E;
-var LOG10E = Math.LOG10E;
-
-// src/types/fraction.ts
-function isFraction(value) {
-  return value instanceof Fraction;
-}
-function gcd(a, b) {
-  a = a < 0n ? -a : a;
-  b = b < 0n ? -b : b;
-  while (b !== 0n) {
-    const t = b;
-    b = a % b;
-    a = t;
-  }
-  return a;
-}
-var Fraction = class _Fraction {
-  type = "Fraction";
-  numerator;
-  denominator;
-  constructor(numerator, denominator = 1n) {
-    const toRatio = (x) => {
-      if (typeof x === "number" && !Number.isInteger(x)) {
-        const f = _Fraction.fromNumber(x);
-        return [f.numerator, f.denominator];
-      }
-      return [typeof x === "bigint" ? x : BigInt(x), 1n];
-    };
-    const [pn, qn] = toRatio(numerator);
-    const [pd, qd] = toRatio(denominator);
-    let num = pn * qd;
-    let den = qn * pd;
-    if (den === 0n) {
-      throw new Error("Fraction denominator cannot be zero");
-    }
-    if (den < 0n) {
-      num = -num;
-      den = -den;
-    }
-    const g = gcd(num, den);
-    this.numerator = num / g;
-    this.denominator = den / g;
-  }
-  // ============================================================
-  // Static Factory Methods
-  // ============================================================
-  /**
-   * Create a Fraction from a number (with optional precision)
-   */
-  static fromNumber(n, maxDenominator = 1000000n) {
-    if (!Number.isFinite(n)) {
-      throw new Error("Cannot create fraction from non-finite number");
-    }
-    if (Number.isInteger(n)) {
-      return new _Fraction(BigInt(n), 1n);
-    }
-    const sign = n < 0 ? -1n : 1n;
-    n = Math.abs(n);
-    let h1 = 1n, h2 = 0n;
-    let k1 = 0n, k2 = 1n;
-    let b = n;
-    do {
-      const a = BigInt(Math.floor(b));
-      let aux = h1;
-      h1 = a * h1 + h2;
-      h2 = aux;
-      aux = k1;
-      k1 = a * k1 + k2;
-      k2 = aux;
-      b = 1 / (b - Number(a));
-    } while (Math.abs(n - Number(h1) / Number(k1)) > Number.EPSILON && k1 < maxDenominator);
-    return new _Fraction(sign * h1, k1);
-  }
-  /**
-   * Create a Fraction from a decimal string
-   */
-  static fromDecimalString(str) {
-    str = str.trim();
-    const repeatingMatch = str.match(/^(-?\d*)\.(\d*)\((\d+)\)$/);
-    if (repeatingMatch) {
-      const sign2 = str.startsWith("-") ? -1n : 1n;
-      const intPart2 = repeatingMatch[1] === "-" ? "0" : repeatingMatch[1] || "0";
-      const nonRepeating = repeatingMatch[2] || "";
-      const repeating = repeatingMatch[3];
-      const fullDigits = intPart2 + nonRepeating + repeating;
-      const nonRepDigits = intPart2 + nonRepeating;
-      const fullNum = BigInt(fullDigits.replace("-", ""));
-      const nonRepNum = BigInt(nonRepDigits.replace("-", "") || "0");
-      const nines = BigInt("9".repeat(repeating.length));
-      const zeros = BigInt("1" + "0".repeat(nonRepeating.length));
-      const num2 = fullNum - nonRepNum;
-      const den2 = nines * zeros;
-      return new _Fraction(sign2 * num2, den2);
-    }
-    const [intPart, decPart = ""] = str.split(".");
-    const sign = str.startsWith("-") ? -1n : 1n;
-    const absInt = intPart.replace("-", "") || "0";
-    const combined = absInt + decPart;
-    const num = BigInt(combined);
-    const den = BigInt("1" + "0".repeat(decPart.length));
-    return new _Fraction(sign * num, den);
-  }
-  /**
-   * Parse a fraction from a string
-   * Supports formats: "3/4", "-3/4", "3", "3.14", "0.(3)"
-   */
-  static parse(str) {
-    str = str.trim();
-    if (str.includes("/")) {
-      const [numStr, denStr] = str.split("/");
-      return new _Fraction(BigInt(numStr.trim()), BigInt(denStr.trim()));
-    }
-    if (str.includes(".") || str.includes("(")) {
-      return _Fraction.fromDecimalString(str);
-    }
-    return new _Fraction(BigInt(str), 1n);
-  }
-  /**
-   * Create a Fraction from a JSON object
-   */
-  static fromJSON(json) {
-    if ("n" in json) {
-      return new _Fraction(BigInt(json.n), BigInt(json.d));
-    }
-    return new _Fraction(BigInt(json.numerator), BigInt(json.denominator));
-  }
-  /**
-   * Compare two fractions
-   * @returns -1, 0, or 1
-   */
-  static compare(a, b) {
-    const diff = a.numerator * b.denominator - b.numerator * a.denominator;
-    if (diff < 0n) return -1;
-    if (diff > 0n) return 1;
-    return 0;
-  }
-  // ============================================================
-  // Conversion Methods
-  // ============================================================
-  valueOf() {
-    return Number(this.numerator) / Number(this.denominator);
-  }
-  toString() {
-    if (this.denominator === 1n) {
-      return this.numerator.toString();
-    }
-    return `${this.numerator}/${this.denominator}`;
-  }
-  toJSON() {
-    return {
-      mathjs: "Fraction",
-      n: this.numerator.toString(),
-      d: this.denominator.toString()
-    };
-  }
-  /**
-   * Convert to number
-   */
-  toNumber() {
-    return this.valueOf();
-  }
-  /**
-   * Convert to decimal string with specified precision
-   */
-  toDecimal(precision = 10) {
-    const sign = this.numerator < 0n ? "-" : "";
-    let num = this.numerator < 0n ? -this.numerator : this.numerator;
-    const den = this.denominator;
-    const intPart = num / den;
-    num = num % den;
-    if (num === 0n || precision === 0) {
-      return sign + intPart.toString();
-    }
-    let decPart = "";
-    for (let i = 0; i < precision && num !== 0n; i++) {
-      num *= 10n;
-      decPart += (num / den).toString();
-      num = num % den;
-    }
-    return sign + intPart.toString() + "." + decPart;
-  }
-  /**
-   * Convert to LaTeX string
-   */
-  toLatex() {
-    if (this.denominator === 1n) {
-      return this.numerator.toString();
-    }
-    const sign = this.numerator < 0n ? "-" : "";
-    const absNum = this.numerator < 0n ? -this.numerator : this.numerator;
-    return `${sign}\\frac{${absNum}}{${this.denominator}}`;
-  }
-  /**
-   * Convert to mixed number representation
-   */
-  toMixed() {
-    const sign = this.numerator < 0n ? -1n : 1n;
-    const absNum = this.numerator < 0n ? -this.numerator : this.numerator;
-    const whole = sign * (absNum / this.denominator);
-    const remainder = absNum % this.denominator;
-    return {
-      whole,
-      numerator: remainder,
-      denominator: this.denominator
-    };
-  }
-  // ============================================================
-  // Arithmetic Operations (Scalar interface)
-  // ============================================================
-  /**
-   * Addition: a/b + c/d = (ad + bc) / bd
-   */
-  add(other) {
-    if (other instanceof _Fraction) {
-      const num = this.numerator * other.denominator + other.numerator * this.denominator;
-      const den = this.denominator * other.denominator;
-      return new _Fraction(num, den);
-    }
-    return this.add(_Fraction.fromNumber(Number(other.valueOf())));
-  }
-  /**
-   * Subtraction: a/b - c/d = (ad - bc) / bd
-   */
-  subtract(other) {
-    if (other instanceof _Fraction) {
-      const num = this.numerator * other.denominator - other.numerator * this.denominator;
-      const den = this.denominator * other.denominator;
-      return new _Fraction(num, den);
-    }
-    return this.subtract(_Fraction.fromNumber(Number(other.valueOf())));
-  }
-  /**
-   * Multiplication: a/b * c/d = ac / bd
-   */
-  multiply(other) {
-    if (other instanceof _Fraction) {
-      return new _Fraction(this.numerator * other.numerator, this.denominator * other.denominator);
-    }
-    return this.multiply(_Fraction.fromNumber(Number(other.valueOf())));
-  }
-  /**
-   * Division: a/b ÷ c/d = ad / bc
-   */
-  divide(other) {
-    if (other instanceof _Fraction) {
-      if (other.numerator === 0n) {
-        throw new Error("Division by zero");
-      }
-      return new _Fraction(this.numerator * other.denominator, this.denominator * other.numerator);
-    }
-    return this.divide(_Fraction.fromNumber(Number(other.valueOf())));
-  }
-  // Short-name aliases (mathjs Fraction API). Ported mathjs functions such as
-  // multiplyScalar/subtractScalar/divideScalar call x.mul/x.sub/x.div; without
-  // these, mixed number/Fraction dispatch (e.g. affine unit conversion like
-  // celsius→fahrenheit) threw "x.mul is not a function".
-  mul(other) {
-    return this.multiply(other);
-  }
-  sub(other) {
-    return this.subtract(other);
-  }
-  div(other) {
-    return this.divide(other);
-  }
-  /**
-   * Negation: -(a/b) = -a/b
-   */
-  negate() {
-    return new _Fraction(-this.numerator, this.denominator);
-  }
-  /**
-   * Absolute value: |a/b|
-   */
-  abs() {
-    return new _Fraction(this.numerator < 0n ? -this.numerator : this.numerator, this.denominator);
-  }
-  /**
-   * Reciprocal: b/a
-   */
-  inverse() {
-    if (this.numerator === 0n) {
-      throw new Error("Cannot invert zero");
-    }
-    return new _Fraction(this.denominator, this.numerator);
-  }
-  /**
-   * Power (integer exponent)
-   */
-  pow(n) {
-    const exp = typeof n === "bigint" ? n : BigInt(n);
-    if (exp === 0n) {
-      return new _Fraction(1n, 1n);
-    }
-    if (exp < 0n) {
-      return this.inverse().pow(-exp);
-    }
-    let result = new _Fraction(1n, 1n);
-    let base = this.clone();
-    let e = exp;
-    while (e > 0n) {
-      if (e % 2n === 1n) {
-        result = result.multiply(base);
-      }
-      base = base.multiply(base);
-      e = e / 2n;
-    }
-    return result;
-  }
-  /**
-   * Modulo operation
-   */
-  mod(other) {
-    const quotient = this.divide(other);
-    const floorQuot = quotient.floor();
-    return this.subtract(other.multiply(floorQuot));
-  }
-  // ============================================================
-  // Comparison Methods
-  // ============================================================
-  /**
-   * Check equality
-   */
-  equals(other) {
-    return this.numerator === other.numerator && this.denominator === other.denominator;
-  }
-  /**
-   * Check if less than
-   */
-  lessThan(other) {
-    return _Fraction.compare(this, other) < 0;
-  }
-  /**
-   * Check if less than or equal
-   */
-  lessThanOrEqual(other) {
-    return _Fraction.compare(this, other) <= 0;
-  }
-  /**
-   * Check if greater than
-   */
-  greaterThan(other) {
-    return _Fraction.compare(this, other) > 0;
-  }
-  /**
-   * Check if greater than or equal
-   */
-  greaterThanOrEqual(other) {
-    return _Fraction.compare(this, other) >= 0;
-  }
-  /**
-   * Compare with another fraction
-   * @returns -1, 0, or 1
-   */
-  compareTo(other) {
-    return _Fraction.compare(this, other);
-  }
-  compare(other) {
-    return this.compareTo(other);
-  }
-  // ============================================================
-  // Utility Methods
-  // ============================================================
-  /**
-   * Return fraction already in lowest terms (no-op since constructor reduces)
-   */
-  simplify() {
-    return this;
-  }
-  /**
-   * Check if this is zero
-   */
-  isZero() {
-    return this.numerator === 0n;
-  }
-  /**
-   * Check if this is positive
-   */
-  isPositive() {
-    return this.numerator > 0n;
-  }
-  /**
-   * Check if this is negative
-   */
-  isNegative() {
-    return this.numerator < 0n;
-  }
-  /**
-   * Check if this is an integer
-   */
-  isInteger() {
-    return this.denominator === 1n;
-  }
-  /**
-   * Check if this is a unit fraction (1/n)
-   */
-  isUnit() {
-    return this.numerator === 1n || this.numerator === -1n;
-  }
-  /**
-   * Floor: largest integer ≤ this
-   */
-  floor() {
-    if (this.denominator === 1n) {
-      return this;
-    }
-    const quot = this.numerator / this.denominator;
-    if (this.numerator >= 0n || this.numerator % this.denominator === 0n) {
-      return new _Fraction(quot, 1n);
-    }
-    return new _Fraction(quot - 1n, 1n);
-  }
-  /**
-   * Ceiling: smallest integer ≥ this
-   */
-  ceil() {
-    if (this.denominator === 1n) {
-      return this;
-    }
-    const quot = this.numerator / this.denominator;
-    if (this.numerator <= 0n || this.numerator % this.denominator === 0n) {
-      return new _Fraction(quot, 1n);
-    }
-    return new _Fraction(quot + 1n, 1n);
-  }
-  /**
-   * Round to nearest integer
-   */
-  round() {
-    const floor = this.floor();
-    const diff = this.subtract(floor);
-    const half = new _Fraction(1n, 2n);
-    if (diff.greaterThanOrEqual(half)) {
-      return floor.add(new _Fraction(1n, 1n));
-    }
-    return floor;
-  }
-  /**
-   * Truncate (round toward zero)
-   */
-  trunc() {
-    return new _Fraction(this.numerator / this.denominator, 1n);
-  }
-  /**
-   * Get the sign: -1, 0, or 1
-   */
-  sign() {
-    if (this.numerator < 0n) return -1;
-    if (this.numerator > 0n) return 1;
-    return 0;
-  }
-  /**
-   * Clone this fraction
-   */
-  clone() {
-    return new _Fraction(this.numerator, this.denominator);
-  }
-  /**
-   * Get the GCD of numerator and denominator (always 1 since we reduce)
-   */
-  gcd() {
-    return 1n;
-  }
-  /**
-   * Get continued fraction representation
-   */
-  toContinuedFraction() {
-    const result = [];
-    let num = this.numerator < 0n ? -this.numerator : this.numerator;
-    let den = this.denominator;
-    while (den !== 0n) {
-      result.push(num / den);
-      const temp = num % den;
-      num = den;
-      den = temp;
-    }
-    if (this.numerator < 0n && result.length > 0) {
-      result[0] = -result[0];
-    }
-    return result;
-  }
-  /**
-   * Create fraction from continued fraction
-   */
-  static fromContinuedFraction(cf) {
-    if (cf.length === 0) {
-      return new _Fraction(0n, 1n);
-    }
-    let num = cf[cf.length - 1];
-    let den = 1n;
-    for (let i = cf.length - 2; i >= 0; i--) {
-      const temp = num;
-      num = cf[i] * num + den;
-      den = temp;
-    }
-    return new _Fraction(num, den);
-  }
-  /**
-   * Mediant of two fractions: (a+c)/(b+d)
-   * Used in Stern-Brocot tree and Farey sequences
-   */
-  mediant(other) {
-    return new _Fraction(this.numerator + other.numerator, this.denominator + other.denominator);
-  }
-};
-var FRACTION_ZERO = new Fraction(0n, 1n);
-var FRACTION_ONE = new Fraction(1n, 1n);
-var FRACTION_NEG_ONE = new Fraction(-1n, 1n);
-var FRACTION_HALF = new Fraction(1n, 2n);
-var FRACTION_THIRD = new Fraction(1n, 3n);
-var FRACTION_QUARTER = new Fraction(1n, 4n);
-
-// src/types/bignumber.ts
-function isBigNumber(value) {
-  return value instanceof BigNumber;
-}
-var defaultConfig = {
-  precision: 64,
-  rounding: "halfUp",
-  minExponent: -1e9,
-  maxExponent: 1e9
-};
-var globalConfig = { ...defaultConfig };
-var BigNumber = class _BigNumber {
-  type = "BigNumber";
-  /**
-   * Duck-typing marker for Decimal.js / mathjs formatter compatibility.
-   * Allows external code that checks `obj.isBigNumber === true` to identify
-   * this class without an `instanceof` check.
-   */
-  isBigNumber = true;
-  // Internal representation: sign * coefficient * 10^exponent
-  _sign;
-  _coefficient;
-  // Absolute value, normalized
-  _exponent;
-  // Power of 10
-  // Special values
-  _isNaN = false;
-  _isInfinite = false;
-  constructor(sign, coefficient, exponent, isNaN2 = false, isInfinite = false) {
-    this._sign = sign;
-    this._coefficient = coefficient;
-    this._exponent = exponent;
-    this._isNaN = isNaN2;
-    this._isInfinite = isInfinite;
-  }
-  // ============================================================
-  // Static Factory Methods
-  // ============================================================
-  /**
-   * Create a BigNumber from a number
-   */
-  static fromNumber(n) {
-    if (Number.isNaN(n)) {
-      return new _BigNumber(0, 0n, 0, true, false);
-    }
-    if (!Number.isFinite(n)) {
-      return new _BigNumber(n > 0 ? 1 : -1, 0n, 0, false, true);
-    }
-    if (n === 0) {
-      return new _BigNumber(0, 0n, 0);
-    }
-    return _BigNumber.parse(n.toString());
-  }
-  /**
-   * Create a BigNumber from a string
-   */
-  static parse(str) {
-    str = str.trim().toLowerCase();
-    if (str === "nan") {
-      return new _BigNumber(0, 0n, 0, true, false);
-    }
-    if (str === "infinity" || str === "+infinity") {
-      return new _BigNumber(1, 0n, 0, false, true);
-    }
-    if (str === "-infinity") {
-      return new _BigNumber(-1, 0n, 0, false, true);
-    }
-    let sign = 1;
-    if (str.startsWith("-")) {
-      sign = -1;
-      str = str.slice(1);
-    } else if (str.startsWith("+")) {
-      str = str.slice(1);
-    }
-    let exponentPart = 0;
-    const eIndex = str.indexOf("e");
-    if (eIndex !== -1) {
-      exponentPart = parseInt(str.slice(eIndex + 1), 10);
-      str = str.slice(0, eIndex);
-    }
-    const dotIndex = str.indexOf(".");
-    let coefficient;
-    let decimalPlaces = 0;
-    if (dotIndex !== -1) {
-      coefficient = str.slice(0, dotIndex) + str.slice(dotIndex + 1);
-      decimalPlaces = str.length - dotIndex - 1;
-    } else {
-      coefficient = str;
-    }
-    coefficient = coefficient.replace(/^0+/, "") || "0";
-    if (coefficient === "0") {
-      return new _BigNumber(0, 0n, 0);
-    }
-    let trailingZeros = 0;
-    for (let i = coefficient.length - 1; i >= 0; i--) {
-      if (coefficient[i] === "0") {
-        trailingZeros++;
-      } else {
-        break;
-      }
-    }
-    if (trailingZeros > 0) {
-      coefficient = coefficient.slice(0, -trailingZeros);
-    }
-    const finalExponent = exponentPart - decimalPlaces + trailingZeros;
-    return new _BigNumber(sign, BigInt(coefficient), finalExponent);
-  }
-  /**
-   * Create from bigint
-   */
-  static fromBigInt(n) {
-    if (n === 0n) {
-      return new _BigNumber(0, 0n, 0);
-    }
-    const sign = n < 0n ? -1 : 1;
-    let str = (n < 0n ? -n : n).toString();
-    let trailingZeros = 0;
-    for (let i = str.length - 1; i >= 0; i--) {
-      if (str[i] === "0") {
-        trailingZeros++;
-      } else {
-        break;
-      }
-    }
-    if (trailingZeros > 0) {
-      str = str.slice(0, -trailingZeros);
-    }
-    return new _BigNumber(sign, BigInt(str), trailingZeros);
-  }
-  /**
-   * Create a BigNumber from a JSON object
-   */
-  static fromJSON(json) {
-    return _BigNumber.parse(json.value);
-  }
-  /**
-   * Get/set global configuration
-   */
-  static config(newConfig) {
-    if (newConfig) {
-      globalConfig = { ...globalConfig, ...newConfig };
-    }
-    return { ...globalConfig };
-  }
-  /**
-   * Reset configuration to defaults
-   */
-  static resetConfig() {
-    globalConfig = { ...defaultConfig };
-  }
-  /**
-   * Compare two BigNumbers
-   * @returns -1, 0, or 1
-   */
-  static compare(a, b) {
-    if (a._isNaN || b._isNaN) return NaN;
-    if (a._isInfinite && b._isInfinite) {
-      if (a._sign === b._sign) return 0;
-      return a._sign > b._sign ? 1 : -1;
-    }
-    if (a._isInfinite) return a._sign;
-    if (b._isInfinite) return -b._sign;
-    if (a._sign === 0 && b._sign === 0) return 0;
-    if (a._sign === 0) return -b._sign;
-    if (b._sign === 0) return a._sign;
-    if (a._sign !== b._sign) return a._sign > b._sign ? 1 : -1;
-    const result = _BigNumber.compareMagnitude(a, b);
-    return a._sign === 1 ? result : -result;
-  }
-  static compareMagnitude(a, b) {
-    const aDigits = a._coefficient.toString();
-    const bDigits = b._coefficient.toString();
-    const aOrder = aDigits.length + a._exponent;
-    const bOrder = bDigits.length + b._exponent;
-    if (aOrder !== bOrder) {
-      return aOrder > bOrder ? 1 : -1;
-    }
-    const aFull = aDigits + "0".repeat(Math.max(0, a._exponent));
-    const bFull = bDigits + "0".repeat(Math.max(0, b._exponent));
-    if (aFull === bFull) return 0;
-    return aFull > bFull ? 1 : -1;
-  }
-  // ============================================================
-  // Conversion Methods
-  // ============================================================
-  valueOf() {
-    if (this._isNaN) return NaN;
-    if (this._isInfinite) return this._sign === 1 ? Infinity : -Infinity;
-    if (this._sign === 0) return 0;
-    const str = this.toString();
-    return parseFloat(str);
-  }
-  /**
-   * Convert to a JS number.
-   * Alias for `valueOf()` — provided for Decimal.js / mathjs formatter
-   * duck-typing compatibility.
-   */
-  toNumber() {
-    return this.valueOf();
-  }
-  toString() {
-    if (this._isNaN) return "NaN";
-    if (this._isInfinite) return this._sign === 1 ? "Infinity" : "-Infinity";
-    if (this._sign === 0) return "0";
-    const sign = this._sign === -1 ? "-" : "";
-    const digits = this._coefficient.toString();
-    if (this._exponent >= 0) {
-      return sign + digits + "0".repeat(this._exponent);
-    } else if (-this._exponent < digits.length) {
-      const insertPos = digits.length + this._exponent;
-      return sign + digits.slice(0, insertPos) + "." + digits.slice(insertPos);
-    } else {
-      return sign + "0." + "0".repeat(-this._exponent - digits.length) + digits;
-    }
-  }
-  toJSON() {
-    return {
-      mathjs: "BigNumber",
-      value: this.toString()
-    };
-  }
-  /**
-   * Convert to fixed-point notation.
-   *
-   * When called with no argument (or `undefined`) returns the full fixed-point
-   * string representation without rounding — matching Decimal.js semantics where
-   * `toFixed()` is equivalent to a lossless fixed-point stringify.
-   * When called with a non-negative integer `decimalPlaces`, rounds and formats
-   * to exactly that many digits after the decimal point.
-   */
-  toFixed(decimalPlaces) {
-    if (decimalPlaces === void 0) {
-      return this.toFixedInternal(void 0);
-    }
-    return this.round(decimalPlaces).toFixedInternal(decimalPlaces);
-  }
-  toFixedInternal(decimalPlaces) {
-    if (this._isNaN) return "NaN";
-    if (this._isInfinite) return this._sign === 1 ? "Infinity" : "-Infinity";
-    const dp = decimalPlaces ?? -1;
-    const allDigits = dp < 0;
-    if (this._sign === 0) return allDigits ? "0" : dp > 0 ? "0." + "0".repeat(dp) : "0";
-    const sign = this._sign === -1 ? "-" : "";
-    const digits = this._coefficient.toString();
-    if (this._exponent >= 0) {
-      const intPart = digits + "0".repeat(this._exponent);
-      if (allDigits) return sign + intPart;
-      return sign + intPart + (dp > 0 ? "." + "0".repeat(dp) : "");
-    } else if (-this._exponent <= digits.length) {
-      const insertPos = digits.length + this._exponent;
-      const intPart = digits.slice(0, insertPos) || "0";
-      const decPart = digits.slice(insertPos);
-      if (allDigits) {
-        return sign + intPart + (decPart.length > 0 ? "." + decPart : "");
-      }
-      let paddedDec = decPart;
-      if (paddedDec.length < dp) {
-        paddedDec += "0".repeat(dp - paddedDec.length);
-      }
-      return sign + intPart + (dp > 0 ? "." + paddedDec.slice(0, dp) : "");
-    } else {
-      const leadingZeros = -this._exponent - digits.length;
-      const decPart = "0".repeat(leadingZeros) + digits;
-      if (allDigits) {
-        return sign + "0." + decPart;
-      }
-      let paddedDec = decPart;
-      if (paddedDec.length < dp) {
-        paddedDec += "0".repeat(dp - paddedDec.length);
-      }
-      return sign + "0" + (dp > 0 ? "." + paddedDec.slice(0, dp) : "");
-    }
-  }
-  /**
-   * Convert to exponential notation
-   */
-  toExponential(decimalPlaces) {
-    if (this._isNaN) return "NaN";
-    if (this._isInfinite) return this._sign === 1 ? "Infinity" : "-Infinity";
-    if (this._sign === 0) {
-      const dp = decimalPlaces ?? 0;
-      return dp > 0 ? "0." + "0".repeat(dp) + "e+0" : "0e+0";
-    }
-    const sign = this._sign === -1 ? "-" : "";
-    const digits = this._coefficient.toString();
-    const exp = digits.length - 1 + this._exponent;
-    const expSign = exp >= 0 ? "+" : "";
-    if (decimalPlaces === void 0) {
-      if (digits.length === 1) {
-        return `${sign}${digits}e${expSign}${exp}`;
-      }
-      return `${sign}${digits[0]}.${digits.slice(1)}e${expSign}${exp}`;
-    }
-    if (decimalPlaces === 0) {
-      return `${sign}${digits[0]}e${expSign}${exp}`;
-    }
-    let decPart = digits.slice(1);
-    if (decPart.length < decimalPlaces) {
-      decPart += "0".repeat(decimalPlaces - decPart.length);
-    } else {
-      decPart = decPart.slice(0, decimalPlaces);
-    }
-    return `${sign}${digits[0]}.${decPart}e${expSign}${exp}`;
-  }
-  /**
-   * Convert to precision
-   */
-  toPrecision(significantDigits) {
-    if (significantDigits === void 0) {
-      return this.toString();
-    }
-    if (this._isNaN) return "NaN";
-    if (this._isInfinite) return this._sign === 1 ? "Infinity" : "-Infinity";
-    if (this._sign === 0) {
-      return significantDigits > 1 ? "0." + "0".repeat(significantDigits - 1) : "0";
-    }
-    const digits = this._coefficient.toString();
-    const order = digits.length + this._exponent;
-    if (order > significantDigits || order < -6) {
-      return this.toExponential(significantDigits - 1);
-    }
-    return this.toFixed(significantDigits - order);
-  }
-  /**
-   * Convert to bigint (truncated)
-   */
-  toBigInt() {
-    if (this._isNaN || this._isInfinite) {
-      throw new Error("Cannot convert NaN or Infinity to bigint");
-    }
-    if (this._sign === 0) return 0n;
-    const digits = this._coefficient.toString();
-    if (this._exponent >= 0) {
-      return BigInt(this._sign) * BigInt(digits + "0".repeat(this._exponent));
-    } else if (-this._exponent < digits.length) {
-      return BigInt(this._sign) * BigInt(digits.slice(0, digits.length + this._exponent));
-    }
-    return 0n;
-  }
-  /**
-   * Binary string representation, e.g. `255 -> '0b11111111'`, `0.5 -> '0b0.1'`.
-   * Mirrors Decimal.js `toBinary()`. Negatives carry a leading `-`.
-   */
-  toBinary() {
-    return this.toRadixString(2, "0b");
-  }
-  /**
-   * Octal string representation, e.g. `8 -> '0o10'`.
-   * Mirrors Decimal.js `toOctal()`.
-   */
-  toOctal() {
-    return this.toRadixString(8, "0o");
-  }
-  /**
-   * Hexadecimal string representation, e.g. `255 -> '0xff'`, `10.5 -> '0xa.8'`.
-   * Mirrors Decimal.js `toHexadecimal()`.
-   */
-  toHexadecimal() {
-    return this.toRadixString(16, "0x");
-  }
-  /**
-   * Shared radix formatter for {@link toBinary}/{@link toOctal}/{@link toHexadecimal}.
-   * Integers and terminating fractions are exact; a non-terminating fraction is
-   * truncated at `maxFractionDigits` radix digits (a safety bound — the common
-   * use is integer formatting).
-   */
-  toRadixString(radix, prefix, maxFractionDigits = 1100) {
-    if (this._isNaN) return "NaN";
-    if (this._isInfinite) return (this._sign < 0 ? "-" : "") + "Infinity";
-    if (this._sign === 0) return prefix + "0";
-    const negative = this._sign < 0;
-    const absVal = this.abs();
-    const intPart = absVal.toBigInt();
-    let out = prefix + intPart.toString(radix);
-    let frac = absVal.subtract(_BigNumber.fromBigInt(intPart));
-    if (!frac.isZero()) {
-      const radixBN = _BigNumber.fromNumber(radix);
-      let digits = "";
-      for (let i = 0; i < maxFractionDigits && !frac.isZero(); i++) {
-        frac = frac.multiply(radixBN);
-        const digit = frac.toBigInt();
-        digits += Number(digit).toString(radix);
-        frac = frac.subtract(_BigNumber.fromBigInt(digit));
-      }
-      out += "." + digits;
-    }
-    return (negative ? "-" : "") + out;
-  }
-  // ============================================================
-  // Arithmetic Operations
-  // ============================================================
-  /**
-   * Addition
-   */
-  add(other) {
-    const b = this.ensureBigNumber(other);
-    if (this._isNaN || b._isNaN) return new _BigNumber(0, 0n, 0, true);
-    if (this._isInfinite && b._isInfinite) {
-      if (this._sign === b._sign) return this;
-      return new _BigNumber(0, 0n, 0, true);
-    }
-    if (this._isInfinite) return this;
-    if (b._isInfinite) return b;
-    if (this._sign === 0) return b;
-    if (b._sign === 0) return this;
-    const [aCoef, bCoef, exp] = this.alignExponents(this, b);
-    if (this._sign === b._sign) {
-      return this.normalize(this._sign, aCoef + bCoef, exp);
-    } else {
-      if (aCoef >= bCoef) {
-        const diff = aCoef - bCoef;
-        return this.normalize(diff === 0n ? 0 : this._sign, diff, exp);
-      } else {
-        return this.normalize(b._sign, bCoef - aCoef, exp);
-      }
-    }
-  }
-  /**
-   * Subtraction
-   */
-  subtract(other) {
-    const b = this.ensureBigNumber(other);
-    return this.add(b.negate());
-  }
-  /**
-   * Alias for subtract — mathjs / Decimal.js compatibility.
-   */
-  sub(other) {
-    return this.subtract(other);
-  }
-  /**
-   * Multiplication
-   */
-  multiply(other) {
-    const b = this.ensureBigNumber(other);
-    if (this._isNaN || b._isNaN) return new _BigNumber(0, 0n, 0, true);
-    if (this._isInfinite || b._isInfinite) {
-      if (this._sign === 0 || b._sign === 0) return new _BigNumber(0, 0n, 0, true);
-      const sign2 = this._sign * b._sign;
-      return new _BigNumber(sign2, 0n, 0, false, true);
-    }
-    if (this._sign === 0 || b._sign === 0) return new _BigNumber(0, 0n, 0);
-    const sign = this._sign * b._sign;
-    const coefficient = this._coefficient * b._coefficient;
-    const exponent = this._exponent + b._exponent;
-    return this.normalize(sign, coefficient, exponent);
-  }
-  /**
-   * Alias for multiply — mathjs / Decimal.js compatibility.
-   */
-  mul(other) {
-    return this.multiply(other);
-  }
-  /**
-   * Division
-   */
-  divide(other) {
-    const b = this.ensureBigNumber(other);
-    if (this._isNaN || b._isNaN) return new _BigNumber(0, 0n, 0, true);
-    if (this._isInfinite && b._isInfinite) return new _BigNumber(0, 0n, 0, true);
-    if (b._sign === 0) {
-      if (this._sign === 0) return new _BigNumber(0, 0n, 0, true);
-      return new _BigNumber(this._sign, 0n, 0, false, true);
-    }
-    if (this._isInfinite) {
-      const sign2 = this._sign * b._sign;
-      return new _BigNumber(sign2, 0n, 0, false, true);
-    }
-    if (b._isInfinite) return new _BigNumber(0, 0n, 0);
-    if (this._sign === 0) return new _BigNumber(0, 0n, 0);
-    const sign = this._sign * b._sign;
-    const precision = globalConfig.precision;
-    const scale = BigInt(10) ** BigInt(precision + 10);
-    const scaledDividend = this._coefficient * scale;
-    const quotient = scaledDividend / b._coefficient;
-    const exponent = this._exponent - b._exponent - precision - 10;
-    return this.normalize(sign, quotient, exponent).roundToPrecision(precision);
-  }
-  /**
-   * Negation
-   */
-  negate() {
-    if (this._isNaN) return this;
-    if (this._sign === 0) return this;
-    const newSign = this._sign === 1 ? -1 : 1;
-    return new _BigNumber(newSign, this._coefficient, this._exponent, false, this._isInfinite);
-  }
-  /**
-   * Absolute value
-   */
-  abs() {
-    if (this._isNaN) return this;
-    if (this._sign === 0) return this;
-    return new _BigNumber(1, this._coefficient, this._exponent, false, this._isInfinite);
-  }
-  /**
-   * Power (integer exponent)
-   */
-  pow(n) {
-    const exp = typeof n === "bigint" ? Number(n) : n;
-    if (this._isNaN) return this;
-    if (exp === 0) return _BigNumber.fromNumber(1);
-    if (this._sign === 0) {
-      if (exp < 0) return new _BigNumber(1, 0n, 0, false, true);
-      return this;
-    }
-    if (exp < 0) {
-      return _BigNumber.fromNumber(1).divide(this.pow(-exp));
-    }
-    let result = _BigNumber.fromNumber(1);
-    let base = this.clone();
-    let e = exp;
-    while (e > 0) {
-      if (e % 2 === 1) {
-        result = result.multiply(base);
-      }
-      base = base.multiply(base);
-      e = Math.floor(e / 2);
-    }
-    return result.roundToPrecision(globalConfig.precision);
-  }
-  /**
-   * Square root
-   */
-  sqrt() {
-    if (this._isNaN) return this;
-    if (this._sign === -1) return new _BigNumber(0, 0n, 0, true);
-    if (this._sign === 0) return this;
-    if (this._isInfinite) return this;
-    const precision = globalConfig.precision;
-    let guess = _BigNumber.fromNumber(Math.sqrt(this.valueOf()));
-    for (let i = 0; i < 100; i++) {
-      const newGuess = guess.add(this.divide(guess)).divide(_BigNumber.fromNumber(2));
-      if (guess.subtract(newGuess).abs().compareTo(guess.multiply(_BigNumber.parse("1e-" + (precision + 5)))) <= 0) {
-        return newGuess.roundToPrecision(precision);
-      }
-      guess = newGuess;
-    }
-    return guess.roundToPrecision(precision);
-  }
-  // ============================================================
-  // Comparison Methods
-  // ============================================================
-  equals(other) {
-    return _BigNumber.compare(this, other) === 0;
-  }
-  lessThan(other) {
-    return _BigNumber.compare(this, other) < 0;
-  }
-  lessThanOrEqual(other) {
-    return _BigNumber.compare(this, other) <= 0;
-  }
-  greaterThan(other) {
-    return _BigNumber.compare(this, other) > 0;
-  }
-  greaterThanOrEqual(other) {
-    return _BigNumber.compare(this, other) >= 0;
-  }
-  compareTo(other) {
-    return _BigNumber.compare(this, other);
-  }
-  compare(other) {
-    return this.compareTo(other);
-  }
-  /**
-   * Returns true iff this > other.
-   * Accepts the same argument types as `add`/`multiply` (BigNumber, number, or string).
-   * Named `gt` for Decimal.js / mathjs formatter compatibility.
-   */
-  gt(other) {
-    return this.greaterThan(this.ensureBigNumber(other));
-  }
-  // ============================================================
-  // Rounding Methods
-  // ============================================================
-  /**
-   * Round to specified decimal places
-   */
-  round(decimalPlaces = 0, mode = globalConfig.rounding) {
-    if (this._isNaN || this._isInfinite || this._sign === 0) return this;
-    const targetExp = -decimalPlaces;
-    if (this._exponent >= targetExp) return this;
-    const shift = targetExp - this._exponent;
-    const divisor = BigInt(10) ** BigInt(shift);
-    const quotient = this._coefficient / divisor;
-    const remainder = this._coefficient % divisor;
-    let rounded = quotient;
-    const halfDivisor = divisor / 2n;
-    const shouldRoundUp = this.shouldRound(remainder, halfDivisor, divisor, quotient, mode);
-    if (shouldRoundUp) {
-      rounded += 1n;
-    }
-    return this.normalize(rounded === 0n ? 0 : this._sign, rounded, targetExp);
-  }
-  shouldRound(remainder, halfDivisor, divisor, quotient, mode) {
-    const isPositive = this._sign === 1;
-    const isExactlyHalf = remainder === halfDivisor && divisor % 2n === 0n;
-    const isMoreThanHalf = remainder > halfDivisor;
-    switch (mode) {
-      case "up":
-        return remainder > 0n;
-      case "down":
-        return false;
-      case "ceil":
-        return isPositive && remainder > 0n;
-      case "floor":
-        return !isPositive && remainder > 0n;
-      case "halfUp":
-        return isMoreThanHalf || isExactlyHalf;
-      case "halfDown":
-        return isMoreThanHalf;
-      case "halfEven":
-        return isMoreThanHalf || isExactlyHalf && quotient % 2n !== 0n;
-      case "halfCeil":
-        return isMoreThanHalf || isExactlyHalf && isPositive;
-      case "halfFloor":
-        return isMoreThanHalf || isExactlyHalf && !isPositive;
-      default:
-        return isMoreThanHalf || isExactlyHalf;
-    }
-  }
-  /**
-   * Round to specified precision (significant digits)
-   */
-  roundToPrecision(precision, mode = globalConfig.rounding) {
-    if (this._isNaN || this._isInfinite || this._sign === 0) return this;
-    const digits = this._coefficient.toString();
-    if (digits.length <= precision) return this;
-    const digitsToRemove = digits.length - precision;
-    const divisor = BigInt(10) ** BigInt(digitsToRemove);
-    const quotient = this._coefficient / divisor;
-    const remainder = this._coefficient % divisor;
-    const halfDivisor = divisor / 2n;
-    let rounded = quotient;
-    const shouldRoundUp = this.shouldRound(remainder, halfDivisor, divisor, quotient, mode);
-    if (shouldRoundUp) {
-      rounded += 1n;
-    }
-    const newExponent = this._exponent + digitsToRemove;
-    return this.normalize(rounded === 0n ? 0 : this._sign, rounded, newExponent);
+  sub(o) {
+    return new _Dual(this.value - o.value, this.deriv - o.deriv);
   }
-  floor() {
-    return this.round(0, "floor");
+  mul(o) {
+    return new _Dual(this.value * o.value, this.deriv * o.value + this.value * o.deriv);
   }
-  ceil() {
-    return this.round(0, "ceil");
+  div(o) {
+    const d = (this.deriv * o.value - this.value * o.deriv) / (o.value * o.value);
+    return new _Dual(this.value / o.value, d);
   }
-  trunc() {
-    return this.round(0, "down");
+  neg() {
+    return new _Dual(-this.value, -this.deriv);
   }
-  /**
-   * Round to `n` significant decimal digits and return a new BigNumber.
-   * Delegates to `roundToPrecision`, using the global rounding mode unless
-   * an explicit `roundingMode` is supplied.
-   *
-   * Named `toSignificantDigits` for Decimal.js / mathjs formatter compatibility.
-   * When `n` is undefined the value is returned unchanged (no rounding).
-   */
-  toSignificantDigits(n, roundingMode) {
-    if (n === void 0) return this.clone();
-    return this.roundToPrecision(n, roundingMode ?? globalConfig.rounding);
+  /** Power with a constant real exponent: d(xᵏ) = k·xᵏ⁻¹·dx. */
+  powConst(k) {
+    return new _Dual(Math.pow(this.value, k), this.deriv * k * Math.pow(this.value, k - 1));
   }
-  /**
-   * The decimal exponent of this number: `floor(log10(|x|))`.
-   *
-   * Matches Decimal.js semantics:
-   *   - `12345` → `4`   (5 digits → the most-significant place is 10^4)
-   *   - `0.0123` → `-2`  (first significant digit is at 10^-2)
-   *   - `100` → `2`
-   *   - `0.01` → `-2`
-   *   - `0` → `0`        (by convention; `isZero()` can be used to distinguish)
-   *
-   * For special values (NaN, ±Infinity) returns 0 — callers check
-   * `isFinite()` / `isNaN()` before using `.e`.
-   */
-  get e() {
-    if (this._isNaN || this._isInfinite || this._sign === 0) return 0;
-    const d = this._coefficient.toString().length;
-    return d - 1 + this._exponent;
+  /** General power a^b: d = a^b·(b'·ln a + b·a'/a). */
+  pow(o) {
+    const v = Math.pow(this.value, o.value);
+    const d = v * (o.deriv * Math.log(this.value) + o.value * this.deriv / this.value);
+    return new _Dual(v, d);
   }
-  // ============================================================
-  // Modular Arithmetic
-  // ============================================================
-  /**
-   * Modulo (remainder after division)
-   * Result has the same sign as the dividend (this).
-   */
-  mod(other) {
-    const b = this.ensureBigNumber(other);
-    if (this._isNaN || b._isNaN || b._sign === 0) return new _BigNumber(0, 0n, 0, true);
-    if (this._isInfinite) return new _BigNumber(0, 0n, 0, true);
-    if (b._isInfinite) return this;
-    if (this._sign === 0) return this;
-    const quotient = this.divide(b).trunc();
-    return this.subtract(b.multiply(quotient));
+  // --- elementary functions ------------------------------------------------
+  // Each applies the shared chain rule (value, deriv) ↦ (f(v), deriv·f′(v))
+  // using the canonical rule from `DUAL_UNARY_RULES`, so the scalar and tensor
+  // AD paths can never drift apart.
+  unary(rule) {
+    const y = rule.primal(this.value);
+    return new _Dual(y, this.deriv * rule.deriv(this.value, y));
   }
-  // ============================================================
-  // Trigonometric Functions
-  // ============================================================
-  /**
-   * Sine of this BigNumber (in radians)
-   * Uses Taylor series: sin(x) = x - x^3/3! + x^5/5! - ...
-   */
   sin() {
-    if (this._isNaN) return this;
-    if (this._isInfinite) return new _BigNumber(0, 0n, 0, true);
-    if (this._sign === 0) return this;
-    const x = this._reduceAngle();
-    return x._sinTaylor();
+    return this.unary(DUAL_UNARY_RULES.sin);
   }
-  /**
-   * Cosine of this BigNumber (in radians)
-   * Uses Taylor series: cos(x) = 1 - x^2/2! + x^4/4! - ...
-   */
   cos() {
-    if (this._isNaN) return this;
-    if (this._isInfinite) return new _BigNumber(0, 0n, 0, true);
-    if (this._sign === 0) return _BigNumber.fromNumber(1);
-    const x = this._reduceAngle();
-    return x._cosTaylor();
+    return this.unary(DUAL_UNARY_RULES.cos);
   }
-  /**
-   * Tangent of this BigNumber (in radians)
-   * tan(x) = sin(x) / cos(x)
-   */
   tan() {
-    if (this._isNaN) return this;
-    if (this._isInfinite) return new _BigNumber(0, 0n, 0, true);
-    if (this._sign === 0) return this;
-    const x = this._reduceAngle();
-    return x._sinTaylor().divide(x._cosTaylor());
+    return this.unary(DUAL_UNARY_RULES.tan);
   }
-  /**
-   * Arcsine of this BigNumber
-   * Returns value in [-PI/2, PI/2]
-   */
-  asin() {
-    if (this._isNaN) return this;
-    const one = _BigNumber.fromNumber(1);
-    if (this.abs().compareTo(one) > 0) return new _BigNumber(0, 0n, 0, true);
-    if (this._sign === 0) return this;
-    const xSquared = this.multiply(this);
-    const denominator = one.subtract(xSquared).sqrt();
-    if (denominator.isZero()) {
-      return this._sign === 1 ? BIGNUMBER_PI.divide(2) : BIGNUMBER_PI.divide(-2);
-    }
-    return this.divide(denominator).atan();
+  exp() {
+    return this.unary(DUAL_UNARY_RULES.exp);
   }
-  /**
-   * Arccosine of this BigNumber
-   * Returns value in [0, PI]
-   */
-  acos() {
-    if (this._isNaN) return this;
-    const one = _BigNumber.fromNumber(1);
-    if (this.abs().compareTo(one) > 0) return new _BigNumber(0, 0n, 0, true);
-    return BIGNUMBER_PI.divide(2).subtract(this.asin());
+  log() {
+    return this.unary(DUAL_UNARY_RULES.log);
   }
-  /**
-   * Arctangent of this BigNumber
-   * Returns value in (-PI/2, PI/2)
-   * Uses Taylor series with argument reduction for convergence.
-   */
-  atan() {
-    if (this._isNaN) return this;
-    if (this._sign === 0) return this;
-    if (this._isInfinite) {
-      return this._sign === 1 ? BIGNUMBER_PI.divide(2) : BIGNUMBER_PI.divide(-2);
-    }
-    const one = _BigNumber.fromNumber(1);
-    if (this.abs().compareTo(one) > 0) {
-      const reciprocal = one.divide(this);
-      const piHalf = BIGNUMBER_PI.divide(2);
-      return this._sign === 1 ? piHalf.subtract(reciprocal.atan()) : piHalf.negate().subtract(reciprocal.atan());
-    }
-    const half = _BigNumber.fromNumber(0.5);
-    if (this.abs().compareTo(half) > 0) {
-      const xSq = this.multiply(this);
-      const reduced = this.divide(one.add(one.add(xSq).sqrt()));
-      return reduced.atan().multiply(_BigNumber.fromNumber(2));
-    }
-    return this._atanTaylor();
+  sqrt() {
+    return this.unary(DUAL_UNARY_RULES.sqrt);
   }
-  /**
-   * Two-argument arctangent: atan2(y, x)
-   * this = y, argument = x
-   * Returns angle in (-PI, PI]
-   */
-  atan2(x) {
-    if (this._isNaN || x._isNaN) return new _BigNumber(0, 0n, 0, true);
-    if (this._sign === 0 && x._sign === 0) return _BigNumber.fromNumber(0);
-    if (x._sign === 0) {
-      return this._sign === 1 ? BIGNUMBER_PI.divide(2) : BIGNUMBER_PI.divide(-2);
-    }
-    const angle = this.divide(x).atan();
-    if (x.isPositive()) {
-      return angle;
-    } else if (this.isNegative()) {
-      return angle.subtract(BIGNUMBER_PI);
-    } else {
-      return angle.add(BIGNUMBER_PI);
-    }
+  square() {
+    return this.unary(DUAL_UNARY_RULES.square);
+  }
+  abs() {
+    return this.unary(DUAL_UNARY_RULES.abs);
   }
-  // ============================================================
-  // Hyperbolic Functions
-  // ============================================================
-  /**
-   * Hyperbolic sine: sinh(x) = (e^x - e^(-x)) / 2
-   */
   sinh() {
-    if (this._isNaN) return this;
-    if (this._isInfinite) return this;
-    if (this._sign === 0) return this;
-    const ex = this.exp();
-    const enx = this.negate().exp();
-    return ex.subtract(enx).divide(_BigNumber.fromNumber(2));
+    return this.unary(DUAL_UNARY_RULES.sinh);
   }
-  /**
-   * Hyperbolic cosine: cosh(x) = (e^x + e^(-x)) / 2
-   */
   cosh() {
-    if (this._isNaN) return this;
-    if (this._isInfinite) return new _BigNumber(1, 0n, 0, false, true);
-    if (this._sign === 0) return _BigNumber.fromNumber(1);
-    const ex = this.exp();
-    const enx = this.negate().exp();
-    return ex.add(enx).divide(_BigNumber.fromNumber(2));
+    return this.unary(DUAL_UNARY_RULES.cosh);
   }
-  /**
-   * Hyperbolic tangent: tanh(x) = sinh(x) / cosh(x)
-   */
   tanh() {
-    if (this._isNaN) return this;
-    if (this._sign === 0) return this;
-    if (this._isInfinite) return _BigNumber.fromNumber(this._sign);
-    const ex = this.exp();
-    const enx = this.negate().exp();
-    return ex.subtract(enx).divide(ex.add(enx));
-  }
-  /**
-   * Inverse hyperbolic sine: asinh(x) = ln(x + sqrt(x^2 + 1))
-   */
-  asinh() {
-    if (this._isNaN) return this;
-    if (this._isInfinite) return this;
-    if (this._sign === 0) return this;
-    const one = _BigNumber.fromNumber(1);
-    return this.add(this.multiply(this).add(one).sqrt()).ln();
-  }
-  /**
-   * Inverse hyperbolic cosine: acosh(x) = ln(x + sqrt(x^2 - 1))
-   * Domain: x >= 1
-   */
-  acosh() {
-    if (this._isNaN) return this;
-    const one = _BigNumber.fromNumber(1);
-    if (this.compareTo(one) < 0) return new _BigNumber(0, 0n, 0, true);
-    if (this._isInfinite) return this;
-    return this.add(this.multiply(this).subtract(one).sqrt()).ln();
-  }
-  /**
-   * Inverse hyperbolic tangent: atanh(x) = 0.5 * ln((1+x)/(1-x))
-   * Domain: -1 < x < 1
-   */
-  atanh() {
-    if (this._isNaN) return this;
-    const one = _BigNumber.fromNumber(1);
-    const absVal = this.abs();
-    if (absVal.compareTo(one) > 0) return new _BigNumber(0, 0n, 0, true);
-    if (absVal.equals(one)) {
-      return this._sign === 1 ? new _BigNumber(1, 0n, 0, false, true) : new _BigNumber(-1, 0n, 0, false, true);
-    }
-    if (this._sign === 0) return this;
-    const half = _BigNumber.fromNumber(0.5);
-    return one.add(this).divide(one.subtract(this)).ln().multiply(half);
-  }
-  // ============================================================
-  // Transcendental Functions
-  // ============================================================
-  /**
-   * Exponential function: e^x
-   * Uses Taylor series: e^x = 1 + x + x^2/2! + x^3/3! + ...
-   * With argument reduction: e^x = (e^(x/2^k))^(2^k) for faster convergence.
-   */
-  exp() {
-    if (this._isNaN) return this;
-    if (this._sign === 0) return _BigNumber.fromNumber(1);
-    if (this._isInfinite) {
-      return this._sign === 1 ? this : _BigNumber.fromNumber(0);
-    }
-    const precision = globalConfig.precision;
-    const val = Math.abs(this.valueOf());
-    let k = 0;
-    if (val > 0.5) {
-      k = Math.ceil(Math.log2(val * 2));
-    }
-    const divisor = _BigNumber.fromNumber(2).pow(k);
-    const reduced = this.divide(divisor);
-    let sum = _BigNumber.fromNumber(1);
-    let term = _BigNumber.fromNumber(1);
-    const maxIter = precision + 20;
-    for (let n = 1; n <= maxIter; n++) {
-      term = term.multiply(reduced).divide(_BigNumber.fromNumber(n));
-      const newSum = sum.add(term);
-      if (sum.equals(newSum)) break;
-      sum = newSum;
-    }
-    for (let i = 0; i < k; i++) {
-      sum = sum.multiply(sum);
-    }
-    return sum.roundToPrecision(precision);
-  }
-  /**
-   * Natural logarithm: ln(x)
-   * Uses the AGM (arithmetic-geometric mean) method for fast convergence.
-   * Fallback: series ln((1+y)/(1-y)) = 2*(y + y^3/3 + y^5/5 + ...) where y = (x-1)/(x+1)
-   */
-  ln() {
-    if (this._isNaN) return this;
-    if (this._sign === -1) return new _BigNumber(0, 0n, 0, true);
-    if (this._sign === 0) return new _BigNumber(-1, 0n, 0, false, true);
-    if (this._isInfinite) return this;
-    const one = _BigNumber.fromNumber(1);
-    if (this.equals(one)) return _BigNumber.fromNumber(0);
-    const precision = globalConfig.precision;
-    let x = this.clone();
-    let k = 0;
-    const two = _BigNumber.fromNumber(2);
-    const half = _BigNumber.fromNumber(0.5);
-    while (x.compareTo(two) > 0) {
-      x = x.divide(two);
-      k++;
-    }
-    while (x.compareTo(half) < 0) {
-      x = x.multiply(two);
-      k--;
-    }
-    const y = x.subtract(one).divide(x.add(one));
-    const ySq = y.multiply(y);
-    let term = y;
-    let sum = y;
-    const maxIter = precision + 20;
-    for (let n = 1; n <= maxIter; n++) {
-      term = term.multiply(ySq);
-      const contribution = term.divide(_BigNumber.fromNumber(2 * n + 1));
-      const newSum = sum.add(contribution);
-      if (sum.equals(newSum)) break;
-      sum = newSum;
-    }
-    sum = sum.multiply(two);
-    if (k !== 0) {
-      sum = sum.add(BIGNUMBER_LN2.multiply(_BigNumber.fromNumber(k)));
-    }
-    return sum.roundToPrecision(precision);
-  }
-  /**
-   * Base-10 logarithm: log10(x) = ln(x) / ln(10)
-   */
-  log10() {
-    return this.ln().divide(BIGNUMBER_LN10);
-  }
-  /**
-   * Base-2 logarithm: log2(x) = ln(x) / ln(2)
-   */
-  log2() {
-    return this.ln().divide(BIGNUMBER_LN2);
-  }
-  /**
-   * Cube root
-   * Uses Newton-Raphson iteration.
-   */
-  cbrt() {
-    if (this._isNaN) return this;
-    if (this._sign === 0) return this;
-    if (this._isInfinite) return this;
-    if (this._sign === -1) {
-      return this.negate().cbrt().negate();
-    }
-    const precision = globalConfig.precision;
-    const three = _BigNumber.fromNumber(3);
-    let guess = _BigNumber.fromNumber(Math.cbrt(this.valueOf()));
-    for (let i = 0; i < 100; i++) {
-      const guessSquared = guess.multiply(guess);
-      const newGuess = guess.multiply(_BigNumber.fromNumber(2)).add(this.divide(guessSquared)).divide(three);
-      if (guess.subtract(newGuess).abs().compareTo(guess.abs().multiply(_BigNumber.parse("1e-" + (precision + 5)))) <= 0) {
-        return newGuess.roundToPrecision(precision);
-      }
-      guess = newGuess;
-    }
-    return guess.roundToPrecision(precision);
-  }
-  /**
-   * e^x - 1 (more precise than exp(x) - 1 for small x)
-   * Uses Taylor series directly: expm1(x) = x + x^2/2! + x^3/3! + ...
-   */
-  expm1() {
-    if (this._isNaN) return this;
-    if (this._sign === 0) return this;
-    if (this._isInfinite) {
-      return this._sign === 1 ? this : _BigNumber.fromNumber(-1);
-    }
-    if (Math.abs(this.valueOf()) > 0.5) {
-      return this.exp().subtract(_BigNumber.fromNumber(1));
-    }
-    const precision = globalConfig.precision;
-    let term = this.clone();
-    let sum = this.clone();
-    const maxIter = precision + 20;
-    for (let n = 2; n <= maxIter; n++) {
-      term = term.multiply(this).divide(_BigNumber.fromNumber(n));
-      const newSum = sum.add(term);
-      if (sum.equals(newSum)) break;
-      sum = newSum;
-    }
-    return sum.roundToPrecision(precision);
-  }
-  /**
-   * ln(1 + x) (more precise than ln(1 + x) for small x)
-   */
-  log1p() {
-    if (this._isNaN) return this;
-    const one = _BigNumber.fromNumber(1);
-    const negOne = _BigNumber.fromNumber(-1);
-    if (this.compareTo(negOne) < 0) return new _BigNumber(0, 0n, 0, true);
-    if (this.equals(negOne)) return new _BigNumber(-1, 0n, 0, false, true);
-    if (this._sign === 0) return this;
-    return one.add(this).ln();
-  }
-  /**
-   * Hypotenuse: sqrt(this^2 + other^2)
-   */
-  hypot(other) {
-    if (this._isNaN || other._isNaN) return new _BigNumber(0, 0n, 0, true);
-    if (this._isInfinite || other._isInfinite) return new _BigNumber(1, 0n, 0, false, true);
-    return this.multiply(this).add(other.multiply(other)).sqrt();
-  }
-  // ============================================================
-  // Private Taylor Series Helpers
-  // ============================================================
-  /** Reduce angle to [-PI, PI] range */
-  _reduceAngle() {
-    const twoPi = BIGNUMBER_PI.multiply(_BigNumber.fromNumber(2));
-    if (this.abs().compareTo(BIGNUMBER_PI) <= 0) {
-      return this;
-    }
-    const quotient = this.divide(twoPi).round(0, "halfUp");
-    let reduced = this.subtract(twoPi.multiply(quotient));
-    if (reduced.compareTo(BIGNUMBER_PI) > 0) {
-      reduced = reduced.subtract(twoPi);
-    } else if (reduced.compareTo(BIGNUMBER_PI.negate()) < 0) {
-      reduced = reduced.add(twoPi);
-    }
-    return reduced;
-  }
-  /** Taylor series for sin(x), assumes x is in [-PI, PI] */
-  _sinTaylor() {
-    const precision = globalConfig.precision;
-    let term = this.clone();
-    let sum = this.clone();
-    const xSquared = this.multiply(this);
-    const maxIter = precision + 20;
-    for (let n = 1; n <= maxIter; n++) {
-      term = term.multiply(xSquared).divide(_BigNumber.fromNumber(2 * n * (2 * n + 1))).negate();
-      const newSum = sum.add(term);
-      if (sum.equals(newSum)) break;
-      sum = newSum;
-    }
-    return sum.roundToPrecision(precision);
-  }
-  /** Taylor series for cos(x), assumes x is in [-PI, PI] */
-  _cosTaylor() {
-    const precision = globalConfig.precision;
-    let term = _BigNumber.fromNumber(1);
-    let sum = _BigNumber.fromNumber(1);
-    const xSquared = this.multiply(this);
-    const maxIter = precision + 20;
-    for (let n = 1; n <= maxIter; n++) {
-      term = term.multiply(xSquared).divide(_BigNumber.fromNumber((2 * n - 1) * (2 * n))).negate();
-      const newSum = sum.add(term);
-      if (sum.equals(newSum)) break;
-      sum = newSum;
-    }
-    return sum.roundToPrecision(precision);
-  }
-  /** Taylor series for atan(x), assumes |x| <= 0.5 */
-  _atanTaylor() {
-    const precision = globalConfig.precision;
-    const xSquared = this.multiply(this);
-    let term = this.clone();
-    let sum = this.clone();
-    const maxIter = precision + 20;
-    for (let n = 1; n <= maxIter; n++) {
-      term = term.multiply(xSquared).negate();
-      const contribution = term.divide(_BigNumber.fromNumber(2 * n + 1));
-      const newSum = sum.add(contribution);
-      if (sum.equals(newSum)) break;
-      sum = newSum;
-    }
-    return sum.roundToPrecision(precision);
-  }
-  // ============================================================
-  // Utility Methods
-  // ============================================================
-  isNaN() {
-    return this._isNaN;
-  }
-  isFinite() {
-    return !this._isNaN && !this._isInfinite;
-  }
-  isInfinite() {
-    return this._isInfinite;
-  }
-  isZero() {
-    return this._sign === 0 && !this._isNaN;
-  }
-  isPositive() {
-    return this._sign === 1;
-  }
-  isNegative() {
-    return this._sign === -1;
-  }
-  isInteger() {
-    if (this._isNaN || this._isInfinite || this._sign === 0) return this._sign === 0;
-    return this._exponent >= 0;
-  }
-  sign() {
-    return this._sign;
-  }
-  clone() {
-    return new _BigNumber(
-      this._sign,
-      this._coefficient,
-      this._exponent,
-      this._isNaN,
-      this._isInfinite
-    );
-  }
-  // ============================================================
-  // Private Helper Methods
-  // ============================================================
-  ensureBigNumber(value) {
-    if (value instanceof _BigNumber) return value;
-    if (typeof value === "number") return _BigNumber.fromNumber(value);
-    if (typeof value === "string") return _BigNumber.parse(value);
-    return _BigNumber.fromNumber(Number(value.valueOf()));
-  }
-  alignExponents(a, b) {
-    const minExp = Math.min(a._exponent, b._exponent);
-    const aShift = a._exponent - minExp;
-    const bShift = b._exponent - minExp;
-    const aCoef = aShift > 0 ? a._coefficient * BigInt(10) ** BigInt(aShift) : a._coefficient;
-    const bCoef = bShift > 0 ? b._coefficient * BigInt(10) ** BigInt(bShift) : b._coefficient;
-    return [aCoef, bCoef, minExp];
+    return this.unary(DUAL_UNARY_RULES.tanh);
   }
-  normalize(sign, coefficient, exponent) {
-    if (coefficient === 0n) {
-      return new _BigNumber(0, 0n, 0);
-    }
-    let coef = coefficient;
-    let exp = exponent;
-    while (coef % 10n === 0n && coef !== 0n) {
-      coef = coef / 10n;
-      exp++;
-    }
-    return new _BigNumber(sign, coef, exp);
+  toString() {
+    return `Dual(${this.value}, ${this.deriv})`;
   }
 };
-var BIGNUMBER_ZERO = BigNumber.fromNumber(0);
-var BIGNUMBER_ONE = BigNumber.fromNumber(1);
-var BIGNUMBER_NEG_ONE = BigNumber.fromNumber(-1);
-var BIGNUMBER_TEN = BigNumber.fromNumber(10);
-var BIGNUMBER_PI = BigNumber.parse("3.14159265358979323846264338327950288419716939937510");
-var BIGNUMBER_E = BigNumber.parse("2.71828182845904523536028747135266249775724709369995");
-var BIGNUMBER_LN2 = BigNumber.parse(
-  "0.69314718055994530941723212145817656807550013436026"
-);
-var BIGNUMBER_LN10 = BigNumber.parse(
-  "2.30258509299404568401799145468436420760110148862877"
-);
+function isDual(x) {
+  return x instanceof Dual;
+}
+
+// src/constants.ts
+var PI = Math.PI;
+var E = Math.E;
+var TAU = 2 * Math.PI;
+var PHI = (1 + Math.sqrt(5)) / 2;
+var SQRT2 = Math.SQRT2;
+var SQRT1_2 = Math.SQRT1_2;
+var LN2 = Math.LN2;
+var LN10 = Math.LN10;
+var LOG2E = Math.LOG2E;
+var LOG10E = Math.LOG10E;
 
 // src/types/unit-definitions.ts
 var DIMENSIONLESS = Object.freeze({
@@ -2574,449 +402,6 @@ function getPrefix(name) {
   return SI_PREFIXES[name];
 }
 
-// src/types/unit.ts
-var DimensionMismatchError = class extends Error {
-  constructor(left, right, op) {
-    super(
-      `Dimension mismatch in ${op}: ${formatDimensions(left)} vs ${formatDimensions(right)}`
-    );
-    this.left = left;
-    this.right = right;
-  }
-  left;
-  right;
-  name = "DimensionMismatchError";
-};
-var UnitParseError = class extends Error {
-  name = "UnitParseError";
-  constructor(notation, reason) {
-    super(`Cannot parse unit notation "${notation}": ${reason}`);
-  }
-};
-var DIM_KEYS = [
-  "length",
-  "mass",
-  "time",
-  "current",
-  "temperature",
-  "amount",
-  "luminosity"
-];
-function dimsEqual(a, b) {
-  for (const k of DIM_KEYS) {
-    if (a[k] !== b[k]) return false;
-  }
-  return true;
-}
-function dimsAdd(a, b) {
-  return {
-    length: a.length + b.length,
-    mass: a.mass + b.mass,
-    time: a.time + b.time,
-    current: a.current + b.current,
-    temperature: a.temperature + b.temperature,
-    amount: a.amount + b.amount,
-    luminosity: a.luminosity + b.luminosity
-  };
-}
-function dimsSub(a, b) {
-  return {
-    length: a.length - b.length,
-    mass: a.mass - b.mass,
-    time: a.time - b.time,
-    current: a.current - b.current,
-    temperature: a.temperature - b.temperature,
-    amount: a.amount - b.amount,
-    luminosity: a.luminosity - b.luminosity
-  };
-}
-function dimsScale(a, n) {
-  return {
-    length: a.length * n,
-    mass: a.mass * n,
-    time: a.time * n,
-    current: a.current * n,
-    temperature: a.temperature * n,
-    amount: a.amount * n,
-    luminosity: a.luminosity * n
-  };
-}
-function isDimensionless(d) {
-  return dimsEqual(d, DIMENSIONLESS);
-}
-function formatDimensions(d) {
-  const parts = [];
-  for (const k of DIM_KEYS) {
-    const e = d[k];
-    if (e !== 0) parts.push(`${k}^${e}`);
-  }
-  return parts.length === 0 ? "dimensionless" : parts.join("\xB7");
-}
-function resolveAtom(token) {
-  const aliased = UNIT_ALIASES[token] ?? token;
-  const direct = getUnitDef(aliased);
-  if (direct) {
-    return {
-      multiplier: direct.multiplier,
-      offset: direct.offset ?? 0,
-      dimensions: direct.dimensions,
-      prefix: "",
-      base: aliased
-    };
-  }
-  for (const prefix of SI_PREFIX_KEYS) {
-    if (!aliased.startsWith(prefix) || aliased.length === prefix.length) continue;
-    const rest = aliased.slice(prefix.length);
-    const baseDef = getUnitDef(rest);
-    if (!baseDef) continue;
-    if (!baseDef.prefixable) continue;
-    return {
-      multiplier: baseDef.multiplier * SI_PREFIXES[prefix],
-      // Offset is in base units, so prefix the multiplier but not the offset
-      // (we never apply prefixes to temperature units in practice anyway).
-      offset: baseDef.offset ?? 0,
-      dimensions: baseDef.dimensions,
-      prefix,
-      base: rest
-    };
-  }
-  throw new UnitParseError(token, `unknown unit "${token}"`);
-}
-function splitScalar(input) {
-  const m = input.match(/^\s*([+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\s+(.*)$/);
-  if (m) {
-    return { scalar: parseFloat(m[1]), rest: m[2].trim() };
-  }
-  const scalarOnly = input.match(/^\s*([+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\s*$/);
-  if (scalarOnly) {
-    return { scalar: parseFloat(scalarOnly[1]), rest: "" };
-  }
-  return { scalar: 1, rest: input.trim() };
-}
-function parseUnitExpr(expr) {
-  if (expr === "" || expr === "1") return [];
-  const normalized = expr.replace(/[·⋅]/g, "*");
-  const atoms = [];
-  let pos = 0;
-  let nextSign = 1;
-  while (pos < normalized.length) {
-    while (pos < normalized.length && /\s/.test(normalized[pos])) pos++;
-    if (pos >= normalized.length) break;
-    const ch = normalized[pos];
-    if (ch === "*") {
-      pos++;
-      continue;
-    }
-    if (ch === "/") {
-      nextSign = -1;
-      pos++;
-      continue;
-    }
-    if (ch === "1") {
-      const next = normalized[pos + 1];
-      if (next === void 0 || next === " " || next === "/" || next === "*") {
-        pos++;
-        continue;
-      }
-    }
-    if (!/[A-Za-z°µΩ]/.test(ch)) {
-      throw new UnitParseError(expr, `unexpected character "${ch}" at position ${pos}`);
-    }
-    const idStart = pos;
-    while (pos < normalized.length && /[A-Za-z°µΩ]/.test(normalized[pos])) pos++;
-    const identifier = normalized.slice(idStart, pos);
-    let exponent = 1;
-    if (pos < normalized.length && normalized[pos] === "^") {
-      pos++;
-      const expMatch = normalized.slice(pos).match(/^([+-]?\d+(?:\.\d+)?)/);
-      if (!expMatch) {
-        throw new UnitParseError(expr, `expected exponent after "^" at position ${pos}`);
-      }
-      exponent = parseFloat(expMatch[1]);
-      pos += expMatch[1].length;
-    } else {
-      const supMatch = normalized.slice(pos).match(/^([²³⁴⁵⁶⁷⁸⁹⁰¹]+)/);
-      if (supMatch) {
-        exponent = parseSuperscript(supMatch[1]);
-        pos += supMatch[1].length;
-      }
-    }
-    const resolved = resolveAtom(identifier);
-    atoms.push({
-      multiplier: resolved.multiplier,
-      offset: resolved.offset,
-      dimensions: resolved.dimensions,
-      exponent: nextSign * exponent,
-      source: identifier
-    });
-    nextSign = 1;
-  }
-  return atoms;
-}
-var SUPERSCRIPT_MAP = {
-  "\u2070": "0",
-  "\xB9": "1",
-  "\xB2": "2",
-  "\xB3": "3",
-  "\u2074": "4",
-  "\u2075": "5",
-  "\u2076": "6",
-  "\u2077": "7",
-  "\u2078": "8",
-  "\u2079": "9"
-};
-function parseSuperscript(s) {
-  let out = "";
-  for (const ch of s) out += SUPERSCRIPT_MAP[ch] ?? ch;
-  return parseInt(out, 10);
-}
-function parse(input) {
-  const { scalar, rest } = splitScalar(input);
-  return { scalar, atoms: parseUnitExpr(rest) };
-}
-var Unit = class _Unit {
-  /** Discriminator (matches the prototype-flag convention). */
-  type = "Unit";
-  /** Used by `isUnit()` and typed-function dispatch. */
-  isUnit = true;
-  /** Numeric magnitude in **SI base units**. */
-  value;
-  /** Dimensional signature. */
-  dimensions;
-  /** Original notation string, preserved for `toString()` round-trip. */
-  notation;
-  constructor(value, notationOrDims, notation) {
-    if (typeof notationOrDims === "string") {
-      const parsed = parse(notationOrDims);
-      const composed = composeAtoms(parsed.atoms);
-      const inputValue = parsed.scalar * value;
-      let canonical;
-      if (parsed.atoms.length === 1 && parsed.atoms[0].exponent === 1) {
-        const a = parsed.atoms[0];
-        canonical = inputValue * a.multiplier + a.offset;
-      } else {
-        canonical = inputValue * composed.multiplier;
-      }
-      this.value = canonical;
-      this.dimensions = composed.dimensions;
-      this.notation = notationOrDims;
-    } else {
-      this.value = value;
-      this.dimensions = notationOrDims;
-      this.notation = notation ?? "";
-    }
-  }
-  // -------------------------------------------------------------------------
-  // Arithmetic
-  // -------------------------------------------------------------------------
-  /**
-   * Add two units. Requires identical dimensions.
-   *
-   * @throws {DimensionMismatchError} if dimensions differ.
-   */
-  add(other) {
-    if (!dimsEqual(this.dimensions, other.dimensions)) {
-      throw new DimensionMismatchError(this.dimensions, other.dimensions, "add");
-    }
-    return new _Unit(this.value + other.value, this.dimensions, this.notation);
-  }
-  /**
-   * Subtract two units. Requires identical dimensions.
-   *
-   * @throws {DimensionMismatchError} if dimensions differ.
-   */
-  sub(other) {
-    if (!dimsEqual(this.dimensions, other.dimensions)) {
-      throw new DimensionMismatchError(this.dimensions, other.dimensions, "sub");
-    }
-    return new _Unit(this.value - other.value, this.dimensions, this.notation);
-  }
-  /**
-   * Multiply by another unit or a scalar. Dimensions add when multiplying by
-   * another unit; unchanged when multiplying by a scalar.
-   */
-  mul(other) {
-    if (typeof other === "number") {
-      return new _Unit(this.value * other, this.dimensions, this.notation);
-    }
-    return new _Unit(
-      this.value * other.value,
-      dimsAdd(this.dimensions, other.dimensions),
-      composeNotation(this.notation, other.notation, "*")
-    );
-  }
-  /**
-   * Divide by another unit or a scalar. Dimensions subtract when dividing by
-   * another unit; unchanged when dividing by a scalar.
-   */
-  div(other) {
-    if (typeof other === "number") {
-      return new _Unit(this.value / other, this.dimensions, this.notation);
-    }
-    return new _Unit(
-      this.value / other.value,
-      dimsSub(this.dimensions, other.dimensions),
-      composeNotation(this.notation, other.notation, "/")
-    );
-  }
-  /**
-   * Raise to an integer or rational power. Dimensions scale by `n`.
-   */
-  pow(n) {
-    return new _Unit(
-      this.value ** n,
-      dimsScale(this.dimensions, n),
-      this.notation ? `(${this.notation})^${n}` : ""
-    );
-  }
-  // -------------------------------------------------------------------------
-  // Conversion
-  // -------------------------------------------------------------------------
-  /**
-   * Convert to a target unit. Dimensions must match.
-   *
-   * @throws {DimensionMismatchError} if `targetNotation`'s dimensions differ
-   *   from this unit's.
-   */
-  to(targetNotation) {
-    const parsed = parse(targetNotation);
-    const composed = composeAtoms(parsed.atoms);
-    if (!dimsEqual(this.dimensions, composed.dimensions)) {
-      throw new DimensionMismatchError(
-        this.dimensions,
-        composed.dimensions,
-        `to("${targetNotation}")`
-      );
-    }
-    return new _Unit(this.value, composed.dimensions, targetNotation);
-  }
-  /**
-   * Pick a unit (with SI prefix) that gives a magnitude closest to 1.
-   *
-   * Searches the unit registry for entries matching this unit's dimensions,
-   * then applies each SI prefix in {@link BEST_PREFIXES} to find the
-   * representation minimising `|log10(displayed value)|`.
-   *
-   * If no registered unit matches the dimensions, falls back to a synthetic
-   * notation describing the dimensional vector.
-   */
-  toBest() {
-    if (isDimensionless(this.dimensions)) {
-      return new _Unit(this.value, this.dimensions, "");
-    }
-    let bestNotation;
-    let bestScore = Infinity;
-    for (const [name, def] of Object.entries(ALL_UNITS)) {
-      if (name === "kg") continue;
-      if (!dimsEqual(def.dimensions, this.dimensions)) continue;
-      if (def.offset !== void 0) continue;
-      const candidatePrefixes = def.prefixable ? BEST_PREFIXES : [""];
-      for (const prefix of candidatePrefixes) {
-        const factor = prefix === "" ? def.multiplier : def.multiplier * SI_PREFIXES[prefix];
-        if (factor === 0) continue;
-        const displayed = this.value / factor;
-        if (displayed === 0) continue;
-        const score = Math.abs(Math.log10(Math.abs(displayed)));
-        if (score < bestScore) {
-          bestScore = score;
-          bestNotation = prefix + name;
-        }
-      }
-    }
-    if (bestNotation === void 0) {
-      return new _Unit(
-        this.value,
-        this.dimensions,
-        this.notation || formatDimensions(this.dimensions)
-      );
-    }
-    return new _Unit(this.value, this.dimensions, bestNotation);
-  }
-  // -------------------------------------------------------------------------
-  // Comparison
-  // -------------------------------------------------------------------------
-  /** True iff dimensions and canonical value are equal. */
-  equals(other) {
-    return dimsEqual(this.dimensions, other.dimensions) && this.value === other.value;
-  }
-  /** True iff dimensions match (values may differ). */
-  dimensionsEqual(other) {
-    return dimsEqual(this.dimensions, other.dimensions);
-  }
-  // -------------------------------------------------------------------------
-  // Formatting
-  // -------------------------------------------------------------------------
-  /**
-   * Pretty-print. If `notation` is set (the common case), display the value
-   * in that notation — otherwise emit a dimensional signature.
-   */
-  toString() {
-    if (this.notation === "") {
-      if (isDimensionless(this.dimensions)) return String(this.value);
-      return `${this.value} ${formatDimensions(this.dimensions)}`;
-    }
-    const displayed = displayedValue(this.value, this.notation);
-    return `${formatNumber(displayed)} ${this.notation}`;
-  }
-  /** JSON-serialisable record. */
-  toJSON() {
-    return { mathts: "Unit", value: this.value, notation: this.notation };
-  }
-  /**
-   * Rehydrate from a JSON record produced by {@link toJSON}.
-   *
-   * @throws {UnitParseError} if `json.notation` cannot be parsed.
-   */
-  static fromJSON(json) {
-    const parsed = parse(json.notation);
-    const composed = composeAtoms(parsed.atoms);
-    return new _Unit(json.value, composed.dimensions, json.notation);
-  }
-  /**
-   * Parse a full unit expression (with optional leading numeric coefficient).
-   *
-   * Example: `Unit.parse('5 km/h')`.
-   */
-  static parse(input) {
-    const { scalar, rest } = splitScalar(input);
-    return new _Unit(scalar, rest);
-  }
-};
-Unit.prototype.isUnit = true;
-function composeAtoms(atoms) {
-  let multiplier = 1;
-  let dimensions = { ...DIMENSIONLESS };
-  for (const a of atoms) {
-    multiplier *= a.multiplier ** a.exponent;
-    dimensions = dimsAdd(dimensions, dimsScale(a.dimensions, a.exponent));
-  }
-  return { multiplier, dimensions };
-}
-function displayedValue(canonical, notation) {
-  const parsed = parse(notation);
-  const composed = composeAtoms(parsed.atoms);
-  if (parsed.atoms.length === 1 && parsed.atoms[0].exponent === 1) {
-    const a = parsed.atoms[0];
-    return (canonical - a.offset) / a.multiplier;
-  }
-  return canonical / composed.multiplier;
-}
-function formatNumber(n) {
-  if (Number.isInteger(n)) return n.toString();
-  const rounded = Number(n.toPrecision(12));
-  return rounded.toString();
-}
-function composeNotation(a, b, op) {
-  if (a === "" && b === "") return "";
-  if (a === "") return op === "*" ? b : `1/${b}`;
-  if (b === "") return a;
-  const sep = op === "*" ? "*" : "/";
-  return `${a}${sep}${b}`;
-}
-function isUnit(value) {
-  return value instanceof Unit;
-}
-
 // src/typed/mathts-typed.ts
 import typed, { create } from "typed-function";
 var wasmInitialized = false;
@@ -3520,6 +905,7 @@ export {
   DEFAULT_CONFIG,
   DERIVED_UNITS,
   DIMENSIONLESS,
+  DUAL_UNARY_RULES,
   DimensionMismatchError,
   Dual,
   E,
@@ -3549,11 +935,16 @@ export {
   Unit,
   UnitParseError,
   VERSION,
+  abs,
+  addScalar,
   create,
   createFactory,
   createMathTSTyped,
   createTypedFunction,
   dim,
+  divideScalar,
+  equal,
+  fix,
   getPrefix,
   getUnitDef,
   initTypedWasm,
@@ -3569,6 +960,7 @@ export {
   isMatrix,
   isNull,
   isNumber,
+  isNumeric,
   isObject,
   isSparseMatrix,
   isString,
@@ -3578,7 +970,12 @@ export {
   isUnit as isUnitValue,
   math,
   mathTyped,
+  multiplyScalar,
+  number,
+  pow,
   registerNativeTypes,
   registry,
+  round,
+  subtractScalar,
   typed
 };