Function evaluateBinomial

src/compute-engine/library/combinatorics.ts:105–153

* Shared evaluate logic for `Binomial` and `Choose` — the two names must * agree everywhere both are defined, so both handlers delegate here. * * - Exact integers (any sign of n): exact bigint result (see * `binomialBigint`), regardless of `numericApproximation`. * - Exact non-integers (ratio

(
  nExpr: Expression,
  kExpr: Expression,
  numericApproximation: boolean | undefined,
  ce: Expression['engine']
)

    if ((++steps & 0xffff) === 0) checkDeadline(deadline);
    result = (result * (n - kk + i)) / i;
  }
  return result;
}

/**
 * Shared evaluate logic for `Binomial` and `Choose` — the two names must
 * agree everywhere both are defined, so both handlers delegate here.
 *
 * - Exact integers (any sign of n): exact bigint result (see
 *   `binomialBigint`), regardless of `numericApproximation`.
 * - Exact non-integers (rationals, radicals, symbolic constants like π):
 *   no closed form, so stay symbolic under plain `evaluate()`; under `.N()`
 *   numericize via the Gamma form Γ(n+1)/(Γ(k+1)·Γ(n−k+1)).
 * - Inexact (float) operands numericize under both `evaluate()` and `.N()`,
 *   per the exactness contract (an inexact argument always numericizes).
 * - Complex or non-numeric (symbolic) operands: stay symbolic (no closed
 *   form implemented for complex args; symbolic args can't be evaluated).
 */
/**
 * Result type shared by `Binomial` and `Choose` (they share
 * `evaluateBinomial` and must agree). Integer n, k → an integer (also for
 * negative n, via the falling factorial). Real arguments go through the Γ
 * ratio: finite real unless the numerator Γ(n+1) sits on a pole (negative
 * integer n with a non-integer k) — there, and for non-finite or non-real
 * arguments, nothing narrower than `number` is sound (`Binomial(∞, 2)` is
 * NaN).
 */
function binomialType(
  n: Expression | undefined,
  k: Expression | undefined
): Type {
  if (!n || !k || n.isNaN || k.isNaN) return 'number';
  if (n.isFinite === false || k.isFinite === false) return 'number';
  if (n.isInteger === true && k.isInteger === true) return 'finite_integer';
  if (n.isReal === true && k.isReal === true) {
    if (n.isInteger === true && n.isNegative === true) return 'number';
    return 'finite_real';
  }
  return 'number';
}

function evaluateBinomial(
  nExpr: Expression,
  kExpr: Expression,
  numericApproximation: boolean | undefined,
  ce: Expression['engine']
): Expression | undefined {
  // Exact integers: exact bigint arithmetic (handles negative n).
  if (
    isNumber(nExpr) &&
    isNumber(kExpr) &&
    nExpr.im === 0 &&