Method intRec

src/compute-engine/rubi/driver.ts:312–401

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

  // `Integrate`, which re-enters the provider → this driver; the flag makes
  // that re-entrant `int()` bail immediately so it cannot clobber the outer
  // call's deadline/memo.
  private templateBuilding = false;
  readonly stats: DriverStats = {
    calls: 0,
    ruleFirings: {},
    preludeFirings: 0,
    failures: 0,
    trace: [],
  };

  constructor(
    private readonly ce: ComputeEngine,
    private readonly rules: CompiledRule[],
    private readonly options: {
      timeLimitMs?: number;
      trace?: boolean;
      /** @internal Force the legacy full-scan dispatch (root-operator
       * prescreen only), bypassing the skeleton screen. Overrides the
       * `RUBI_NO_SKELETON` env default. For the A/B equivalence harness. */
      noSkeleton?: boolean;
    } = {}
  ) {}

  // Per-root-operator candidate lists: the rules whose root-operator prescreen
  // admits an integrand with that operator (rootOp === op, plus the wildcard
  // rootOp === null rules that can match any root). Built lazily and cached —
  // the operator alphabet is tiny (Multiply/Power/a few heads), so this is
  // effectively "once per bundle". Each list is a stable subsequence of the
  // ordered `this.rules`, preserving the original priority order exactly.
  private readonly candidateCache = new Map<string, CompiledRule[]>();
  private candidatesFor(operator: string): CompiledRule[] {
    let list = this.candidateCache.get(operator);
    if (list === undefined) {
      list = this.rules.filter(
        (r) => r.rootOp === null || r.rootOp === operator
      );
      this.candidateCache.set(operator, list);
    }
    return list;
  }

  // ── step recording (active only when `this.records` is set) ────────────
  /** The current `records` length, or 0 when not tracing. Capture before an
   * attempt so it can be rolled back with `truncate` if the attempt fails. */
  private mark(): number {
    return this.records?.length ?? 0;
  }
  /** Drop every record pushed since `mark` (attempt-scoped rollback). */
  private truncate(mark: number): void {
    if (this.records) this.records.length = mark;
  }
  /** Push a step record, returning its index (or -1 when not recording).
   * `node`/`replacement` are thunks so their (sometimes non-trivial)
   * construction is skipped entirely on the hot, non-tracing path. */
  private record(
    node: () => Expression,
    replacement: () => Expression | null,
    because: string