@danielsimonjr/mathts-functions 0.59.0 → 0.60.0

package/dist/cas/rational-integrate.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Layer 1 rational-function symbolic integration — Task 1: parse a
+ * single-variable rational-function expression into exact integer
+ * numerator/denominator polynomials, split off the polynomial part via
+ * exact-ℚ long division, and integrate a polynomial termwise (power rule).
+ *
+ * Reuses the univariate expression parser (`polyFromExpression`, from the
+ * Gröbner-basis module) for parsing and the bigint dense-polynomial
+ * convention (`IntPoly`, index = degree) from the #7 factorization engine
+ * for the integer representation.
+ *
+ * See docs/superpowers/plans/2026-07-20-risch-layer1-rational-integration.md
+ * (Task 1). Later tasks build denominator factorization, exact-ℚ partial
+ * fractions, and per-factor closed-form integration on top of this module.
+ */
+import { type IntPoly } from '../typed/factorization/integer-poly.js';
+/** Exact rational number, always normalized to lowest terms with a positive denominator. */
+export interface Rat {
+    num: bigint;
+    den: bigint;
+}
+/** A rational function `numer(x)/denom(x)` with integer dense (`IntPoly`) coefficients. */
+export interface RatFunc {
+    numer: IntPoly;
+    denom: IntPoly;
+}
+export declare function ratAdd(a: Rat, b: Rat): Rat;
+export declare function ratSub(a: Rat, b: Rat): Rat;
+export declare function ratMul(a: Rat, b: Rat): Rat;
+export declare function ratDiv(a: Rat, b: Rat): Rat;
+export declare function ratFromBigint(n: bigint): Rat;
+/**
+ * Parses a single-variable expression `numerExpr/denomExpr` (or a bare
+ * polynomial, denominator `[1n]`) into integer numerator/denominator dense
+ * polynomials. Rational coefficients are cleared by the LCM of their
+ * denominators (numerator and denominator are each cleared independently,
+ * then cross-scaled by the other's factor so the represented ratio
+ * `numer(x)/denom(x)` is unchanged).
+ *
+ * Returns `null` when `expr` is not a rational function of `v`: it contains
+ * a transcendental call (`sin`/`exp`/... — any identifier other than `v`),
+ * more than one variable, a zero denominator, or coefficients that cannot be
+ * cleared to integers.
+ */
+export declare function parseRationalFunction(expr: string, v: string): RatFunc | null;
+/**
+ * Exact-ℚ polynomial long division of `rf.numer` by `rf.denom`:
+ * `numer = quotient·denom + remainder`, `deg(remainder) < deg(denom)`.
+ * Division is performed over ℚ (so a non-monic denominator is handled
+ * correctly); the result is converted back to `bigint` coefficients, which
+ * requires every intermediate `Rat` to reduce to an integer denominator —
+ * true whenever the division is itself exact-integer, as it is for a
+ * genuine rational-function reduction. Throws if it is not (a caller that
+ * expects a non-integer quotient/remainder is out of this module's scope).
+ */
+export declare function polynomialPart(rf: RatFunc): {
+    quotient: IntPoly;
+    remainder: IntPoly;
+};
+/**
+ * Termwise power rule: the coefficient `c` at degree `n` in `p` integrates
+ * to `c/(n+1) · v^(n+1)`. Renders a readable (not contractual beyond
+ * containing the expected power) string, e.g. `x^2/2`, `2*x`.
+ */
+export declare function integratePolynomial(p: IntPoly, v: string): string;
+/**
+ * An irreducible factor of a rational function's denominator, classified by
+ * degree for Layer 1 closed-form integration: degree 1 ("linear") integrates
+ * to a `log`, degree 2 ("quadratic") to a `log` + `atan` pair. Degree ≥ 3
+ * irreducible factors are outside Layer 1's scope (see `factorDenominator`).
+ */
+export interface DenFactor {
+    poly: IntPoly;
+    mult: number;
+    kind: 'linear' | 'quadratic';
+}
+/**
+ * Factors `denom` completely over ℤ/ℚ via the #7 factorization engine
+ * (`factorUnivariateZ`) and classifies each irreducible factor by degree.
+ *
+ * A degree-1 factor is `'linear'`; a degree-2 factor is `'quadratic'` — and,
+ * having survived complete factorization over ℚ, necessarily irreducible
+ * (any rational root would already have split it into two linear factors,
+ * i.e. it has negative discriminant).
+ *
+ * Returns `null` when any irreducible factor has degree ≥ 3: Layer 1 only
+ * handles linear + irreducible-quadratic denominators, so a higher-degree
+ * irreducible factor is out of scope and the caller falls back to the
+ * `integral(...)` marker (Layer 2/Rothstein–Trager territory).
+ */
+export declare function factorDenominator(denom: IntPoly): DenFactor[] | null;
+/**
+ * A single partial-fraction term `numer(x) / factor(x)^power`. `numer` is a
+ * `Rat[]` of fixed length `deg(factor)` (index = degree, ascending — the same
+ * convention as `IntPoly`): length 1 (a constant) over a linear factor,
+ * length 2 (`[E, D]` meaning `D*x + E`) over a quadratic factor.
+ */
+export interface PFTerm {
+    factor: IntPoly;
+    power: number;
+    numer: Rat[];
+}
+/**
+ * Exact-ℚ partial-fraction decomposition of `remainder(x) / ∏ factorᵢ(x)^multᵢ`
+ * (`deg(remainder) < deg(∏ factorᵢ^multᵢ)`, as produced by `polynomialPart`)
+ * into the standard form: for each irreducible factor `qᵢ` with multiplicity
+ * `mᵢ`, terms `A_{i,k}(x) / qᵢ(x)^k` for `k = 1..mᵢ`, `deg A_{i,k} < deg qᵢ`.
+ *
+ * Solved by clearing denominators: multiplying the ansatz by the full
+ * denominator `D = ∏ factorⱼ^multⱼ` turns each unknown numerator coefficient
+ * into a linear unknown whose column is the polynomial
+ * `x^j · qᵢ(x)^{mᵢ−k} · ∏_{j≠i} factorⱼ(x)^multⱼ` (a plain integer polynomial
+ * product — no division is ever needed, since `mᵢ−k ≥ 0`). Equating
+ * coefficients of `remainder(x)` on both sides gives a square (`deg D` ×
+ * `deg D`) rational linear system, solved exactly via `solveLinearSystemRat`.
+ */
+export declare function partialFractions(remainder: IntPoly, factors: DenFactor[]): PFTerm[];
+/**
+ * Integrates a single partial-fraction term in closed form. Dispatches on the
+ * degree of `term.factor`: degree 1 → `log` (+ rational part for a repeated
+ * factor); degree 2 (irreducible, disc < 0) → `log`/rational part + `atan`.
+ * The produced string is evaluable by the expression engine (`log`, `atan`,
+ * `sqrt`, `abs`, `^`, `*`); its exact form is not contractual — correctness is
+ * verified by differentiation. Throws on any other factor degree (unreachable
+ * for a `factorDenominator`-classified factor).
+ */
+export declare function integratePFTerm(term: PFTerm, v: string): string;
+/**
+ * Full Layer-1 rational-function integration pipeline. Parses `expr` into an
+ * exact integer rational function, splits off and integrates the polynomial
+ * part, factors the denominator into linear + irreducible-quadratic factors,
+ * decomposes into exact-ℚ partial fractions, and integrates each term in
+ * closed form (rational part + `log` + `atan`).
+ *
+ * Returns `null` when `expr` is not a rational function of `v`
+ * (`parseRationalFunction` declines), when the denominator has a degree-≥3
+ * irreducible factor (`factorDenominator` declines — Layer 2 territory), or
+ * when any internal step throws (e.g. a non-integer polynomial-part division),
+ * so callers get a clean decline rather than an exception.
+ */
+export declare function integrateRationalFunction(expr: string, v: string): string | null;
+//# sourceMappingURL=rational-integrate.d.ts.map

package/dist/cas/rational-integrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rational-integrate.d.ts","sourceRoot":"","sources":["../../src/cas/rational-integrate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAKL,KAAK,OAAO,EACb,MAAM,wCAAwC,CAAC;AAGhD,4FAA4F;AAC5F,MAAM,WAAW,GAAG;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb;AAED,2FAA2F;AAC3F,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;CAChB;AAoBD,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,GAAG,CAE1C;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,GAAG,CAE1C;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,GAAG,CAE1C;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,GAAG,CAK1C;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAE5C;AAsDD;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CA4C7E;AAWD;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,OAAO,GAAG;IAAE,QAAQ,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CAoCrF;AAWD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAiBjE;AAED;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,QAAQ,GAAG,WAAW,CAAC;CAC9B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,EAAE,GAAG,IAAI,CA0BpE;AAED;;;;;GAKG;AACH,MAAM,WAAW,MAAM;IACrB,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,GAAG,EAAE,CAAC;CACd;AA0DD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,GAAG,MAAM,EAAE,CA4EnF;AAkLD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAU/D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA+ChF"}

package/dist/cas-integration.d.ts

@@ -4,12 +4,17 @@
  * integrand is outside the supported subset, returns `integral(expr, variable)`.
  *
  * The direct recursion is tried first; on failure, partial-fraction integration
- * (for rational integrands) and tabular integration by parts (for
- * polynomial·{exp,sin,cos}) are attempted before giving up with the marker.
+ * (for distinct-rational-root integrands), tabular integration by parts (for
+ * polynomial·{exp,sin,cos}), and full rational-function integration (Risch
+ * Layer 1) are attempted before giving up with the marker. Rational functions
+ * with irreducible-quadratic and repeated factors are now integrated (rational
+ * part + `log` + `arctan`); degree-≥3 irreducible denominators and transcendental
+ * Risch remain out of scope (marker).
  *
  * @example symbolicIntegral('x^3')          // 'x^4 / 4'
  * @example symbolicIntegral('cos(3*x + 1)') // 'sin(3 * x + 1) / 3'
  * @example symbolicIntegral('1/(x^2 - 1)')  // partial fractions → sum of logs
+ * @example symbolicIntegral('1/(x^2 + 1)')  // Risch Layer 1 → 'atan(...)'
  * @example symbolicIntegral('x * sin(x)')   // by parts → 'sin(x) - x*cos(x)'
  */
 export declare function symbolicIntegral(expr: string, variable?: string): string;

package/dist/cas-integration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cas-integration.d.ts","sourceRoot":"","sources":["../src/cas-integration.ts"],"names":[],"mappings":"AAoWA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,SAAM,GAAG,MAAM,CAWrE"}
+{"version":3,"file":"cas-integration.d.ts","sourceRoot":"","sources":["../src/cas-integration.ts"],"names":[],"mappings":"AA2WA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,SAAM,GAAG,MAAM,CAYrE"}

package/dist/index.js

@@ -50609,6 +50609,468 @@ function lsqBounded(A, b, lower, upper, opts = {}) {
   return { x, residual: residualNorm(A, x, b) };
 }
 
+// src/cas/rational-integrate.ts
+function ratNormalize(num2, den) {
+  if (den === 0n) {
+    throw new Error("Rat: zero denominator");
+  }
+  let n = num2;
+  let d = den;
+  if (d < 0n) {
+    n = -n;
+    d = -d;
+  }
+  if (n === 0n) {
+    return { num: 0n, den: 1n };
+  }
+  const g = bigintGcd(n, d);
+  return { num: n / g, den: d / g };
+}
+function ratSub(a, b) {
+  return ratNormalize(a.num * b.den - b.num * a.den, a.den * b.den);
+}
+function ratMul(a, b) {
+  return ratNormalize(a.num * b.num, a.den * b.den);
+}
+function ratDiv(a, b) {
+  if (b.num === 0n) {
+    throw new Error("Rat: division by zero");
+  }
+  return ratNormalize(a.num * b.den, a.den * b.num);
+}
+function ratFromBigint(n) {
+  return { num: n, den: 1n };
+}
+var RAT_ZERO = { num: 0n, den: 1n };
+function splitTopLevelDivision(expr) {
+  let depth = 0;
+  for (let i = 0; i < expr.length; i += 1) {
+    const c = expr[i];
+    if (c === "(") {
+      depth += 1;
+    } else if (c === ")") {
+      depth -= 1;
+    } else if (c === "/" && depth === 0) {
+      return { numerStr: expr.slice(0, i), denomStr: expr.slice(i + 1) };
+    }
+  }
+  return { numerStr: expr, denomStr: "1" };
+}
+function denseFromPoly(p) {
+  let maxPow = 0;
+  for (const t of p) {
+    maxPow = Math.max(maxPow, t.powers[0] ?? 0);
+  }
+  const dense = new Array(maxPow + 1).fill(0);
+  for (const t of p) {
+    dense[t.powers[0]] += t.coeff;
+  }
+  return dense;
+}
+var INT_EPS = 1e-7;
+function isCloseToInteger(x) {
+  return Math.abs(x - Math.round(x)) < INT_EPS;
+}
+function commonDenominator(coeffs) {
+  const LIMIT = 1e5;
+  for (let k = 1; k <= LIMIT; k += 1) {
+    if (coeffs.every((c) => isCloseToInteger(c * k))) {
+      return k;
+    }
+  }
+  return null;
+}
+function parseRationalFunction(expr, v) {
+  const { numerStr, denomStr } = splitTopLevelDivision(expr);
+  let numerPoly;
+  let denomPoly;
+  try {
+    numerPoly = polyFromExpression(numerStr, [v]);
+    denomPoly = polyFromExpression(denomStr, [v]);
+  } catch {
+    return null;
+  }
+  const numerDense = denseFromPoly(numerPoly);
+  const denomDense = denseFromPoly(denomPoly);
+  if (denomDense.every((c) => c === 0)) {
+    return null;
+  }
+  const kNumer = commonDenominator(numerDense);
+  const kDenom = commonDenominator(denomDense);
+  if (kNumer === null || kDenom === null) {
+    return null;
+  }
+  const scale4 = kNumer * kDenom;
+  const toIntPoly = (dense) => {
+    const out = new Array(dense.length);
+    for (let i = 0; i < dense.length; i += 1) {
+      const scaled = dense[i] * scale4;
+      if (!isCloseToInteger(scaled)) {
+        return null;
+      }
+      out[i] = BigInt(Math.round(scaled));
+    }
+    return trim(out);
+  };
+  const numer = toIntPoly(numerDense);
+  const denom = toIntPoly(denomDense);
+  if (numer === null || denom === null || denom.length === 0) {
+    return null;
+  }
+  return { numer, denom };
+}
+function trimRat(p) {
+  let n = p.length;
+  while (n > 0 && p[n - 1].num === 0n) {
+    n -= 1;
+  }
+  return p.slice(0, n);
+}
+function polynomialPart(rf) {
+  const denom = trim(rf.denom);
+  if (denom.length === 0) {
+    throw new Error("polynomialPart: zero denominator");
+  }
+  const db = denom.length - 1;
+  const lb = ratFromBigint(denom[db]);
+  const denomRat = denom.map(ratFromBigint);
+  let rem = trimRat(trim(rf.numer).map(ratFromBigint));
+  const dq = rem.length - 1 - db;
+  const quotient = new Array(Math.max(dq + 1, 0)).fill(RAT_ZERO);
+  while (rem.length > 0 && rem.length - 1 >= db) {
+    const dr = rem.length - 1;
+    const shift = dr - db;
+    const coeff = ratDiv(rem[dr], lb);
+    quotient[shift] = coeff;
+    const next = rem.slice();
+    for (let i = 0; i <= db; i += 1) {
+      next[shift + i] = ratSub(next[shift + i], ratMul(coeff, denomRat[i]));
+    }
+    rem = trimRat(next);
+  }
+  const toExactIntPoly = (rs) => trim(
+    rs.map((r) => {
+      if (r.den !== 1n) {
+        throw new Error("polynomialPart: division introduced a non-integer coefficient");
+      }
+      return r.num;
+    })
+  );
+  return { quotient: toExactIntPoly(quotient), remainder: toExactIntPoly(rem) };
+}
+function formatRatTerm(r, varPart) {
+  const sign3 = r.num < 0n ? "-" : "";
+  const absNum = r.num < 0n ? -r.num : r.num;
+  const coeffPart = absNum === 1n ? "" : `${absNum}*`;
+  const denPart = r.den === 1n ? "" : `/${r.den}`;
+  return `${sign3}${coeffPart}${varPart}${denPart}`;
+}
+function integratePolynomial(p, v) {
+  const trimmed = trim(p);
+  const terms = [];
+  for (let i = 0; i < trimmed.length; i += 1) {
+    const c = trimmed[i];
+    if (c === 0n) {
+      continue;
+    }
+    const n = i + 1;
+    const coeff = ratNormalize(c, BigInt(n));
+    const varPart = n === 1 ? v : `${v}^${n}`;
+    terms.push(formatRatTerm(coeff, varPart));
+  }
+  if (terms.length === 0) {
+    return "0";
+  }
+  return terms.join(" + ").replace(/\+ -/g, "- ");
+}
+function factorDenominator(denom) {
+  const { factors } = factorUnivariateZ(trim(denom));
+  const out = [];
+  for (const { poly, mult } of factors) {
+    const deg = trim(poly).length - 1;
+    if (deg === 1) {
+      out.push({ poly, mult, kind: "linear" });
+    } else if (deg === 2) {
+      const q = trim(poly);
+      const disc = q[1] * q[1] - 4n * q[2] * q[0];
+      if (disc >= 0n) {
+        return null;
+      }
+      out.push({ poly, mult, kind: "quadratic" });
+    } else {
+      return null;
+    }
+  }
+  return out;
+}
+function shiftedColumn(poly, shift, size2) {
+  const col = new Array(size2).fill(RAT_ZERO);
+  for (let i = 0; i < poly.length; i += 1) {
+    const row2 = i + shift;
+    if (row2 < size2) {
+      col[row2] = ratFromBigint(poly[i]);
+    }
+  }
+  return col;
+}
+function solveLinearSystemRat(matrix2, rhs) {
+  const n = rhs.length;
+  const rows = matrix2.map((row2, r) => [...row2, rhs[r]]);
+  for (let col = 0; col < n; col += 1) {
+    let pivotRow = -1;
+    for (let r = col; r < n; r += 1) {
+      if (rows[r][col].num !== 0n) {
+        pivotRow = r;
+        break;
+      }
+    }
+    if (pivotRow === -1) {
+      throw new Error("partialFractions: singular partial-fraction linear system");
+    }
+    if (pivotRow !== col) {
+      const tmp = rows[col];
+      rows[col] = rows[pivotRow];
+      rows[pivotRow] = tmp;
+    }
+    const pivotVal = rows[col][col];
+    rows[col] = rows[col].map((v) => ratDiv(v, pivotVal));
+    for (let r = 0; r < n; r += 1) {
+      if (r === col) {
+        continue;
+      }
+      const factor2 = rows[r][col];
+      if (factor2.num === 0n) {
+        continue;
+      }
+      const pivotRowVals = rows[col];
+      rows[r] = rows[r].map((v, c) => ratSub(v, ratMul(factor2, pivotRowVals[c])));
+    }
+  }
+  return rows.map((row2) => row2[n]);
+}
+function partialFractions(remainder, factors) {
+  const trimmedRemainder = trim(remainder);
+  const factorPowers = factors.map((f) => {
+    const powers = [[1n]];
+    let acc = [1n];
+    for (let p = 1; p <= f.mult; p += 1) {
+      acc = mul(acc, f.poly);
+      powers.push(acc);
+    }
+    return powers;
+  });
+  const othersProduct = factors.map((_f, fi) => {
+    let acc = [1n];
+    for (let fj = 0; fj < factors.length; fj += 1) {
+      if (fj === fi) {
+        continue;
+      }
+      acc = mul(acc, factorPowers[fj][factors[fj].mult]);
+    }
+    return acc;
+  });
+  const degOf = (fi) => trim(factors[fi].poly).length - 1;
+  const unknowns = [];
+  for (let fi = 0; fi < factors.length; fi += 1) {
+    const di = degOf(fi);
+    for (let k = 1; k <= factors[fi].mult; k += 1) {
+      for (let j = 0; j < di; j += 1) {
+        unknowns.push({ fi, k, j });
+      }
+    }
+  }
+  const n = unknowns.length;
+  const columns = unknowns.map(({ fi, k, j }) => {
+    const remainingPower = factors[fi].mult - k;
+    const coPoly = mul(othersProduct[fi], factorPowers[fi][remainingPower]);
+    return shiftedColumn(coPoly, j, n);
+  });
+  const rows = [];
+  for (let r = 0; r < n; r += 1) {
+    rows.push(columns.map((col) => col[r]));
+  }
+  const rhs = new Array(n).fill(RAT_ZERO).map((_, idx2) => ratFromBigint(idx2 < trimmedRemainder.length ? trimmedRemainder[idx2] : 0n));
+  const solution = n === 0 ? [] : solveLinearSystemRat(rows, rhs);
+  const terms = [];
+  let idx = 0;
+  for (let fi = 0; fi < factors.length; fi += 1) {
+    const di = degOf(fi);
+    for (let k = 1; k <= factors[fi].mult; k += 1) {
+      const numer = [];
+      for (let j = 0; j < di; j += 1) {
+        numer.push(solution[idx]);
+        idx += 1;
+      }
+      terms.push({ factor: factors[fi].poly, power: k, numer });
+    }
+  }
+  return terms;
+}
+function ratNeg(r) {
+  return { num: -r.num, den: r.den };
+}
+function ratToStr(r) {
+  return r.den === 1n ? `${r.num}` : `${r.num}/${r.den}`;
+}
+function renderCoeffTimes(r, rest) {
+  const neg2 = r.num < 0n;
+  const absNum = neg2 ? -r.num : r.num;
+  const sign3 = neg2 ? "-" : "";
+  if (absNum === r.den) {
+    return `${sign3}${rest}`;
+  }
+  const denPart = r.den === 1n ? "" : `/${r.den}`;
+  return `${sign3}${absNum}${denPart}*${rest}`;
+}
+function renderXMinus(a, v) {
+  if (a.num === 0n) {
+    return v;
+  }
+  if (a.num > 0n) {
+    return `${v} - ${ratToStr(a)}`;
+  }
+  return `${v} + ${ratToStr(ratNeg(a))}`;
+}
+function renderQuadraticCore(b, c, v) {
+  let s = `${v}^2`;
+  if (b.num !== 0n) {
+    s += ` + (${ratToStr(b)})*${v}`;
+  }
+  s += ` + (${ratToStr(c)})`;
+  return s;
+}
+function renderTwoXPlusB(b, v) {
+  let s = `2*${v}`;
+  if (b.num !== 0n) {
+    s += ` + (${ratToStr(b)})`;
+  }
+  return s;
+}
+function joinTerms(parts) {
+  if (parts.length === 0) {
+    return "0";
+  }
+  return parts.join(" + ").replace(/\+ -/g, "- ");
+}
+function integrateLinearTerm(factor2, k, numer, v) {
+  const p0 = factor2[0];
+  const p1 = factor2[1];
+  const a = ratNeg(ratDiv(ratFromBigint(p0), ratFromBigint(p1)));
+  const A = ratDiv(numer[0], ratFromBigint(p1 ** BigInt(k)));
+  if (A.num === 0n) {
+    return "0";
+  }
+  const xMinus = renderXMinus(a, v);
+  if (k === 1) {
+    return renderCoeffTimes(A, `log(abs(${xMinus}))`);
+  }
+  const coeff = ratNeg(ratDiv(A, ratFromBigint(BigInt(k - 1))));
+  return renderCoeffTimes(coeff, `(${xMinus})^(${-(k - 1)})`);
+}
+function integrateInverseQuadraticPower(k, b, c) {
+  if (k === 1) {
+    return { terms: [], atanCoeff: ratFromBigint(1n) };
+  }
+  const prev = integrateInverseQuadraticPower(k - 1, b, c);
+  const d2 = ratSub(ratMul(ratFromBigint(4n), c), ratMul(b, b));
+  const denomFactor = ratMul(ratFromBigint(BigInt(k - 1)), d2);
+  const newTermCoeff = ratDiv(ratFromBigint(1n), denomFactor);
+  const propagate = ratDiv(ratFromBigint(BigInt(2 * (2 * k - 3))), denomFactor);
+  const terms = prev.terms.map((t) => ({ coeff: ratMul(t.coeff, propagate), power: t.power }));
+  terms.push({ coeff: newTermCoeff, power: k - 1 });
+  return { terms, atanCoeff: ratMul(prev.atanCoeff, propagate) };
+}
+function integrateQuadraticTerm(factor2, k, numer, v) {
+  const q0 = factor2[0];
+  const q1 = factor2[1];
+  const q2 = factor2[2];
+  const b = ratDiv(ratFromBigint(q1), ratFromBigint(q2));
+  const c = ratDiv(ratFromBigint(q0), ratFromBigint(q2));
+  const leadPow = ratFromBigint(q2 ** BigInt(k));
+  const D = ratDiv(numer[1], leadPow);
+  const E = ratDiv(numer[0], leadPow);
+  const d2 = ratSub(ratMul(ratFromBigint(4n), c), ratMul(b, b));
+  const K = ratSub(E, ratMul(D, ratDiv(b, ratFromBigint(2n))));
+  const qCore = renderQuadraticCore(b, c, v);
+  const twoXb = renderTwoXPlusB(b, v);
+  const parts = [];
+  if (D.num !== 0n) {
+    const half = ratDiv(D, ratFromBigint(2n));
+    if (k === 1) {
+      parts.push(renderCoeffTimes(half, `log(${qCore})`));
+    } else {
+      const coeff = ratNeg(ratDiv(half, ratFromBigint(BigInt(k - 1))));
+      parts.push(renderCoeffTimes(coeff, `(${qCore})^(${-(k - 1)})`));
+    }
+  }
+  if (K.num !== 0n) {
+    const ik = integrateInverseQuadraticPower(k, b, c);
+    for (const t of ik.terms) {
+      const coeff = ratMul(K, t.coeff);
+      if (coeff.num === 0n) {
+        continue;
+      }
+      parts.push(renderCoeffTimes(coeff, `(${twoXb})/(${qCore})^(${t.power})`));
+    }
+    const atanCoeff = ratMul(ratMul(K, ik.atanCoeff), ratFromBigint(2n));
+    if (atanCoeff.num !== 0n) {
+      const d2s = ratToStr(d2);
+      parts.push(renderCoeffTimes(atanCoeff, `atan((${twoXb})/sqrt(${d2s}))/sqrt(${d2s})`));
+    }
+  }
+  return joinTerms(parts);
+}
+function integratePFTerm(term, v) {
+  const factor2 = trim(term.factor);
+  const deg = factor2.length - 1;
+  if (deg === 1) {
+    return integrateLinearTerm(factor2, term.power, term.numer, v);
+  }
+  if (deg === 2) {
+    return integrateQuadraticTerm(factor2, term.power, term.numer, v);
+  }
+  throw new Error(`integratePFTerm: unsupported factor degree ${deg}`);
+}
+function integrateRationalFunction(expr, v) {
+  try {
+    const rf = parseRationalFunction(expr, v);
+    if (rf === null) {
+      return null;
+    }
+    const factors = factorDenominator(rf.denom);
+    if (factors === null) {
+      return null;
+    }
+    const { quotient, remainder } = polynomialPart(rf);
+    const terms = partialFractions(remainder, factors);
+    let prod2 = [1n];
+    for (const { poly, mult } of factors) {
+      for (let k = 0; k < mult; k += 1) prod2 = mul(prod2, poly);
+    }
+    const scalePoly = exactDivide(rf.denom, prod2);
+    if (scalePoly !== null && scalePoly.length === 1 && scalePoly[0] !== 1n) {
+      const scale4 = ratFromBigint(scalePoly[0]);
+      for (const term of terms) {
+        term.numer = term.numer.map((c) => ratDiv(c, scale4));
+      }
+    }
+    const parts = [];
+    const polyPart = integratePolynomial(quotient, v);
+    if (polyPart !== "0") {
+      parts.push(polyPart);
+    }
+    for (const term of terms) {
+      const s = integratePFTerm(term, v);
+      if (s !== "0") {
+        parts.push(s);
+      }
+    }
+    return joinTerms(parts);
+  } catch {
+    return null;
+  }
+}
+
 // src/cas-integration.ts
 var parse2 = parse;
 var evaluate2 = evaluate;
@@ -50846,7 +51308,7 @@ function symbolicIntegral(expr, variable = "x") {
     return integrateNode(parse2(expr), variable);
   } catch (e) {
     if (!(e instanceof NotIntegrable)) throw e;
-    return tryPartialFractions(expr, variable) ?? tryByParts(expr, variable) ?? `integral(${expr}, ${variable})`;
+    return tryPartialFractions(expr, variable) ?? tryByParts(expr, variable) ?? integrateRationalFunction(expr, variable) ?? `integral(${expr}, ${variable})`;
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-functions",
-  "version": "0.59.0",
+  "version": "0.60.0",
   "description": "Mathematical functions for MathTS - arithmetic, algebra, trigonometry, statistics, and more",
   "author": "Daniel Simon Jr.",
   "license": "MIT",