Method mulToPrecision

src/big-decimal/big-decimal.ts:558–589

* Fused multiply-then-round: equivalent to `this.mul(other).toPrecision(prec)` * but skips the intermediate normalize of the full-width product and the * `bigintDigits` re-scan that `toPrecision` would otherwise run on it — the * same double-work class the `div` fix eliminated. * * Th

(other: BigDecimal | number, prec: number)

   * @internal
   */
  _mulToPrecision(other: BigDecimal | number, prec: 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 and nonzero (the product is a plain integer
    // multiply whose digit count is derivable from the operand sizes).
    if (
      thisSig !== 0n &&
      otherSig !== 0n &&
      Number.isFinite(thisExp) &&
      Number.isFinite(otherExp)
    ) {
      const productSig = thisSig * otherSig;
      const productExp = thisExp + otherExp;
      // da+db-1 ≤ digits(|a·b|) ≤ da+db; one cached-pow10 compare resolves ±1.
      const lo = this._digitCount() + other._digitCount() - 1;
      const absProd = productSig < 0n ? -productSig : productSig;
      const rawDigits = absProd >= pow10(lo) ? lo + 1 : lo;
      if (rawDigits <= prec) return fromRaw(productSig, productExp);
      return rawUnnormalized(productSig, productExp).roundToPrecKnownDigits(
        prec,
        rawDigits
      );
    }

    // Slow path: NaN, Infinity, or a zero operand — defer to the plain path.
    return this.mul(other).toPrecision(prec);
  }

  /**
   * Negate this value. Zero.neg() → Zero.