Function factorPolynomial

src/compute-engine/boxed-expression/factor.ts:559–619

(
  expr: Expression,
  variable?: string
)

 * IMPORTANT: Does not call .simplify() to avoid infinite recursion.
 */
function extractContent(expr: Expression, variable: string): Expression | null {
  const ce = expr.engine;
  const coeffs = getPolynomialCoefficients(expr, variable);
  if (!coeffs) return null;

  // Extract integer values from all coefficients
  const intCoeffs: number[] = [];
  for (const c of coeffs) {
    const n = asSmallInteger(c);
    if (n === null) return null;
    intCoeffs.push(n);
  }

  // Compute GCD of all non-zero coefficients
  const gcd = (a: number, b: number): number => {
    a = Math.abs(a);
    b = Math.abs(b);
    while (b) {
      [a, b] = [b, a % b];
    }
    return a;
  };

  let content = 0;
  for (const c of intCoeffs) {
    if (c !== 0) content = gcd(content, c);
  }

  if (content <= 1) return null;

  // If the leading coefficient is negative, extract a negative content so
  // the primitive part leads with a positive coefficient:
  // -2x - 4 → -2(x + 2), not 2(-x - 2)
  // (the top slot can be 0 if leading terms canceled during expansion, so
  // scan back to the last non-zero coefficient)
  let i = intCoeffs.length - 1;
  while (i >= 0 && intCoeffs[i] === 0) i -= 1;
  if (i >= 0 && intCoeffs[i] < 0) content = -content;

  // Divide all coefficients by the content to get the primitive part
  const primitiveCoeffs = coeffs.map((c) => {
    const n = asSmallInteger(c)!;
    return ce.number(n / content);
  });

  // Reconstruct the primitive polynomial
  const primitive = fromCoefficients(primitiveCoeffs, variable);

  // Recursively factor the primitive part
  const factoredPrimitive = factorPolynomial(primitive, variable);

  // Build the product `content · primitive` with ce.function rather than
  // `.mul()`. The arithmetic `.mul()` distributes a numeric factor over a
  // bare sum — e.g. `3 · (2x + 3)` collapses back to `6x + 9`, undoing the
  // content extraction for a primitive that doesn't factor further (such as
  // a linear polynomial). Canonical `Multiply` does not distribute, so the
  // factored form is preserved. `|content|` is always ≥ 2 here (we returned
  // null for content ≤ 1 before applying the sign), so the coefficient-±1