Function assertNumericallyEqual

test/compute-engine/trig-rewrite.test.ts:13–66

* Check that `original` and `transformed` are numerically equal at a battery of * sample points. `vars` are the free variables to substitute; each is assigned * a value from `points`.

(
  original: BoxedExpression,
  transformed: BoxedExpression,
  vars: string[],
  { complex = false, tol = 1e-9 }: { complex?: boolean; tol?: number } = {}
)

 * a value from `points`.
 */
function assertNumericallyEqual(
  original: BoxedExpression,
  transformed: BoxedExpression,
  vars: string[],
  { complex = false, tol = 1e-9 }: { complex?: boolean; tol?: number } = {}
) {
  // A handful of deterministic "random-ish" sample points, chosen to avoid
  // poles of tan/sec/csc/cot.
  const reals = [0.3, 0.7, 1.1, -0.5, 2.2, -1.7];
  const points: { re: number; im: number }[] = reals.map((re) => ({
    re,
    im: 0,
  }));
  if (complex)
    points.push(
      { re: 0.4, im: 0.6 },
      { re: -0.8, im: 0.3 },
      { re: 1.2, im: -0.7 }
    );

  for (let i = 0; i < points.length; i++) {
    // Assign each variable a distinct point (rotate through the list).
    const sub: Record<string, BoxedExpression> = {};
    for (let v = 0; v < vars.length; v++) {
      const p = points[(i + v) % points.length];
      sub[vars[v]] =
        p.im === 0 ? ce.number(p.re) : ce.number(ce.complex(p.re, p.im));
    }

    const a = original.subs(sub).N();
    const b = transformed.subs(sub).N();

    const ar = a.re ?? NaN;
    const ai = a.im ?? 0;
    const br = b.re ?? NaN;
    const bi = b.im ?? 0;

    const ok =
      Number.isFinite(ar) &&
      Number.isFinite(br) &&
      Math.abs(ar - br) <= tol &&
      Math.abs(ai - bi) <= tol;

    if (!ok) {
      throw new Error(
        `Mismatch at ${JSON.stringify(sub)}: ` +
          `original=${a.toString()} (${ar}+${ai}i) vs ` +
          `transformed=${b.toString()} (${br}+${bi}i)\n` +
          `  original: ${original.toString()}\n` +
          `  transformed: ${transformed.toString()}`
      );
    }
  }
}

function apply(op: string, latex: string): BoxedExpression {
  return ce.function(op, [ce.parse(latex)]).evaluate();