@danielsimonjr/mathts-functions 0.60.0 → 0.62.0

package/dist/index.js

@@ -2039,6 +2039,28 @@ var xgcd = mathTyped2("xgcd", {
       [y, lastY] = [lastY - q * y, y];
     }
     return a < 0n ? [-a, -lastX, -lastY] : [a, lastX, lastY];
+  },
+  "Fraction, Fraction": (a, b) => {
+    if (!a.isInteger() || !b.isInteger()) {
+      throw new Error("Parameters in function xgcd must be integer numbers");
+    }
+    const zero = new Fraction(0n, 1n);
+    const one = new Fraction(1n, 1n);
+    let x = zero, lastX = one;
+    let y = one, lastY = zero;
+    while (!b.isZero()) {
+      const q = a.divide(b).floor();
+      const r = a.mod(b);
+      const nextX = lastX.subtract(q.multiply(x));
+      const nextY = lastY.subtract(q.multiply(y));
+      lastX = x;
+      x = nextX;
+      lastY = y;
+      y = nextY;
+      a = b;
+      b = r;
+    }
+    return a.lessThan(zero) ? [a.negate(), lastX.negate(), lastY.negate()] : [a, !a.isZero() ? lastX : zero, lastY];
   }
 });
 function is2DArray(arr10) {
@@ -9734,18 +9756,55 @@ function polyFromExpression(expr, vars) {
   return result;
 }
 function divides(a, b) {
-  return a.every((p, i) => p <= b[i]);
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] > b[i]) return false;
+  }
+  return true;
+}
+function totalDegree(powers) {
+  let sum3 = 0;
+  for (let i = 0; i < powers.length; i++) sum3 += powers[i];
+  return sum3;
 }
+var DivisorGeobucket = class {
+  buckets = [];
+  maxDeg = 0;
+  constructor(polys) {
+    for (const p of polys) this.insert(p);
+  }
+  insert(poly) {
+    if (poly.length === 0) return;
+    const d = totalDegree(poly[0].powers);
+    if (!this.buckets[d]) this.buckets[d] = [];
+    this.buckets[d].push(poly);
+    if (d > this.maxDeg) this.maxDeg = d;
+  }
+  find(target) {
+    const d = totalDegree(target);
+    const limit2 = d < this.maxDeg ? d : this.maxDeg;
+    for (let i = 0; i <= limit2; i++) {
+      const bucket = this.buckets[i];
+      if (!bucket) continue;
+      for (let j = 0; j < bucket.length; j++) {
+        if (divides(bucket[j][0].powers, target)) {
+          return bucket[j];
+        }
+      }
+    }
+    return void 0;
+  }
+};
 function polyReduce(p, G) {
   const rem = [];
   let work = normalize(p);
   let guard = 0;
+  const index = Array.isArray(G) ? new DivisorGeobucket(G) : G;
   while (work.length > 0) {
     if (++guard > 2e4) {
       throw new Error("polyReduce: iteration cap exceeded (system too large for this CAS)");
     }
     const lt = work[0];
-    const g = G.find((q) => q.length > 0 && divides(q[0].powers, lt.powers));
+    const g = index.find(lt.powers);
     if (g) {
       const factor2 = [
         {
@@ -9783,15 +9842,18 @@ function buchberger(input) {
     for (let j = i + 1; j < G.length; j++) pairs.push([i, j]);
   }
   let iter = 0;
+  const index = new DivisorGeobucket(G);
   while (pairs.length > 0) {
     if (++iter > 2e3 || G.length > 64) {
       throw new Error("groebnerBasis: system too large (iteration/basis cap exceeded)");
     }
     const [i, j] = pairs.shift();
-    const s = polyReduce(sPoly(G[i], G[j]), G);
+    const s = polyReduce(sPoly(G[i], G[j]), index);
     if (s.length > 0) {
       const k = G.length;
-      G.push(monic(s));
+      const newPoly = monic(s);
+      G.push(newPoly);
+      index.insert(newPoly);
       for (let t = 0; t < k; t++) pairs.push([t, k]);
     }
   }
@@ -10019,11 +10081,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) {
@@ -10610,7 +10676,7 @@ function degreeIn(p, varIndex) {
   }
   return d;
 }
-function totalDegree(p) {
+function totalDegree2(p) {
   let d = -1;
   for (const k of p.terms.keys()) {
     const exps = unkey(k);
@@ -10896,7 +10962,7 @@ function candidateFor(pool, indices, bases, degBounds, vars) {
     return null;
   }
   const cand = primitivePartMP(back);
-  if (totalDegree(cand) < 1) {
+  if (totalDegree2(cand) < 1) {
     return null;
   }
   return cand;
@@ -10914,7 +10980,7 @@ function factorMultivariateKronecker(p) {
   if (p.vars.length < 2) {
     return null;
   }
-  if (isZero2(p) || totalDegree(p) < 1) {
+  if (isZero2(p) || totalDegree2(p) < 1) {
     return null;
   }
   const cont = integerContentMP(p);
@@ -10993,7 +11059,7 @@ function factorMultivariateKronecker(p) {
     const l = leadingTerm(gCur);
     const sgn = l !== null && l.coeff < 0n ? -1n : 1n;
     constant *= c * sgn;
-    if (totalDegree(gCur) >= 1) {
+    if (totalDegree2(gCur) >= 1) {
       found.push({ poly: primitivePartMP(gCur), mult: 1 });
     }
   }
@@ -22004,11 +22070,11 @@ var createSubtractScalar = /* @__PURE__ */ factory(
 
 // src/arithmetic/unaryMinus.ts
 var name14 = "unaryMinus";
-var dependencies14 = ["typed", "config", "?bignumber"];
+var dependencies14 = ["typed", "config", "?bignumber", "?fraction"];
 var createUnaryMinus = /* @__PURE__ */ factory(
   name14,
   dependencies14,
-  ({ typed: typed3, config: config2, bignumber: bignumber2 }) => {
+  ({ typed: typed3, config: config2, bignumber: bignumber2, fraction: fraction2 }) => {
     return typed3(name14, {
       number: unaryMinusNumber,
       "Complex | BigNumber | Fraction": (x) => x.neg(),
@@ -22031,7 +22097,10 @@ var createUnaryMinus = /* @__PURE__ */ factory(
           case "bigint":
             return BigInt(negValue);
           case "Fraction":
-            return negValue;
+            if (!fraction2) {
+              throw new Error("Fraction not available. Configure mathjs with Fraction support.");
+            }
+            return fraction2(negValue);
           case "number":
           default:
             return negValue;
@@ -22348,7 +22417,6 @@ var createArg = /* @__PURE__ */ factory(
       Complex: function(x) {
         return x.arg();
       },
-      // TODO: implement BigNumber support for function arg
       "Array | Matrix": typed3.referToSelf(
         (self) => (x) => deepMap(x, self)
       )
@@ -23190,26 +23258,36 @@ function randomMatrix(size2, random3) {
 // src/probability/random.ts
 var name32 = "random";
 var dependencies32 = ["typed", "config", "?on"];
+function _createRng(config2, on) {
+  let rng = createRng(config2.randomSeed);
+  if (on) {
+    on("config", function(curr, prev) {
+      if (curr.randomSeed !== prev.randomSeed) {
+        rng = createRng(curr.randomSeed);
+      }
+    });
+  }
+  return () => rng();
+}
+function _createRandomSignatures(rng) {
+  function _random(min2, max2) {
+    return min2 + rng() * (max2 - min2);
+  }
+  return {
+    _random,
+    signatures: {
+      "": () => _random(0, 1),
+      number: (max2) => _random(0, max2),
+      "number, number": (min2, max2) => _random(min2, max2)
+    }
+  };
+}
 var createRandom = /* @__PURE__ */ factory(
   name32,
   dependencies32,
   ({ typed: typed3, config: config2, on }) => {
-    let rng = createRng(config2.randomSeed);
-    if (on) {
-      on("config", function(curr, prev) {
-        if (curr.randomSeed !== prev.randomSeed) {
-          rng = createRng(curr.randomSeed);
-        }
-      });
-    }
-    return typed3(name32, {
-      "": () => _random(0, 1),
-      number: (max2) => _random(0, max2),
-      "number, number": (min2, max2) => _random(min2, max2),
-      "Array | Matrix": (size2) => _randomMatrix(size2, 0, 1),
-      "Array | Matrix, number": (size2, max2) => _randomMatrix(size2, 0, max2),
-      "Array | Matrix, number, number": (size2, min2, max2) => _randomMatrix(size2, min2, max2)
-    });
+    const rng = _createRng(config2, on);
+    const { _random, signatures } = _createRandomSignatures(rng);
     function _randomMatrix(size2, min2, max2) {
       const res = randomMatrix(
         size2.valueOf(),
@@ -23217,9 +23295,12 @@ var createRandom = /* @__PURE__ */ factory(
       );
       return isMatrix(size2) ? size2.create(res, "number") : res;
     }
-    function _random(min2, max2) {
-      return min2 + rng() * (max2 - min2);
-    }
+    return typed3(name32, {
+      ...signatures,
+      "Array | Matrix": (size2) => _randomMatrix(size2, 0, 1),
+      "Array | Matrix, number": (size2, max2) => _randomMatrix(size2, 0, max2),
+      "Array | Matrix, number, number": (size2, min2, max2) => _randomMatrix(size2, min2, max2)
+    });
   }
 );
 
@@ -24651,9 +24732,7 @@ var createProd = /* @__PURE__ */ factory(
       // prod([a, b, c, d, ...])
       "Array | Matrix": _prod,
       // prod([a, b, c, d, ...], dim)
-      "Array | Matrix, number | BigNumber": function(_array, _dim) {
-        throw new Error("prod(A, dim) is not yet supported");
-      },
+      "Array | Matrix, number | BigNumber": _nprodDim,
       // prod(a, b, c, d, ...)
       "...": function(args) {
         return _prod(args);
@@ -24690,6 +24769,15 @@ var createProd = /* @__PURE__ */ factory(
       }
       return prod2;
     }
+    function _nprodDim(array, dim) {
+      try {
+        const dimValue = typeof dim === "number" ? dim : dim.valueOf();
+        const prod2 = reduce2(array, dimValue, multiplyScalar2);
+        return prod2;
+      } catch (err) {
+        throw improveErrorMessage(err, "prod", void 0);
+      }
+    }
   }
 );
 
@@ -24802,11 +24890,11 @@ var createIsZero = /* @__PURE__ */ factory(
 
 // src/utils/parseNumber.ts
 var name83 = "parseNumberWithConfig";
-var dependencies83 = ["config", "?bignumber"];
+var dependencies83 = ["config", "?bignumber", "?fraction"];
 var createParseNumberWithConfig = /* @__PURE__ */ factory(
   name83,
   dependencies83,
-  ({ config: config2, bignumber: bignumber2 }) => {
+  ({ config: config2, bignumber: bignumber2, fraction: fraction2 }) => {
     function parseNumberWithConfig2(str) {
       if (typeof str !== "string") {
         throw new TypeError(`parseNumberWithConfig expects string, got ${typeof str}`);
@@ -24832,11 +24920,10 @@ var createParseNumberWithConfig = /* @__PURE__ */ factory(
             throw new SyntaxError(`String "${str}" is not a valid number`);
           }
         case "Fraction": {
-          const fracNum = Number(str);
-          if (isNaN(fracNum)) {
-            throw new SyntaxError(`String "${str}" is not a valid number`);
+          if (!fraction2) {
+            throw new Error("Fraction not available. Configure mathjs with Fraction support.");
           }
-          return fracNum;
+          return fraction2(str);
         }
         case "number":
         default: {
@@ -28052,19 +28139,22 @@ var createRound = /* @__PURE__ */ factory(
 
 // src/arithmetic/xgcd.ts
 var name112 = "xgcd";
-var dependencies112 = ["typed", "config", "matrix", "BigNumber"];
+var dependencies112 = ["typed", "config", "matrix", "BigNumber", "?Fraction"];
 var createXgcd = /* @__PURE__ */ factory(
   name112,
   dependencies112,
-  ({ typed: typed3, config: config2, matrix: matrix2, BigNumber: BigNumber9 }) => {
-    return typed3(name112, {
+  ({ typed: typed3, config: config2, matrix: matrix2, BigNumber: BigNumber9, Fraction: Fraction5 }) => {
+    const typedSignatures = {
       "number, number": function(a, b) {
         const res = xgcdNumber(a, b);
         return config2.matrix === "Array" ? res : matrix2(res);
       },
       "BigNumber, BigNumber": _xgcdBigNumber
-      // TODO: implement support for Fraction
-    });
+    };
+    if (Fraction5) {
+      typedSignatures["Fraction, Fraction"] = _xgcdFraction;
+    }
+    return typed3(name112, typedSignatures);
     function _xgcdBigNumber(a, b) {
       let t;
       let q;
@@ -28098,6 +28188,42 @@ var createXgcd = /* @__PURE__ */ factory(
       }
       return config2.matrix === "Array" ? res : matrix2(res);
     }
+    function _xgcdFraction(a, b) {
+      if (!Fraction5) {
+        throw new Error("Fraction is not available");
+      }
+      let t;
+      let q;
+      let r;
+      const zero = new Fraction5(0);
+      const one = new Fraction5(1);
+      let x = zero;
+      let lastx = one;
+      let y = one;
+      let lasty = zero;
+      if (!a.isInteger() || !b.isInteger()) {
+        throw new Error("Parameters in function xgcd must be integer numbers");
+      }
+      while (!b.isZero()) {
+        q = a.divide(b).floor();
+        r = a.mod(b);
+        t = x;
+        x = lastx.subtract(q.multiply(x));
+        lastx = t;
+        t = y;
+        y = lasty.subtract(q.multiply(y));
+        lasty = t;
+        a = b;
+        b = r;
+      }
+      let res;
+      if (a.lessThan(zero)) {
+        res = [a.negate(), lastx.negate(), lasty.negate()];
+      } else {
+        res = [a, !a.isZero() ? lastx : 0, lasty];
+      }
+      return config2.matrix === "Array" ? res : matrix2(res);
+    }
   }
 );
 
@@ -28181,9 +28307,6 @@ var createCatalan = /* @__PURE__ */ factory(
   }
 );
 
-// src/error/IndexError.ts
-import { IndexError, createIndexError } from "@danielsimonjr/mathts-core/internal";
-
 // src/error/DimensionError.ts
 import { DimensionError } from "@danielsimonjr/mathts-core/internal";
 
@@ -28218,7 +28341,7 @@ var createConcat = /* @__PURE__ */ factory(
               throw new TypeError("Integer number expected for dimension");
             }
             if (dim < 0 || i > 0 && dim > prevDim) {
-              throw new IndexError(dim, prevDim + 1);
+              throw new DimensionError(dim, dim < 0 ? 0 : prevDim, dim < 0 ? "<" : ">");
             }
           } else {
             const m = clone(arg3).valueOf();
@@ -28445,6 +28568,9 @@ var createInv = /* @__PURE__ */ factory(
   }
 );
 
+// src/error/IndexError.ts
+import { IndexError, createIndexError } from "@danielsimonjr/mathts-core/internal";
+
 // src/matrix/mapSlices.ts
 var name117 = "mapSlices";
 var dependencies117 = ["typed", "isInteger"];
@@ -28733,7 +28859,7 @@ var createSubset = /* @__PURE__ */ factory(
 );
 function _getSubstring(str, index) {
   if (!isIndex(index)) {
-    throw new TypeError("Index expected");
+    throw new TypeError("Invalid index: must be an Index or Index-like object");
   }
   if (isEmptyIndex(index)) {
     return "";
@@ -28759,7 +28885,7 @@ function _getSubstring(str, index) {
 }
 function _setSubstring(str, index, replacement, defaultValue) {
   if (!index || index.isIndex !== true) {
-    throw new TypeError("Index expected");
+    throw new TypeError("Invalid index: must be an Index or Index-like object");
   }
   if (isEmptyIndex(index)) {
     return str;
@@ -29515,7 +29641,7 @@ var createCumSum = /* @__PURE__ */ factory(
       const size2 = arraySize(array);
       const dimValue = typeof dim === "number" ? dim : dim.valueOf();
       if (dimValue < 0 || dimValue >= size2.length) {
-        throw new IndexError(dimValue, 0, size2.length);
+        throw new DimensionError(dimValue, size2.length, "<");
       }
       try {
         return _cumsumDimensional(array, dimValue);
@@ -35389,13 +35515,21 @@ var dependencies199 = [
   "multiply",
   "equalScalar",
   "divideScalar",
-  "inv",
+  "pinv",
   "nodeOperations"
 ];
 var createDivide = /* @__PURE__ */ factory(
   name199,
   dependencies199,
-  ({ typed: typed3, matrix: matrix2, multiply: multiply2, equalScalar: equalScalar3, divideScalar: divideScalar2, inv: inv3, nodeOperations: nodeOperations2 }) => {
+  ({
+    typed: typed3,
+    matrix: matrix2,
+    multiply: multiply2,
+    equalScalar: equalScalar3,
+    divideScalar: divideScalar2,
+    pinv: pinv2,
+    nodeOperations: nodeOperations2
+  }) => {
     const matAlgo11xS0s = createMatAlgo11xS0s({ typed: typed3, equalScalar: equalScalar3 });
     const matAlgo14xDs = createMatAlgo14xDs({ typed: typed3 });
     return typed3(
@@ -35423,7 +35557,7 @@ var createDivide = /* @__PURE__ */ factory(
           // MATRIX SIGNATURES - Deal with matrices
           // =========================================================================
           "Array | Matrix, Array | Matrix": function(x, y) {
-            return multiply2(x, inv3(y));
+            return multiply2(x, pinv2(y));
           },
           "DenseMatrix, any": function(x, y) {
             return matAlgo14xDs(
@@ -35450,7 +35584,7 @@ var createDivide = /* @__PURE__ */ factory(
             ).valueOf();
           },
           "any, Array | Matrix": function(x, y) {
-            return multiply2(x, inv3(y));
+            return multiply2(x, pinv2(y));
           }
         },
         divideScalar2.signatures
@@ -37834,6 +37968,15 @@ var createIntersect = /* @__PURE__ */ factory(
         ),
         z1z
       );
+      if (isZero4(denominator) || smaller2(abs2(denominator), config2.relTol)) {
+        if (isZero4(numerator) || smaller2(abs2(numerator), config2.relTol)) {
+          return [
+            [x1, y1, z1],
+            [x2, y2, z2]
+          ];
+        }
+        return null;
+      }
       const t = divideScalar2(numerator, denominator);
       const px = addScalar2(x1, multiplyScalar2(t, subtract3(x2, x1)));
       const py = addScalar2(y1, multiplyScalar2(t, subtract3(y2, y1)));
@@ -37919,11 +38062,11 @@ var createMean = /* @__PURE__ */ factory(
 
 // src/statistics/median.ts
 var name220 = "median";
-var dependencies220 = ["typed", "add", "divide", "compare", "partitionSelect"];
+var dependencies220 = ["typed", "add", "divide", "compare", "partitionSelect", "mapSlices"];
 var createMedian = /* @__PURE__ */ factory(
   name220,
   dependencies220,
-  ({ typed: typed3, add: add5, divide: divide2, compare: compare2, partitionSelect: partitionSelect2 }) => {
+  ({ typed: typed3, add: add5, divide: divide2, compare: compare2, partitionSelect: partitionSelect2, mapSlices: mapSlices2 }) => {
     function _median2(array) {
       try {
         const flat = flatten2(array.valueOf());
@@ -37964,7 +38107,11 @@ var createMedian = /* @__PURE__ */ factory(
       "Array | Matrix": _median2,
       // median([a, b, c, d, ...], dim)
       "Array | Matrix, number | BigNumber": function(_array, _dim) {
-        throw new Error("median(A, dim) is not yet supported");
+        try {
+          return mapSlices2(_array, _dim, (x) => _median2(x));
+        } catch (err) {
+          throw improveErrorMessage(err, "median", void 0);
+        }
       },
       // median(a, b, c, d, ...)
       "...": function(args) {
@@ -42793,7 +42940,6 @@ var createRationalize = /* @__PURE__ */ factory(
       const variables2 = [];
       const node = simplify2(expr, rules, scope, { exactFractions: false });
       extended = !!extended;
-      const oper = "+-*" + (extended ? "/" : "");
       recPoly(node);
       const retFunc = {};
       retFunc.expression = node;
@@ -42811,9 +42957,10 @@ var createRationalize = /* @__PURE__ */ factory(
               recPoly(node2.args[0]);
             }
           } else {
-            if (!oper.includes(node2.op)) {
+            const op = node2.op;
+            if (op !== "+" && op !== "-" && op !== "*" && op !== "^" && (!extended || op !== "/")) {
               throw new Error(
-                "Operator " + node2.op + " invalid in polynomial expression"
+                "Operator " + op + " invalid in polynomial expression"
               );
             }
             for (let i = 0; i < node2.args.length; i++) {
@@ -43053,8 +43200,9 @@ var createRationalize = /* @__PURE__ */ factory(
         if (tp === "FunctionNode") {
           throw new Error("There is an unsolved function call");
         } else if (tp === "OperatorNode") {
-          if (!"+-*^".includes(node2.op))
-            throw new Error("Operator " + node2.op + " invalid");
+          const op = node2.op;
+          if (op !== "+" && op !== "-" && op !== "*" && op !== "^")
+            throw new Error("Operator " + op + " invalid");
           if (noPai !== null) {
             if ((node2.fn === "unaryMinus" || node2.fn === "pow") && noPai.fn !== "add" && noPai.fn !== "subtract" && noPai.fn !== "multiply") {
               throw new Error("Invalid " + node2.op + " placing");
@@ -44771,7 +44919,6 @@ function reviver(_key, value) {
 }
 
 // src/typed/cas.ts
-import { computePool as computePool12 } from "@danielsimonjr/mathts-parallel";
 import { Complex as Complex10 } from "@danielsimonjr/mathts-core";
 
 // src/numeric/numeric-jacobian.ts
@@ -46208,15 +46355,17 @@ function _combineLikeTerms(expr) {
   return parts.join(" + ").replace(/\+\s*-/g, "- ");
 }
 function _casDerivativeOne(expr, variable) {
+  if (expr.indexOf(variable) === -1) return "0";
   const terms = expr.split(/\s*\+\s*/);
   const derivedTerms = [];
+  const powerRe = new RegExp("^(-?\\d*\\.?\\d*)\\s*\\*?\\s*" + variable + "\\^(\\d+)$");
+  const linearRe = new RegExp("^(-?\\d*\\.?\\d*)\\s*\\*?\\s*" + variable + "$");
   for (const term of terms) {
     const t = term.trim();
-    if (!t.includes(variable)) {
+    if (t.indexOf(variable) === -1) {
       derivedTerms.push("0");
       continue;
     }
-    const powerRe = new RegExp("^(-?\\d*\\.?\\d*)\\s*\\*?\\s*" + variable + "\\^(\\d+)$");
     const powerMatch = t.match(powerRe);
     if (powerMatch) {
       const coeff = powerMatch[1] === "" || powerMatch[1] === void 0 ? 1 : parseFloat(powerMatch[1]);
@@ -46230,7 +46379,6 @@ function _casDerivativeOne(expr, variable) {
       }
       continue;
     }
-    const linearRe = new RegExp("^(-?\\d*\\.?\\d*)\\s*\\*?\\s*" + variable + "$");
     const linearMatch = t.match(linearRe);
     if (linearMatch) {
       const coeff = linearMatch[1] === "" ? 1 : parseFloat(linearMatch[1]);
@@ -46269,199 +46417,14 @@ function casSimplify(input) {
     return _casSimplifyOne(_nodeToStr(input));
   }
   const strs = input.map(_nodeToStr);
-  if (strs.length < CAS_BATCH_THRESHOLD || !computePool12.isReady()) {
-    return Promise.resolve(strs.map(_casSimplifyOne));
-  }
-  return computePool12.map(strs, (exprStr) => {
-    function _evalNumeric2(exprStr2) {
-      let pos = 0;
-      const s = exprStr2.replace(/\s+/g, "");
-      const parseExpr = () => {
-        let val = parseTerm();
-        while (pos < s.length) {
-          if (s[pos] === "+") {
-            pos++;
-            val += parseTerm();
-          } else if (s[pos] === "-") {
-            pos++;
-            val -= parseTerm();
-          } else break;
-        }
-        return val;
-      };
-      const parseTerm = () => {
-        let val = parseFactor();
-        while (pos < s.length) {
-          if (s[pos] === "*") {
-            pos++;
-            val *= parseFactor();
-          } else if (s[pos] === "/") {
-            pos++;
-            val /= parseFactor();
-          } else break;
-        }
-        return val;
-      };
-      const parseFactor = () => {
-        let val = parseBase();
-        if (pos < s.length && s[pos] === "^") {
-          pos++;
-          val = Math.pow(val, parseFactor());
-        }
-        return val;
-      };
-      const parseBase = () => {
-        if (s[pos] === "+") {
-          pos++;
-          return parseBase();
-        }
-        if (s[pos] === "-") {
-          pos++;
-          return -parseBase();
-        }
-        if (s[pos] === "(") {
-          pos++;
-          const val = parseExpr();
-          if (s[pos] === ")") pos++;
-          return val;
-        }
-        const start = pos;
-        while (pos < s.length && /[\d.]/.test(s[pos])) pos++;
-        if (start === pos) throw new Error();
-        return parseFloat(s.substring(start, pos));
-      };
-      try {
-        const val = parseExpr();
-        if (pos === s.length && typeof val === "number" && isFinite(val)) {
-          return String(val);
-        }
-      } catch {
-      }
-      return void 0;
-    }
-    function _combineLikeTermsW(expr) {
-      const normalised = expr.replace(/\s*-\s*/g, " + -");
-      const rawTerms = normalised.split(/\s*\+\s*/);
-      const termMap = /* @__PURE__ */ new Map();
-      const otherTerms = [];
-      for (const raw of rawTerms) {
-        const t = raw.trim();
-        if (!t) continue;
-        if (/^-?\d+(\.\d+)?$/.test(t)) {
-          termMap.set("__const__", (termMap.get("__const__") ?? 0) + Number(t));
-          continue;
-        }
-        const cvpMatch = t.match(/^(-?\d*\.?\d*)\s*\*?\s*(\w+)\^(\d+)$/);
-        if (cvpMatch) {
-          const c = cvpMatch[1] === "" || cvpMatch[1] === "+" ? 1 : cvpMatch[1] === "-" ? -1 : Number(cvpMatch[1]);
-          const key2 = cvpMatch[2] + "^" + cvpMatch[3];
-          termMap.set(key2, (termMap.get(key2) ?? 0) + c);
-          continue;
-        }
-        const cvMatch = t.match(/^(-?\d*\.?\d*)\s*\*?\s*(\w+)$/);
-        if (cvMatch && !/^\d+$/.test(cvMatch[2])) {
-          const c = cvMatch[1] === "" || cvMatch[1] === "+" ? 1 : cvMatch[1] === "-" ? -1 : Number(cvMatch[1]);
-          termMap.set(cvMatch[2], (termMap.get(cvMatch[2]) ?? 0) + c);
-          continue;
-        }
-        otherTerms.push(t);
-      }
-      const parts = [];
-      for (const [key2, c] of termMap) {
-        if (Math.abs(c) < 1e-12) continue;
-        if (key2 === "__const__") {
-          parts.push(String(c));
-        } else if (Math.abs(c - 1) < 1e-12) {
-          parts.push(key2);
-        } else if (Math.abs(c + 1) < 1e-12) {
-          parts.push("-" + key2);
-        } else {
-          parts.push(c + "*" + key2);
-        }
-      }
-      parts.push(...otherTerms);
-      if (parts.length === 0) return "0";
-      return parts.join(" + ").replace(/\+\s*-/g, "- ");
-    }
-    let r = exprStr.trim();
-    r = r.replace(/\b(\w+)\^0\b/g, "1");
-    r = r.replace(/\b(\w+)\^1\b/g, "$1");
-    r = r.replace(/\b1\s*\*\s*/g, "");
-    r = r.replace(/\s*\*\s*1\b/g, "");
-    r = r.replace(/\b0\s*\+\s*/g, "");
-    r = r.replace(/\s*\+\s*0\b/g, "");
-    r = r.replace(/\b0\s*\*\s*[^+-]*/g, "0");
-    if (/^[\d\s+\-*/().^]+$/.test(r)) {
-      const val = _evalNumeric2(r);
-      if (val !== void 0) return val;
-    }
-    return _combineLikeTermsW(r) || "0";
-  }).then((r) => r.result);
+  return Promise.resolve(strs.map(_casSimplifyOne));
 }
 function casDerivative(input, variable) {
   if (!Array.isArray(input)) {
     return _casDerivativeOne(_nodeToStr(input), variable);
   }
   const strs = input.map(_nodeToStr);
-  if (strs.length < CAS_BATCH_THRESHOLD || !computePool12.isReady()) {
-    return Promise.resolve(strs.map((s) => _casDerivativeOne(s, variable)));
-  }
-  const varName = variable;
-  return computePool12.map(strs, (exprStr) => {
-    const _variable = varName;
-    const terms = exprStr.split(/\s*\+\s*/);
-    const derivedTerms = [];
-    for (const term of terms) {
-      const t = term.trim();
-      if (!t.includes(_variable)) {
-        derivedTerms.push("0");
-        continue;
-      }
-      const powerRe = new RegExp("^(-?\\d*\\.?\\d*)\\s*\\*?\\s*" + _variable + "\\^(\\d+)$");
-      const powerMatch = t.match(powerRe);
-      if (powerMatch) {
-        const coeff = powerMatch[1] === "" || powerMatch[1] === void 0 ? 1 : parseFloat(powerMatch[1]);
-        const n = parseInt(powerMatch[2], 10);
-        if (n === 0) {
-          derivedTerms.push("0");
-        } else if (n === 1) {
-          derivedTerms.push(String(coeff));
-        } else {
-          derivedTerms.push(coeff * n + "*" + _variable + "^" + (n - 1));
-        }
-        continue;
-      }
-      const linearRe = new RegExp("^(-?\\d*\\.?\\d*)\\s*\\*?\\s*" + _variable + "$");
-      const linearMatch = t.match(linearRe);
-      if (linearMatch) {
-        const coeff = linearMatch[1] === "" ? 1 : parseFloat(linearMatch[1]);
-        derivedTerms.push(String(coeff));
-        continue;
-      }
-      if (t === _variable) {
-        derivedTerms.push("1");
-        continue;
-      }
-      if (t === "sin(" + _variable + ")") {
-        derivedTerms.push("cos(" + _variable + ")");
-        continue;
-      }
-      if (t === "cos(" + _variable + ")") {
-        derivedTerms.push("-sin(" + _variable + ")");
-        continue;
-      }
-      if (t === "exp(" + _variable + ")") {
-        derivedTerms.push("exp(" + _variable + ")");
-        continue;
-      }
-      if (t === "ln(" + _variable + ")") {
-        derivedTerms.push("1/" + _variable);
-        continue;
-      }
-      derivedTerms.push("d/d" + _variable + "(" + t + ")");
-    }
-    return derivedTerms.join(" + ");
-  }).then((r) => r.result);
+  return Promise.resolve(strs.map((s) => _casDerivativeOne(s, variable)));
 }
 function casExpand(input) {
   if (!Array.isArray(input)) {
@@ -50626,6 +50589,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 +50608,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 +50806,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 +51036,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 +51073,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}`);
 }