Function bigErfInv

src/compute-engine/numerics/special-functions.ts:3043–3071

(ce: ComputeEngine, x: BigNum)

 * with the term recurrence tₙ = tₙ₋₁ · x²·(2n−1) / (n·(2n+1)).
 * Odd function. Grows like e^{x²}, so it overflows to ±∞ for large |x|.
 */
export function erfi(x: number): number {
  if (Number.isNaN(x)) return NaN;
  if (x === 0) return 0;
  if (!Number.isFinite(x)) return x > 0 ? Infinity : -Infinity;

  const sign = x < 0 ? -1 : 1;
  const ax = Math.abs(x);
  const x2 = ax * ax;
  let term = ax; // n = 0 term: x
  let sum = ax;
  for (let n = 1; n < 1000; n++) {
    term *= (x2 * (2 * n - 1)) / (n * (2 * n + 1));
    sum += term;
    if (term < sum * 1e-18) break;
  }
  return sign * (2 / Math.sqrt(Math.PI)) * sum;
}

/**
 * Bignum imaginary error function. The Maclaurin series above has only
 * positive terms (no cancellation), so the relative error tracks the working
 * precision. Precision scales with `BigDecimal.precision`.
 */
function bigErfiSeries(x: BigNum, tolDigits: number): BigNum {
  const x2 = x.mul(x);
  let term = x; // n = 0
  let sum = x;
  const tol = new BigDecimal(10).pow(-tolDigits);
  const maxTerms = 1000 + 10 * Math.ceil(x2.toNumber()) + 10 * tolDigits;
  for (let n = 1; n <= maxTerms; n++) {
    // tₙ = tₙ₋₁ · x²·(2n−1) / (n·(2n+1))