Function costFunction

src/compute-engine/cost-function.ts:74–257

(expr: Expression)

  // beat the single `⁴√12` (8).
  //
  // The premium is calibrated so a radical LITERAL costs about what the
  // equivalent expression costs: `Sqrt(y)` prices at 6, and `√3` now prices
  // at 6 too.
  const radical = (n as { radical?: number }).radical;
  if (radical !== undefined && radical > 1)
    return numericCostFunction(n.re) + 3 + numericCostFunction(radical);

  return numericCostFunction(n.re);
}

/**
 * The default cost function, used to determine if a new expression is simpler
 * than the old one.
 *
 * To change the cost function used by the engine, set the
 * `ce.costFunction` property of the engine or pass a custom cost function
 * to the `simplify` function.
 *
 */
/**
 * Price a `Power(base, exp)`. Extracted so the alias heads that canonicalize
 * to a Power (`Square`, `Exp`) price identically to the canonical form — the
 * cost function must not depend on which representation it is handed.
 *
 * The base is mostly ignored so that `2q^2` beats `2qq`, except when the base
 * is a `Negate` (so `(-x)^n` is not cheaper than `-x^n`) or a `Multiply` (so
 * `(ab)^n` is not artificially cheaper than the distributed `a^n b^n`).
 */
function powerCost(base: Expression, exp: Expression): number {
  const expCost = costFunction(exp);
  // Count a negated base too. This used to be a flat `expCost + 4`, which
  // discarded everything under the sign — the same defect as the removed
  // `Negate(Power(...))` shortcut, just on the other side. Once `Power` began
  // counting its base it became load-bearing: `(-sin x)^2` scored 5 against
  // `sin(x)^2` at 12, so the gate REJECTED the rewrite and left the negation
  // in place. A symbol base hid it (`(-x)^2 -> x^2` still worked).
  if (base.operator === 'Negate') return expCost + costFunction(base);
  if (isFunction(base, 'Multiply')) {
    // A negative coefficient under a fractional exponent must factor its sign
    // out for a correct real result, so make the unfactored form expensive.
    const hasNegativeCoef = base.ops.some(
      (f) => isNumber(f) && f.isNegative === true
    );
    if (hasNegativeCoef && exp.isRational === true && !exp.isInteger)
      return expCost + costFunction(base) + 15;
    return expCost + costFunction(base);
  }
  // Count the base. It used to be discarded for every base that was not a
  // `Negate` or `Multiply`, which priced `(a+b+c+d)^20` at 2 — the same as
  // `x^20`, and barely above `x^2` — even though it expands to 1,771 terms.
  // The stated goal ("`2q^2` should beat `2qq`") survives: a power still costs
  // far less than the repeated multiplication it replaces.
  return expCost + costFunction(base);
}

export function costFunction(expr: Expression): number {
  // Special-case: Encourage the "exp/log separation" rewrite used by
  // `simplifyLog()` for base-10 logs: