Function genTrinomialPartsX

src/compute-engine/rubi/rubi-utils.ts:1976–2028

Rubi GeneralizedTrinomialParts → {a,b,c,n,q}: * u ≡ a·x^q + b·x^n + c·x^(2n−q)

(u: Expression, x: string)

  const f = rec(u);
  if (f === null || vAcc === null) return null;
  return { f, v: vAcc, n: nAcc! };
}

/** Rubi BinomialParts product combination: (a+b·x^m)·(c+d·x^n) */
function combineBinProduct(p: BinParts, q: BinParts): BinParts | null {
  const aZ = p.a.isSame(0) || zeroQ(p.a);
  const cZ = q.a.isSame(0) || zeroQ(q.a);
  const { b, n: m } = p;
  const { b: d, n } = q;
  if (aZ && cZ)
    return {
      a: p.a.engine.Zero,
      b: b.mul(d).evaluate(),
      n: m.add(n).evaluate(),
    };
  if (aZ && zeroQ(m.add(n)))
    return { a: b.mul(d).evaluate(), b: b.mul(q.a).evaluate(), n: m };
  if (cZ && zeroQ(m.add(n)))
    return { a: b.mul(d).evaluate(), b: p.a.mul(d).evaluate(), n };
  if (zeroQ(m.sub(n)) && zeroQ(p.a.mul(d).add(b.mul(q.a))))
    return {
      a: p.a.mul(q.a).evaluate(),
      b: b.mul(d).evaluate(),
      n: m.mul(2).evaluate(),
    };
  return null;
}

/** Rubi TrinomialParts[u,x] → {a,b,c,n} with u ≡ a + b·x^n + c·x^(2n) */
function trinomialPartsX(u: Expression, x: string): TriParts | null {
  const ce = u.engine;
  if (!u.has(x)) return null;

  const coeffs0 = polyCoeffsX(u, x);
  if (coeffs0 !== null) {
    const coeffs = trimZeros(coeffs0);
    const L = coeffs.length;
    if (L < 3 || L % 2 === 0) return null;
    const mid = (L - 1) / 2;
    if (coeffs[mid].isSame(0) || zeroQ(coeffs[mid])) return null;
    for (let i = 1; i < L - 1; i++)
      if (i !== mid && !(coeffs[i].isSame(0) || zeroQ(coeffs[i]))) return null;
    return {
      a: coeffs[0],
      b: coeffs[mid],
      c: coeffs[L - 1],
      n: ce.number(mid),
    };
  }

  const ops = u.ops;
  if (!ops) return null;
  const scaleTri = (s: Expression, t: TriParts): TriParts => ({
    a: s.mul(t.a).evaluate(),
    b: s.mul(t.b).evaluate(),
    c: s.mul(t.c).evaluate(),