Function numericTendsToInfinity

src/compute-engine/symbolic/limit.ts:756–771

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

  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) {
      // The sign of each term is read from a numeric probe. A probe with no
      // value (a symbolic coefficient, as in `a·eˣ/x`) leaves the sign of
      // the infinity undecided: decline.
      const sn = numericAt(n, x, 120, ce);
      const sd = numericAt(d, x, 120, ce);
      if (Number.isNaN(sn) || Number.isNaN(sd) || sn === 0 || sd === 0)
        return undefined;
      return sn < 0 !== sd < 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();