Function numericAt

src/compute-engine/symbolic/limit.ts:721–754

(
  e: Expression,
  x: string,
  xv: number,
  ce: ComputeEngine
)

function limitRatioAtPosInf(
  num: Expression,
  den: Expression,
  x: string,
  ce: ComputeEngine,
  depth: number
): Expression | undefined {
  checkDeadline(ce._deadlineFrame);
  // Bail on a numerator/denominator that suffers catastrophic cancellation or
  // overflow at the probe points (e.g. e^stuff − eˣ, whose huge terms cancel to
  // a far smaller value): neither the asymptotic nor the numeric pass can rank
  // it reliably, so defer to the numeric limit (which has its own guard).
  if (hasCancellation(num, x, ce) || hasCancellation(den, x, ce))
    return undefined;

  const n = leadingOrder(num, x, ce, depth).simplify();
  const d = leadingOrder(den, x, ce, depth).simplify();

  // Compare growth *first*. (Simplifying the quotient first can re-expand it
  // back into the original product and loop — e.g. x/(1/ln(1+a/x)).)
  const cmp = compareGrowth(n, d, x, ce);
  if (cmp !== undefined) {
    if (cmp < 0) return ce.Zero; // numerator grows slower → 0
    if (cmp > 0) {
      const s = leadingSign(n, x, ce) * leadingSign(d, x, ce);
      return s < 0 ? ce.NegativeInfinity : ce.PositiveInfinity;
    }
    // Same growth order → ratio of leading coefficients.
    const r = n.div(d).simplify();
    if (!r.has(x)) return r.evaluate();
    return leadingCoefficientRatio(n, d, x, ce);
  }

  // Growth comparison inconclusive: a genuine 0/0 or ∞/∞ that the asymptotic
  // pass couldn't rank → L'Hôpital (differentiate top and bottom, recurse).
  if (depth < MAX_DEPTH) {
    const dn = differentiate(n, x);
    const dd = differentiate(d, x);
    if (dn && dd && !dd.is(0)) {