Function binomialPartsX

src/compute-engine/rubi/rubi-utils.ts:1624–1712

Rubi BinomialParts[u,x] → {a,b,n} with u ≡ a + b·x^n (n ≠ 0, b ≠ 0)

(u: Expression, x: string)

    case 'Negate': {
      const m = monoPartsX(ops[0], x);
      return m === null ? null : { coef: m.coef.neg(), exp: m.exp };
    }
    case 'Multiply': {
      let coef = ce.One;
      let exp: Expression = ce.Zero;
      for (const f of ops) {
        if (!f.has(x)) {
          coef = coef.mul(f);
          continue;
        }
        const m = monoPartsX(f, x);
        if (m === null) return null;
        coef = coef.mul(m.coef);
        exp = exp.add(m.exp);
      }
      return { coef: coef.evaluate(), exp: exp.evaluate() };
    }
    case 'Divide': {
      const mn = monoPartsX(ops[0], x);
      const md = monoPartsX(ops[1], x);
      if (mn === null || md === null) return null;
      return {
        coef: mn.coef.div(md.coef).evaluate(),
        exp: mn.exp.sub(md.exp).evaluate(),
      };
    }
  }
  return null;
}

/** flatten a sum into its terms (Add/Subtract/Negate normalized) */
function sumTermsX(u: Expression): Expression[] {
  if (u.operator === 'Add' && u.ops) return u.ops.flatMap(sumTermsX);
  if (u.operator === 'Subtract' && u.ops)
    return [...sumTermsX(u.ops[0]), ...sumTermsX(u.ops[1]).map((t) => t.neg())];
  if (u.operator === 'Negate' && u.ops)
    return sumTermsX(u.ops[0]).map((t) => t.neg());
  return [u];
}

/** group the structural sum terms of u into (exponent → summed coefficient)
 * classes; null when some term is not a structural monomial in x */
function monoClassesX(
  u: Expression,
  x: string
): { exp: Expression; coef: Expression }[] | null {
  const classes: { exp: Expression; coef: Expression }[] = [];
  for (const t of sumTermsX(u)) {
    const m = monoPartsX(t, x);
    if (m === null) return null;
    const cls = classes.find(
      (c) => c.exp.isSame(m.exp) || zeroQ(c.exp.sub(m.exp))
    );
    if (cls) cls.coef = cls.coef.add(m.coef).evaluate();
    else classes.push({ exp: m.exp, coef: m.coef });
  }
  return classes.filter((c) => !c.coef.isSame(0));
}