Method intUncached

src/compute-engine/rubi/driver.ts:403–704

(
    integrand: Expression,
    variable: string,
    depth: number
  )

    // Bail if this is a re-entrant call triggered while building a display-only
    // rule template (a `Subst` template can `.evaluate()` an inert `Integrate`,
    // which re-enters the provider): pretend we can't integrate rather than
    // clobber the outer call's deadline/memo.
    if (this.templateBuilding) return null;
    // This method can be re-entered while a call is in flight: the
    // native-rational fallback goes through `ce.Integrate.evaluate()` (see
    // nativeRationalFallback), and `build()` can `.evaluate()` an expression
    // containing an inert `Integrate` (a With-binding whose `Int[…]` didn't
    // close, the general `Subst` path) — both land back here via the
    // provider. A re-entrant call must NOT clobber the outer call's
    // per-call state: resetting the deadline would grant the outer
    // integration a fresh time budget (violating the interruptible-
    // evaluation contract), clearing the memo would wipe the outer call's
    // in-flight cycle-guard entries (re-opening infinite recursion on
    // cyclic subproblems), and resetting `trigActive` (and the caches)
    // would leak the subproblem's state back into the outer recursion — a
    // trig integrand whose subproblem hits the fallback could otherwise
    // emit inert lowercase trig heads. So: a re-entrant call — detected by
    // the in-flight counter, NOT just the native-fallback flag — inherits
    // the outer deadline and memo, and its clobber of `trigActive`/caches
    // is snapshotted and restored on the way out.
    const reentrant = this.activeCalls > 0;
    const savedTrig = this.trigActive;
    const savedCaches = getActiveCaches();
    // Step-tracing accumulator (only when `explain('Integrate')` threads one
    // in). A re-entrant call passes no `records`, so the outer's accumulator is
    // left in place; recording is suppressed for its duration — a re-entrant
    // subproblem is internal to whatever expression the outer step records.
    const savedRecords = this.records;
    if (records !== undefined) this.records = records;
    if (reentrant) this.suppressRecording++;
    this.activeCalls++;
    if (!reentrant) {
      this.deadline = Date.now() + (this.options.timeLimitMs ?? 30_000);
      // Bound the memo to a single top-level call: it is a per-call cache +
      // cycle guard, not a cross-call one (rules don't consult assumptions
      // today, but if they did, a stale pre-assumption result could be
      // served verbatim). Clearing here caps its growth and sidesteps that
      // staleness. Not cleared on re-entry — that would wipe the outer
      // call's in-flight cycle-guard entries.
      this.memo.clear();
    }
    // fresh predicate caches per call (zeroQ/simplify results recur heavily
    // across the rule scan); the outer call's caches are restored below when
    // this is a re-entrant call.
    installCaches({ zeroQ: new Map(), simplify: new Map() });
    // Chapter-4 rules match against inert trig (`cos`/`sin`); detect active
    // trig once so intRec can deactivate the integrand (and its recursive
    // subproblems). Results are re-activated on the way out.
    this.trigActive = hasActiveTrig(integrand);
    // Re-activate inert heads on the way out, then normalize the trig form:
    // the cosine→sine cofunction shift (unifyInertTrig) leaves `sin(θ+π/2)`
    // etc. in the result; `simplifyTrig` folds those back to `cos(θ)` so the
    // answer reads cleanly (Rubi relies on Mathematica's auto-simplification
    // for the same step). Sound identities only — never changes the value.
    const activate = (e: Expression | null): Expression | null =>
      e !== null && this.trigActive
        ? cleanTrig(this.ce, activateTrig(this.ce, e))
        : e;