Function runCase

benchmarks/runners/run_ce_rubi.mjs:171–224

(ce, kase)

// Run one case on one engine and return its result object (no id/tool — those
// are added by emit). Precision is reset per call so cases stay independent.
function runCase(ce, kase) {
  const input = kase.inputs.ce;
  const fn = buildOp(ce, kase); // also (re)sets precision for this case
  if (!fn) return { status: 'error', error: `unknown op ${input.op}` };
  try {
    if (input.op === 'N') {
      const timing = timeit(fn);
      const r = fn();
      return { status: 'ok', text: r.toString(), valueText: r.toString(), values: [], ...timing };
    } else if (input.op === 'simplify') {
      const timing = timeit(fn);
      const original = ce.expr(input.mathjson);
      const result = fn();
      const pts = kase.verify.points.map(parseFloat);
      const values = pts.map((p) => num(result.subs({ [kase.verify.var]: ce.number(p) })));
      return { status: 'ok', text: result.toString(), inputText: original.toString(), values, ...timing };
    } else if (input.op === 'diff') {
      const timing = timeit(fn);
      const result = fn();
      const pts = kase.verify.points.map(parseFloat);
      const values = pts.map((p) => num(result.subs({ [input.var]: ce.number(p) })));
      return { status: 'ok', text: result.toString(), values, ...timing };
    } else if (input.op === 'integrate') {
      const timing = timeit(fn);
      const result = fn();
      if (isUnevaluated(result))
        return { status: 'unevaluated', text: result.toString(), values: [], ...timing };
      const a = parseFloat(kase.verify.a);
      const b = parseFloat(kase.verify.b);
      const fb = num(result.subs({ [input.var]: ce.number(b) }));
      const fa = num(result.subs({ [input.var]: ce.number(a) }));
      return { status: 'ok', text: result.toString(), values: [fb - fa], ...timing };
    } else if (input.op === 'evaluate') {
      const timing = timeit(fn);
      const result = fn();
      if (isUnevaluated(result))
        return { status: 'unevaluated', text: result.toString(), values: [], ...timing };
      return { status: 'ok', text: result.toString(), values: [num(result)], ...timing };
    } else if (input.op === 'solve') {
      const timing = timeit(fn);
      const roots = fn();
      const values = realRootValues(roots);
      return {
        status: values.length ? 'ok' : 'unevaluated',
        text: (roots ?? []).map((r) => r.toString()).join(', '),
        values,
        ...timing,
      };
    }
    return { status: 'error', error: `unknown op ${input.op}` };
  } catch (e) {
    return { status: 'error', error: String(e && e.message ? e.message : e) };
  }
}

// Warm-up pass: run every case once on every engine BEFORE any timing, so the
// V8 JIT has tiered up the shared code paths uniformly and no engine measured