@danielsimonjr/mathts-functions 0.59.0 → 0.61.0

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

@@ -0,0 +1,197 @@
+/**
+ * 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;
+/**
+ * A quadratic surd `a + b·√Δ` for a fixed positive non-square radicand `Δ`
+ * (Δ > 0, non-square — a perfect-square Δ never occurs here since it would
+ * already have split into rational linear factors). `Δ` is NOT stored on the
+ * `Surd` itself: surds produced within one computation share a single `Δ`,
+ * and every op that needs it (`surdMul`, `surdDiv`, `surdRender`) takes it as
+ * an explicit parameter. `surdAdd`/`surdSub`/`surdNeg`/`surdFromRat` are
+ * Δ-independent (componentwise on `a`/`b`), so they don't take it.
+ *
+ * See docs/superpowers/specs/2026-07-21-risch-layer2-quadratic-surd-design.md
+ * (Architecture §1).
+ */
+export interface Surd {
+    a: Rat;
+    b: Rat;
+}
+/** Lifts a rational number to a surd with zero `√Δ` component. */
+export declare function surdFromRat(r: Rat): Surd;
+/** Negates a surd componentwise. */
+export declare function surdNeg(s: Surd): Surd;
+/** Componentwise surd addition (Δ-independent). */
+export declare function surdAdd(x: Surd, y: Surd): Surd;
+/** Componentwise surd subtraction (Δ-independent). */
+export declare function surdSub(x: Surd, y: Surd): Surd;
+/**
+ * Surd multiplication: `(a+b√Δ)(c+d√Δ) = (ac+bdΔ) + (ad+bc)√Δ`, using exact
+ * `Rat` arithmetic throughout (`Δ` lifted to a `Rat` via `ratFromBigint`).
+ */
+export declare function surdMul(x: Surd, y: Surd, delta: bigint): Surd;
+/**
+ * Surd division, rationalized by the conjugate: `(a+b√Δ)/(c+d√Δ) =
+ * (a+b√Δ)(c−d√Δ) / (c²−d²Δ)`, where `c²−d²Δ` is a plain rational scalar.
+ * Throws when `y` is zero (both components zero).
+ */
+export declare function surdDiv(x: Surd, y: Surd, delta: bigint): Surd;
+/**
+ * Renders a surd as a readable, evaluable string `a + b*sqrt(Δ)`: a zero `a`
+ * or zero `b` component is omitted, `b = 1`/`b = -1` render as bare
+ * `sqrt(Δ)`/`- sqrt(Δ)`, and integer `Rat`s print without a `/1`. Exact
+ * format is non-contractual (correctness is verified by differentiation
+ * elsewhere); this only needs to stay evaluable and readable.
+ */
+export declare function surdRender(s: Surd, delta: bigint): string;
+/**
+ * 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 for
+ * closed-form integration:
+ *   - `'linear'` (degree 1) → a `log`;
+ *   - `'quadratic-neg'` (degree 2, discriminant `b²−4ac < 0`, complex roots) →
+ *     a `log` + `atan` pair (Layer 1);
+ *   - `'quadratic-pos'` (degree 2, discriminant `> 0`, real irrational roots,
+ *     multiplicity 1) → a pair of real `log`s with quadratic-surd coefficients
+ *     (Layer 2, see the quadratic-surd design doc).
+ * Degree-≥3 irreducible factors, and repeated positive-discriminant quadratics,
+ * are out of scope (see `factorDenominator`, which returns `null` for them).
+ */
+export interface DenFactor {
+    poly: IntPoly;
+    mult: number;
+    kind: 'linear' | 'quadratic-neg' | 'quadratic-pos';
+}
+/**
+ * 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, having survived complete
+ * factorization over ℚ, is irreducible over ℚ — but that does NOT fix its
+ * discriminant sign: `disc = b²−4ac < 0` (complex roots, e.g. x²+1) is
+ * `'quadratic-neg'` (Layer 1 arctan path); `disc > 0` (real irrational roots,
+ * a non-square disc, e.g. x²−2) with **multiplicity 1** is `'quadratic-pos'`
+ * (Layer 2 quadratic-surd path).
+ *
+ * Returns `null` when a factor is out of scope: any irreducible factor of
+ * degree ≥ 3, or a **repeated** positive-discriminant quadratic (`disc > 0`,
+ * `mult > 1`) — the reduction formula for repeated real-root quadratics is
+ * Layer 3. The caller then falls back to the `integral(...)` marker.
+ */
+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` and, for a quadratic, on its discriminant sign:
+ *   - degree 1 → `log` (+ rational part for a repeated factor);
+ *   - degree 2, `disc < 0` (complex roots) → `log`/rational part + `atan`;
+ *   - degree 2, `disc > 0` (real irrational roots, power 1) → a pair of real
+ *     `log`s with quadratic-surd coefficients (Layer 2).
+ * 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, or on a
+ * positive-discriminant quadratic with power > 1 (both 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":"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"}

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

@@ -10019,11 +10019,15 @@ function landauMignotte(p) {
     return 1n;
   }
   const n = BigInt(d + 1);
-  const lcAbs = t[d] < 0n ? -t[d] : t[d];
   const powerOfTwo = 1n << BigInt(d);
+  let normSq = 0n;
+  for (const c of t) {
+    normSq += c * c;
+  }
+  const norm2Ceil = isqrt(normSq) + 1n;
   const sq = isqrt(n);
   const sqrtCeil = sq * sq === n ? sq : sq + 1n;
-  const bound = sqrtCeil * powerOfTwo * (lcAbs === 0n ? 1n : lcAbs);
+  const bound = sqrtCeil * powerOfTwo * norm2Ceil;
   return bound > 0n ? bound : 1n;
 }
 function modSymmetric(p, m) {
@@ -50609,6 +50613,558 @@ 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 ratAdd(a, b) {
+  return ratNormalize(a.num * b.den + b.num * a.den, a.den * b.den);
+}
+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 surdFromRat(r) {
+  return { a: r, b: RAT_ZERO };
+}
+function surdNeg(s) {
+  return { a: ratNeg(s.a), b: ratNeg(s.b) };
+}
+function surdAdd(x, y) {
+  return { a: ratAdd(x.a, y.a), b: ratAdd(x.b, y.b) };
+}
+function surdMul(x, y, delta) {
+  const d = ratFromBigint(delta);
+  return {
+    a: ratAdd(ratMul(x.a, y.a), ratMul(ratMul(x.b, y.b), d)),
+    b: ratAdd(ratMul(x.a, y.b), ratMul(x.b, y.a))
+  };
+}
+function surdDiv(x, y, delta) {
+  if (y.a.num === 0n && y.b.num === 0n) {
+    throw new Error("surdDiv: division by zero surd");
+  }
+  const d = ratFromBigint(delta);
+  const scale4 = ratSub(ratMul(y.a, y.a), ratMul(ratMul(y.b, y.b), d));
+  const conj3 = { a: y.a, b: ratNeg(y.b) };
+  const numer = surdMul(x, conj3, delta);
+  return { a: ratDiv(numer.a, scale4), b: ratDiv(numer.b, scale4) };
+}
+function surdRender(s, delta) {
+  const parts = [];
+  if (s.a.num !== 0n) {
+    parts.push(ratToStr(s.a));
+  }
+  if (s.b.num !== 0n) {
+    const neg2 = s.b.num < 0n;
+    const absB = neg2 ? ratNeg(s.b) : s.b;
+    const sqrtPart = `sqrt(${delta})`;
+    const term = absB.num === absB.den ? sqrtPart : `${ratToStr(absB)}*${sqrtPart}`;
+    if (parts.length === 0) {
+      parts.push(neg2 ? `- ${term}` : term);
+    } else {
+      parts.push(neg2 ? `- ${term}` : `+ ${term}`);
+    }
+  }
+  if (parts.length === 0) {
+    return "0";
+  }
+  return parts.join(" ");
+}
+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) {
+        out.push({ poly, mult, kind: "quadratic-neg" });
+      } else if (mult === 1) {
+        out.push({ poly, mult, kind: "quadratic-pos" });
+      } else {
+        return null;
+      }
+    } 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 integrateQuadraticPosTerm(factor2, numer, v) {
+  const c = factor2[0];
+  const b = factor2[1];
+  const a = factor2[2];
+  const R = b * b - 4n * a * c;
+  const D = numer[1] ?? RAT_ZERO;
+  const E = numer[0] ?? RAT_ZERO;
+  const twoA = ratFromBigint(2n * a);
+  const negBOver2A = ratDiv(ratFromBigint(-b), twoA);
+  const inv2A = ratDiv(ratFromBigint(1n), twoA);
+  const r1 = { a: negBOver2A, b: inv2A };
+  const r2 = { a: negBOver2A, b: ratNeg(inv2A) };
+  const sqrtR = { a: RAT_ZERO, b: ratFromBigint(1n) };
+  const Dsurd = surdFromRat(D);
+  const Esurd = surdFromRat(E);
+  const numA = surdAdd(surdMul(Dsurd, r1, R), Esurd);
+  const numB = surdAdd(surdMul(Dsurd, r2, R), Esurd);
+  const A = surdDiv(numA, sqrtR, R);
+  const B = surdDiv(numB, surdNeg(sqrtR), R);
+  const parts = [];
+  const emit = (coeff, root2) => {
+    if (coeff.a.num === 0n && coeff.b.num === 0n) {
+      return;
+    }
+    parts.push(`(${surdRender(coeff, R)})*log(abs(${v} - (${surdRender(root2, R)})))`);
+  };
+  emit(A, r1);
+  emit(B, r2);
+  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) {
+    const disc = factor2[1] * factor2[1] - 4n * factor2[2] * factor2[0];
+    if (disc < 0n) {
+      return integrateQuadraticTerm(factor2, term.power, term.numer, v);
+    }
+    if (term.power !== 1) {
+      throw new Error("integratePFTerm: repeated positive-discriminant quadratic is out of scope");
+    }
+    return integrateQuadraticPosTerm(factor2, 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 +51402,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/dist/typed/factorization/integer-poly.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"integer-poly.d.ts","sourceRoot":"","sources":["../../../src/typed/factorization/integer-poly.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,qEAAqE;AACrE,MAAM,MAAM,OAAO,GAAG,MAAM,EAAE,CAAC;AAE/B;;;GAGG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAMxC;AAED,sEAAsE;AACtE,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAGzC;AAED,+DAA+D;AAC/D,wBAAgB,EAAE,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAGrC;AAED,4EAA4E;AAC5E,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAE1C;AAED,wBAAwB;AACxB,wBAAgB,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CASnD;AAED,wBAAwB;AACxB,wBAAgB,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CASnD;AAED,qBAAqB;AACrB,wBAAgB,GAAG,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAEvC;AAED,uDAAuD;AACvD,wBAAgB,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAenD;AAED,iDAAiD;AACjD,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAExD;AAED,gFAAgF;AAChF,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAQtD;AAED,4DAA4D;AAC5D,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAOtD;AAED,sDAAsD;AACtD,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAStD;AAED,0EAA0E;AAC1E,wBAAgB,OAAO,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAO1C;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAYjD;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,IAAI,CAmClE;AAED,sEAAsE;AACtE,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAU9C;AAyBD;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAkBxD;AAmBD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAejD;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAa3D"}
+{"version":3,"file":"integer-poly.d.ts","sourceRoot":"","sources":["../../../src/typed/factorization/integer-poly.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,qEAAqE;AACrE,MAAM,MAAM,OAAO,GAAG,MAAM,EAAE,CAAC;AAE/B;;;GAGG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAMxC;AAED,sEAAsE;AACtE,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAGzC;AAED,+DAA+D;AAC/D,wBAAgB,EAAE,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAGrC;AAED,4EAA4E;AAC5E,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAE1C;AAED,wBAAwB;AACxB,wBAAgB,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CASnD;AAED,wBAAwB;AACxB,wBAAgB,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CASnD;AAED,qBAAqB;AACrB,wBAAgB,GAAG,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAEvC;AAED,uDAAuD;AACvD,wBAAgB,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAenD;AAED,iDAAiD;AACjD,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAExD;AAED,gFAAgF;AAChF,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAQtD;AAED,4DAA4D;AAC5D,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAOtD;AAED,sDAAsD;AACtD,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAStD;AAED,0EAA0E;AAC1E,wBAAgB,OAAO,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAO1C;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAYjD;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,IAAI,CAmClE;AAED,sEAAsE;AACtE,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAU9C;AAyBD;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAkBxD;AAmBD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAyBjD;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAa3D"}

package/package.json

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