Method dispatch

src/compute-engine/rubi/driver.ts:477–585

(envCap: number)

      // rules don't yet cover. Bounded by the same wall-clock budget. This
      // rules+native coexistence is exactly how `loadIntegrationRules` is
      // meant to ship.
      this.suppressRecording++;
      let nf: Expression | null;
      try {
        nf = this.nativeRationalFallback(integrand, variable);
      } finally {
        this.suppressRecording--;
      }
      if (nf !== null)
        this.record(
          () => this.ce._fn('Integrate', [integrand, this.ce.symbol(variable)]),
          () => nf,
          'integrate.partial-fractions'
        );
      return nf;
    } catch (e) {
      // An engine deadline firing inside evaluate()/simplify(), or the
      // matcher's own deadline (see match.ts), surfaces as a
      // CancellationError — deadline exhaustion, not a crash: report "no
      // rule chain applied" like any other timeout. Detect it via the
      // `name` instance property (set as a string literal in the
      // constructor): `instanceof CancellationError` fails across the
      // host/plugin bundle split, and `constructor.name` is mangled by
      // minification.
      if (e instanceof Error && e.name === 'CancellationError') return null;
      throw e;
    } finally {
      // Restore the outer call's state clobbered by this re-entry (see the
      // header comment); a genuine top-level call leaves its state in place.
      this.activeCalls--;
      if (reentrant) {
        this.suppressRecording--;
        this.trigActive = savedTrig;
        installCaches(savedCaches);
      }
      this.records = savedRecords;
    }
  }

  /** Engine-native antiderivative fallback for a rational integrand the Rubi
   * rule set didn't close (see int()). Returns null when the integrand is
   * not a rational function of `variable`, the wall-clock budget is spent,
   * or the native integrator can't close it either (result still inert). */
  private nativeRationalFallback(
    integrand: Expression,
    variable: string
  ): Expression | null {
    if (NO_NATIVE_RATIONAL) return null;
    if (this.inNativeFallback) return null; // re-entry guard (see field)
    if (!rationalFnQ(integrand, variable)) return null;
    // Numeric-coefficient integrands only. Symbolic-parameter rationals
    // (e.g. 1/((a+b·x)(c+d·x)(e+f·x))) need symbolic polynomial factoring
    // the native integrator can't do — it can't close them, and its
    // factoring path doesn't poll the deadline, so it overruns the budget
    // badly (observed 80 s+). Restricting to free-of-parameters integrands
    // keeps the wins and bounds the cost.
    if (integrand.unknowns.some((u) => u !== variable)) return null;
    const ce = this.ce;