Function apply2

src/compute-engine/boxed-expression/apply.ts:189–245

(
  expr1: Expression,
  expr2: Expression,
  fn: (x1: number, x2: number) => number | Complex,
  bigFn?: (x1: BigDecimal, x2: BigDecimal) => BigDecimal | Complex | number,
  complexFn?: (x1: Complex, x2: number | Complex) => Complex | number
)

    if (
      isNaNResult(result) &&
      complexFn &&
      ops.every((op) => Number.isFinite(op.re))
    ) {
      // The value may be complex for real arguments
      result = complexFn(...ops.map((op) => ce.complex(op.re, 0)));
    }
  }

  if (result === undefined) return undefined;
  if (result instanceof Complex) {
    if (Number.isNaN(result.re) || Number.isNaN(result.im)) return undefined;
    // Chop kernel roundoff dust at the machine-roundoff scale, NOT
    // `ce.tolerance` — whether a component is noise from the complex kernel is
    // a property of the arithmetic, not of the user's comparison tolerance.
    return ce.number(
      ce._numericValue({
        re: chop(result.re, ROUNDOFF_TOLERANCE),
        im: chop(result.im, ROUNDOFF_TOLERANCE),
      })
    );
  }
  if (typeof result === 'number') {
    if (Number.isNaN(result)) return undefined;
    return boxMachineNumber(ce, result);
  }
  if (result.isNaN()) return undefined;
  return ce.number(result);
}

export function apply2(
  expr1: Expression,
  expr2: Expression,
  fn: (x1: number, x2: number) => number | Complex,
  bigFn?: (x1: BigDecimal, x2: BigDecimal) => BigDecimal | Complex | number,
  complexFn?: (x1: Complex, x2: number | Complex) => Complex | number
): Expression | undefined {
  if (!isNumber(expr1) || !isNumber(expr2)) return undefined;

  const ce = expr1.engine;

  let result: number | Complex | BigDecimal | undefined = undefined;
  if (expr1.im !== 0 || expr2.im !== 0) {
    result = complexFn?.(
      ce.complex(expr1.re, expr1.im),
      ce.complex(expr2.re, expr2.im)
    );
  }

  if (result === undefined && bigFn) {
    let bigRe1 = expr1.bignumRe;
    let bigRe2 = expr2.bignumRe;
    if (bigRe1 !== undefined || bigRe2 !== undefined) {
      bigRe1 ??= ce.bignum(expr1.re);
      bigRe2 ??= ce.bignum(expr2.re);
      result = bigFn(bigRe1, bigRe2);
    }
  }
  if (result === undefined) {