Function loadIntegrationRules

src/compute-engine/rubi/loader.ts:53–93

(
  ce: ComputeEngine,
  options?: IntegrationRulesLoadOptions
)

/**
 * Compile the bundled Rubi rules and register them as the engine's symbolic
 * integration provider. Idempotent per engine (re-registers the provider,
 * reusing the cached compiled rules).
 */
export function loadIntegrationRules(
  ce: ComputeEngine,
  options?: IntegrationRulesLoadOptions
): IntegrationRulesLoadReport {
  let result = compiledCache.get(ce);
  if (!result) {
    result = compileRuleDocs(ce, RUBI_RULES_DATA as unknown as RubiRuleDoc[]);
    compiledCache.set(ce, result);
  }
  const compiled = result.rules;
  const skipped = result.skipped;

  const driver = new RubiDriver(ce, compiled, {
    timeLimitMs: options?.timeLimitMs ?? 10_000,
  });

  ce._integrationProvider = (
    integrand: Expression,
    variable: string,
    trace?: RuleSteps
  ) => {
    // The `Integrate` evaluator passes the integrand wrapped in
    // `Function`/`Block`/`Delimiter` scaffolding; the rule driver wants the
    // bare integrand (the built-in antiderivative unwraps these too).
    let f = integrand;
    while (
      f.operator === 'Function' ||
      f.operator === 'Block' ||
      f.operator === 'Delimiter'
    )
      f = f.op1!; // Function/Block/Delimiter always have a first operand
    // Only accumulate a step trace when `explain('Integrate')` asked for one.
    const records: IntStepRecord[] | undefined = trace ? [] : undefined;
    const result = driver.int(f, variable, records);
    // Only a fully-closed antiderivative is usable; a residual inert
    // `Integrate` means the rules couldn't finish — defer to the built-in
    // antiderivative instead of returning a partial result.
    if (result === null || containsIntegrate(result)) return null;
    if (trace && records) {
      // Replay the recorded steps into whole-state steps. No closing step is
      // pushed here: the caller (`explainIntegrate`) appends a final