Method div

src/big-decimal/big-decimal.ts:701–771

* Divide this value by another. * Uses `BigDecimal.precision` to determine significant digits for inexact results. * * Special cases: * - NaN / x → NaN, x / NaN → NaN * - nonzero / 0 → +/-Infinity (matching Decimal.js behavior) * - 0 / 0 → NaN * - Inf / finite → Inf (correct

(other: BigDecimal | number)

   *  - Inf / Inf → NaN
   */
  div(other: BigDecimal | number): BigDecimal {
    if (typeof other === 'number') other = new BigDecimal(other);

    const thisExp = this.exponent;
    const otherExp = other.exponent;
    const thisSig = this.significand;
    const otherSig = other.significand;

    // Fast path: both finite
    if (Number.isFinite(thisExp) && Number.isFinite(otherExp)) {
      // Division by zero
      if (otherSig === 0n) {
        if (thisSig === 0n) return BigDecimal.NAN; // 0/0 → NaN
        return thisSig > 0n
          ? BigDecimal.POSITIVE_INFINITY
          : BigDecimal.NEGATIVE_INFINITY;
      }
      // 0 / nonzero → 0
      if (thisSig === 0n) return fromRaw(0n, 0);

      // General case
      const prec = BigDecimal.precision;
      const guard = 10;
      const dividendDigits = this._digitCount();
      const divisorDigits = other._digitCount();
      const totalScale =
        prec + guard + Math.max(0, divisorDigits - dividendDigits);
      const scale = pow10(totalScale);
      const quotient = (thisSig * scale) / otherSig;
      const resultExp = thisExp - otherExp - totalScale;
      // The quotient carries `prec + guard` digits (guard = 10), so rounding it
      // to `prec` always happens — it can never hit the `digits <= n → return
      // this` short-circuit. Two economies over `…toPrecision(prec)`:
      //
      // 1. Skip normalizing the (large) quotient: stripping z trailing zeros
      //    scales the significand, the rounding divisor, and the round-half-even
      //    tie point all by 10^z, so the rounded significand/exponent is
      //    byte-identical either way, and the rounding re-normalizes its own
      //    (smaller) result. Saves one full-width normalize per division.
      // 2. Derive the quotient's digit count instead of recomputing it with a
      //    `bigintDigits` bit-length scan. The numerator `thisSig·10^totalScale`
      //    has exactly `dividendDigits + totalScale` digits; dividing by an
      //    `otherSig` of `divisorDigits` digits yields a quotient of exactly
      //    `lo` or `lo + 1` digits (integer division of an a-digit by a b-digit
      //    value gives a−b or a−b+1 digits). Resolve the ±1 with one cached-pow10
      //    boundary compare. `lo ≥ prec + guard > prec`, so it always rounds.
      const absQuot = quotient < 0n ? -quotient : quotient;
      const lo = dividendDigits + totalScale - divisorDigits;
      const quotientDigits = absQuot >= pow10(lo) ? lo + 1 : lo;
      return rawUnnormalized(quotient, resultExp).roundToPrecKnownDigits(
        prec,
        quotientDigits
      );
    }

    // Slow path: NaN or Infinity
    if (thisExp !== thisExp || otherExp !== otherExp) return BigDecimal.NAN;