Function collectFactorsRaw

src/compute-engine/boxed-expression/factor.ts:804–839

Recursively collect raw factors without merging

(
  expr: Expression,
  variable: string,
  result: FactorInfo[]
)

  if (isFunction(expr, 'Negate')) return factor(expr.op1).neg();

  if (isFunction(expr, 'Add')) {
    const ce = expr.engine;
    let common: NumericValue | undefined = undefined;

    // Calculate the GCD of all coefficients
    const terms: { coeff: NumericValue; term: Expression }[] = [];
    for (const op of expr.ops) {
      const [coeff, term] = op.toNumericValue();
      // GCD-based content extraction is only defined for real (rational)
      // coefficients. A complex coefficient — e.g. the `i` in `1 + i` — has no
      // meaningful gcd: `gcd` returns NaN, which would poison `common` and make
      // factor() return NaN (destroying a Gaussian integer at boxing time).
      // Leave such sums unfactored.
      if (coeff.im !== 0) return expr;
      common = common ? common.gcd(coeff) : coeff;
      if (!coeff.isZero) terms.push({ coeff, term });
    }

    // Every coefficient was zero (possible with non-canonical input,
    // e.g. synthetic `0·u + 0·v` sums): the sum is zero, and add() below
    // cannot be called with no terms.
    if (terms.length === 0) return ce.Zero;

    if (!common || common.isOne) return expr;

    const newTerms = terms.map(({ coeff, term }) =>
      mul(term, ce.expr(coeff.div(common)))
    );

    // Build the factored product WITHOUT the expanding `mul()` helper:
    // `mul(k, sum)` distributes `k` back over the sum (expandProduct),
    // re-expanding `2(x+2)` into `2x+4` and undoing the factoring. A
    // canonical Multiply node preserves the factored form.
    return ce.function('Multiply', [ce.number(common), add(...newTerms)]);
  }

  return Product.from(together(expr)).asExpression();
}