@danielsimonjr/mathts-functions 0.60.0 → 0.61.0

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

@@ -29,6 +29,49 @@ 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
@@ -64,29 +107,37 @@ export declare function polynomialPart(rf: RatFunc): {
  */
 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`).
+ * 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';
+    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 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).
+ * 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 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).
+ * 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;
 /**
@@ -117,12 +168,16 @@ export interface PFTerm {
 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`.
+ * 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 (unreachable
- * for a `factorDenominator`-classified factor).
+ * 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;
 /**

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

@@ -1 +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"}
+{"version":3,"file":"rational-integrate.d.ts","sourceRoot":"","sources":["../../src/cas/rational-integrate.ts"],"names":[],"mappings":"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"}

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) {
@@ -50626,6 +50630,9 @@ function ratNormalize(num2, den) {
   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);
 }
@@ -50642,6 +50649,53 @@ 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) {
@@ -50793,10 +50847,13 @@ function factorDenominator(denom) {
     } else if (deg === 2) {
       const q = trim(poly);
       const disc = q[1] * q[1] - 4n * q[2] * q[0];
-      if (disc >= 0n) {
+      if (disc < 0n) {
+        out.push({ poly, mult, kind: "quadratic-neg" });
+      } else if (mult === 1) {
+        out.push({ poly, mult, kind: "quadratic-pos" });
+      } else {
         return null;
       }
-      out.push({ poly, mult, kind: "quadratic" });
     } else {
       return null;
     }
@@ -51020,6 +51077,36 @@ function integrateQuadraticTerm(factor2, k, numer, v) {
   }
   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;
@@ -51027,7 +51114,14 @@ function integratePFTerm(term, v) {
     return integrateLinearTerm(factor2, term.power, term.numer, v);
   }
   if (deg === 2) {
-    return integrateQuadraticTerm(factor2, term.power, term.numer, v);
+    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}`);
 }

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.60.0",
+  "version": "0.61.0",
   "description": "Mathematical functions for MathTS - arithmetic, algebra, trigonometry, statistics, and more",
   "author": "Daniel Simon Jr.",
   "license": "MIT",