Exp2(7000000000, 3) throws OverflowException while Exp2(7000000000.5, 3) works, and integer Exp2 ignores significantDigits: Exp2(5000000, 10) builds 1.5 million digits in 3.3 s #150

What's wrong

Exp2(x, significantDigits) sends every integer x to Two.Pow(x):

Pow's integer path is exact exponentiation by squaring, and it begins with power.Abs().To<int>():

That causes two problems:

1. It throws for large exponents. For |x| ≥ 2^31, To<int> throws, even though 2^x is easily representable to the requested digits.
2. It ignores the requested precision. For large |x|, the exact result has about 0.301·|x| digits (0.699·|x| for negative x). All of them are computed and returned regardless of significantDigits.

Every non-integer x takes the exp(x · ln 2) path, which is fast and correctly rounded. So does Exp2M1, even when its argument is an integer.

Reproduction (net10.0, Release)

The remark on Exp2 says "An integer power of two is produced by repeated squaring, which is exact". That contradicts the method's own significantDigits parameter. Exp10 already treats an integer argument as a pure exponent shift, and Exp2M1 honours the requested precision.

Why it matters

How fast the call is, and whether it throws, depends on whether x happens to be an integer. For example, Exp2(n, 20) in a loop over n hangs or crashes on values whose non-integer neighbours return instantly. Producing x · log10(2) digits for a call that asked for 3 is a large and unexpected cost.

Related: #128 is the same To<int> limit in Pow(-1, n). #123 (closed) fixed the non-integer path.

Suggested fix and acceptance criteria

• In Exp2, use the exact Two.Pow(x) only when the exact result fits in significantDigits:
  • positive x: when |x|·log10 2 ≤ significantDigits
  • negative x: when the 0.699·|x| digits of 5^|x| fit
• Otherwise, use ExpOfProductWithConstant, which the tests already show is correctly rounded at magnitudes like these.
• Keep Exp2(10) == 1024 and Exp2(-3) == 0.125 exact, as pinned today.
• Tests:
  • Exp2(7000000000, 3) == 4.44e2107209969
  • Exp2(-6000000000, 5) == 1.0378e-1806179974
  • Exp2(5000000, 10) returns 10 digits in under 100 ms
• Update the remark on Exp2.