Method mod

src/big-decimal/big-decimal.ts:884–914

* Modulo (remainder after truncating division). * Defined as: this - trunc(this / other) * other * * The sign of the result matches the sign of the dividend (this), * consistent with JavaScript's % operator and Decimal.js.

(other: BigDecimal | number)

   * consistent with JavaScript's % operator and Decimal.js.
   */
  mod(other: BigDecimal | number): BigDecimal {
    if (typeof other === 'number') other = new BigDecimal(other);

    const thisExp = this.exponent;
    const otherExp = other.exponent;

    // Fast path: both finite
    if (Number.isFinite(thisExp) && Number.isFinite(otherExp)) {
      if (other.significand === 0n) return BigDecimal.NAN; // x mod 0 → NaN
      if (this.significand === 0n) return fromRaw(0n, 0); // 0 mod x → 0

      // Compute trunc(this / other) EXACTLY with bigints. Using the
      // precision-bounded `div` here would round the quotient before
      // truncating, producing a wrong remainder whenever |this / other|
      // exceeds the working precision (e.g. `1e60 mod 3`).
      //   this / other = (s₁ · 10^(e₁−e₂)) / s₂
      const ediff = thisExp - otherExp;
      const num =
        ediff >= 0 ? this.significand * pow10(ediff) : this.significand;
      const den =
        ediff >= 0 ? other.significand : other.significand * pow10(-ediff);
      const q = num / den; // bigint division truncates toward zero
      return this.sub(fromRaw(q, 0).mul(other));
    }

    // Slow path: NaN or Infinity
    if (thisExp !== thisExp || otherExp !== otherExp) return BigDecimal.NAN;
    if (!Number.isFinite(thisExp)) return BigDecimal.NAN; // Inf mod x → NaN
    // finite mod Inf → this
    return new BigDecimal(this);
  }

  /**
   * Raise to a power.