Function runOn

benchmarks/audit/wester.ts:239–304

(engine: any, c: Case)

    const hi = numAt(ce, f, c.varName, a0 + H), lo = numAt(ce, f, c.varName, a0 - H);
    if (hi == null || lo == null || Math.abs(hi - lo) > 1e-3 * (1 + Math.abs(hi))) return [null];
    return [(hi + lo) / 2];
  }
  if (c.op === 'defint') {                                                                    // composite Simpson
    const a0 = Number(c.a), b0 = Number(c.b), n = 200, h = (b0 - a0) / n;
    let sum = 0;
    for (let i = 0; i <= n; i++) {
      const y = numAt(ce, f, c.varName, a0 + i * h);
      if (y == null) return [null];
      sum += (i === 0 || i === n ? 1 : i % 2 ? 4 : 2) * y;
    }
    return [(h / 3) * sum];
  }
  return POINTS.map((p) => numAt(ce, f, c.varName, p));                                       // factor/expand/simplify
}

// --- run one configuration --------------------------------------------------
// When `engine` has the Rubi rules loaded (the CE+R/F engine), `Integrate`
// consults them automatically, so every op runs through the same code path on
// every engine.
function runOn(engine: any, c: Case) {
  try {
    if (c.op === 'integrate') {
      const build = () => engine.expr(['Integrate', c.arg, ['Tuple', c.varName]]).evaluate();
      const timeMs = timeit(build);
      const F = build();
      if (F == null || F.operator === 'Integrate' || /\bint\(/.test(F.toString())) return { status: 'unsolved', text: F ? F.toString() : 'null', values: [], timeMs };
      const dF = engine.expr(['D', F, c.varName]).evaluate();
      return { status: 'ok', text: F.toString(), values: POINTS.map((p) => numAt(engine, dF, c.varName, p)), timeMs };
    }
    if (c.op === 'defint') {
      const build = () => engine.expr(['Integrate', c.arg, ['Tuple', c.varName, c.a, c.b]]);
      const timeMs = timeit(() => build().N());
      const v = numOf(build());
      return v == null ? { status: 'unsolved', text: build().toString(), values: [], timeMs } : { status: 'ok', text: build().N().toString(), values: [v], timeMs };
    }
    if (c.op === 'diff') {
      const build = () => engine.expr(['D', c.arg, c.varName]).evaluate();
      const timeMs = timeit(build); const r = build();
      return { status: 'ok', text: r.toString(), values: POINTS.map((p) => numAt(engine, r, c.varName, p)), timeMs };
    }
    if (c.op === 'limit') {
      const build = () => engine.expr(['Limit', ['Function', c.arg, c.varName], c.point]);
      const timeMs = timeit(() => build().N());
      const v = numOf(build());
      return v == null ? { status: 'unsolved', text: build().evaluate().toString(), values: [], timeMs } : { status: 'ok', text: build().N().toString(), values: [v], timeMs };
    }
    if (c.op === 'solve') {
      // The public API is the `.solve()` method (the `Solve` operator doesn't
      // auto-evaluate). It returns the *real* roots.
      const build = () => engine.expr(c.arg).solve(c.varName);
      const timeMs = timeit(() => build());
      const roots: any[] = build() || [];
      if (!roots.length) return { status: 'unsolved', text: '[]', values: [], roots: [], timeMs };
      const resid = engine.expr(c.arg);
      const realRoots: number[] = [], resid_mag: number[] = [];
      for (const root of roots) {
        try {
          const rv = root.N(); const im = typeof rv.im === 'number' ? rv.im : 0;