Function limit

src/compute-engine/numerics/numeric.ts:364–397

(
  f: (x: number) => number,
  x: number,
  dir = 1,
  deadline?: number
)

 *  - catastrophic cancellation: the magnitude grows to an interior peak and
 *    then collapses to ~0.
 *
 * Beyond that horizon the samples are floating-point garbage. Left unchecked,
 * a collapse to a run of identical `0`s makes `extrapolate` report `err = 0`
 * (perfect "convergence") and return a spurious value — e.g.
 * `lim_{x→∞} (e^{x·e^{−x}/…} − eˣ)/x = −e²`, whose two `eˣ` terms cancel to 0
 * around x ≈ 40 and overflow to `NaN` past x ≈ 710, yielding a wrong `0`.
 * Capping `extrapolate`'s `maxeval` to the clean prefix makes it report
 * non-convergence instead, so `limit()` returns `NaN` (not-evaluable).
 *
 * The schedule here must mirror `extrapolate()` (default `contract = 0.125`,
 * and the `x = 1/u` change of variables for an infinite target).
 */
function reliableLimitSamples(
  f: (x: number) => number,
  x0: number,
  step: number,
  deadline?: number
): number {
  const CONTRACT = 0.125; // must match extrapolate()'s default contract
  const MAX = 60;
  const inf = !Number.isFinite(x0);
  // The actual argument passed to `f` for a given step `h` (with the `x = 1/u`
  // change of variables for an infinite target, matching extrapolate()).
  const arg = (h: number) => (inf ? 1 / h : x0 + h);

  // A run of (nearly) identical samples can be a real limit, or a
  // floating-point artifact: a function whose numerically-meaningful window is
  // narrower than the ladder spacing reads as a constant because every ladder
  // point lands in an overflow/underflow region (e.g. a denominator with a
  // triple exponential overflows for all x ≳ 2, so f ≈ 0 at x = 1, 8, 64 …
  // while the true value lives near x ≈ 1.5). Corroborate by probing a few
  // points *between* the two ladder steps; the settle is real only if they all
  // match.
  const settleIsReal = (hA: number, hB: number, v: number): boolean => {
    // A generous tolerance: we are separating real fp noise (a converging
    // sequence such as (1+1/x)^x is noisy to ~x·ε near its limit) from a
    // genuinely skipped window (an overflow artifact's true value differs by an