Function combineTriSum

src/compute-engine/rubi/rubi-utils.ts:1859–1913

(
  u: { kind: 'bin'; p: BinParts } | { kind: 'tri'; p: TriParts },
  v: { kind: 'bin'; p: BinParts } | { kind: 'tri'; p: TriParts }
)

    const out = terms.map((t) => t.div(xk));
    return out.length === 1 ? out[0] : ce.function('Add', out);
  };
  return divTerms(num).div(divTerms(den));
}

/** R26B: rewrite a (possibly deeply nested) rational function of `x` into a
 * single FLAT `N/D` whose numerator and denominator are fully-expanded
 * polynomials in `x` sharing no common `x^k` monomial factor. Used by the
 * hyperbolic function-of-exponential fallback: the `t = e^x` substitution
 * lands `∫1/(a+b·sinh x)` at the nested shape `1/(x·(a + b/2·(x − 1/x)))`,
 * which no bundled rule matches, whereas the flat equivalent `2/(b·x²+2a·x−b)`
 * closes via the 1.2.1.1 quadratic-denominator rules.
 *
 * `asNumDen` cross-multiplies the nested Divide/Subtract/Power structure into a
 * single fraction; `expand` turns each side into a polynomial in x; the common
 * `x^k` factor (introduced by the outer `1/x` of the substitution) is cancelled
 * the way `Cancel` would. Returns null when the result is NOT a rational
 * function of x (some expanded side is not a polynomial in x, or the
 * denominator vanishes), so the caller can fall back to the un-normalized form.
 */
export function rationalNormalFormX(
  e: Expression,
  x: string,
  clearNegatives = false
): Expression | null {
  const ce = e.engine;
  const divByXk = (u: Expression, kk: number): Expression => {
    if (kk <= 0) return u;
    const xk = ce.function('Power', [ce.symbol(x), ce.number(kk)]);
    const terms = u.operator === 'Add' && u.ops ? u.ops : [u];
    const out = terms.map((t) => t.div(xk));
    return expand(out.length === 1 ? out[0] : ce.function('Add', out));
  };
  const { num, den } = asNumDen(e);
  let n = expand(num);
  let d = expand(den);
  if (d.isSame(0)) return null;
  // R30: a hyperbolic power ≥ 2 substitutes to `(½(x∓1/x))^k` folds whose
  // expansion carries genuine NEGATIVE x-powers (`x^-1`, `x^-2`, …); the outer
  // `1/x` of the substitution clears only ONE of them, so the residual is a
  // Laurent (not ordinary) polynomial and `polyCoeffsX` below rejects it,
  // leaving these rows unsolved. Multiply num & den through by `x^(-negShift)`
  // (the shared factor preserves the fraction's value) so both become genuine
  // polynomials in x; the biquadratic/trinomial denominator that results is
  // exactly what the bundled 1.2.x rules close. Gated (default off) so R26B and
  // ch2 stay byte-identical unless the caller opts in.
  if (clearNegatives) {
    const negShift = Math.min(0, minXPowerSigned(n, x), minXPowerSigned(d, x));
    if (negShift < 0) {
      const xs = ce.function('Power', [ce.symbol(x), ce.number(-negShift)]);
      n = expand(n.mul(xs));
      d = expand(d.mul(xs));
    }
  }
  // Cancel the common `x^k` monomial factor shared by numerator and denominator
  // (introduced by the substitution's outer `1/x`).
  const k = Math.min(minXPower(n, x), minXPower(d, x));
  n = divByXk(n, k);
  d = divByXk(d, k);