Function bigintDigits

src/big-decimal/utils.ts:198–237

(n: bigint)

/** Count the number of decimal digits in a bigint (absolute value). */
export function bigintDigits(n: bigint): number {
  if (n === 0n) return 1;
  if (n < 0n) n = -n;
  // Fast path: fits in a Number (< 2^53), so `Number(n)` is exact. Resolve the
  // digit count with an exact float comparison ladder (a 4-deep binary search
  // over the 16 possible lengths) rather than `Math.floor(Math.log10(x)) + 1`.
  // The `log10` form is not only a libm call but *wrong* at a power-of-ten
  // boundary: `Math.log10(999999999999999) === 15` rounds up, so it returned 16
  // for the fifteen-nines value (and 999999999999998), over-counting by one and
  // corrupting every consumer that derives an order of magnitude from the count
  // (`cmp`'s magnitude early-out could invert an ordering; `toPrecision(15)` of
  // a genuine 15-digit value rounded it to 1e15). Every power 10^0…10^15 is an
  // exact double (10^15 < 2^53) and `x` is exact, so each comparison is exact —
  // the ladder is correct by construction and needs no boundary fix-up. It is
  // also faster than the old path (no `log10`): ~17–34% in an A/B micro-bench.
  if (n < 0x20000000000000n) {
    const x = Number(n);
    if (x < 1e8) {
      if (x < 1e4) return x < 1e2 ? (x < 1e1 ? 1 : 2) : x < 1e3 ? 3 : 4;
      return x < 1e6 ? (x < 1e5 ? 5 : 6) : x < 1e7 ? 7 : 8;
    }
    if (x < 1e12) return x < 1e10 ? (x < 1e9 ? 9 : 10) : x < 1e11 ? 11 : 12;
    return x < 1e14 ? (x < 1e13 ? 13 : 14) : x < 1e15 ? 15 : 16;
  }
  // Large bigints: seed the decimal digit count from the hex-string length.
  // `n.toString(16).length` is a single near-linear native base-16 conversion
  // (hex being a power of 2, it is far cheaper than a base-10 stringification)
  // and gives `bits/4` rounded up — i.e. an upper bound on the bit length, high
  // by at most the 3 bits the top nibble may leave unused. That is ≤ ~1 decimal
  // digit of slack, which the cached-pow10 boundary walk (0–2 steps) settles
  // exactly. Replaces the doubling + binary-search bit-length scan, whose
  // ~2·log2(bits) per-step `tmp >> BigInt(shift)` calls each allocated a fresh
  // full-width bigint. Byte-identical result; ~2–4× faster in the 30–500-digit
  // working-precision range that dominates div/cmp operand sizing.
  const bits = n.toString(16).length * 4;
  let approx = Math.ceil(bits * 0.30102999566398);
  while (n < pow10(approx - 1)) approx--;
  while (n >= pow10(approx)) approx++;
  return approx;
}

/**
 * Extra argument-reduction depth for `fpexp`, as a multiple of √bits.