@danielsimonjr/mathts-functions 0.58.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"}