@danielsimonjr/mathts-functions 0.61.0 → 0.63.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) {
@@ -9587,13 +9609,23 @@ function normalize(p) {
     if (existing) existing.coeff += t.coeff;
     else byKey.set(key2, { coeff: t.coeff, powers: [...t.powers] });
   }
-  return [...byKey.values()].filter((t) => Math.abs(t.coeff) > EPS).sort((a, b) => cmpPowers(b.powers, a.powers));
+  const out = [];
+  for (const t of byKey.values()) {
+    if (Math.abs(t.coeff) > EPS) {
+      out.push(t);
+    }
+  }
+  return out.sort((a, b) => cmpPowers(b.powers, a.powers));
 }
 function polyAdd(a, b) {
   return normalize([...a, ...b]);
 }
 function polyNeg(a) {
-  return a.map((t) => ({ coeff: -t.coeff, powers: [...t.powers] }));
+  const out = [];
+  for (let i = 0; i < a.length; i++) {
+    out.push({ coeff: -a[i].coeff, powers: [...a[i].powers] });
+  }
+  return out;
 }
 function polySub(a, b) {
   return polyAdd(a, polyNeg(b));
@@ -9602,9 +9634,13 @@ function polyMul(a, b) {
   const out = [];
   for (const ta of a) {
     for (const tb of b) {
+      const powers = new Array(ta.powers.length);
+      for (let i = 0; i < ta.powers.length; i++) {
+        powers[i] = ta.powers[i] + tb.powers[i];
+      }
       out.push({
         coeff: ta.coeff * tb.coeff,
-        powers: ta.powers.map((p, i) => p + tb.powers[i])
+        powers
       });
     }
   }
@@ -9617,12 +9653,24 @@ function polyPow(a, n, nVars) {
 }
 function polyFromExpression(expr, vars) {
   const nVars = vars.length;
-  const varIndex = new Map(vars.map((v, i) => [v, i]));
+  const varIndex = /* @__PURE__ */ new Map();
+  for (let i = 0; i < vars.length; i++) {
+    varIndex.set(vars[i], i);
+  }
   let pos = 0;
   const constPoly = (v) => normalize([{ coeff: v, powers: new Array(nVars).fill(0) }]);
   function constOf(p) {
     if (p.length === 0) return 0;
-    if (p.length === 1 && p[0].powers.every((x) => x === 0)) return p[0].coeff;
+    if (p.length === 1) {
+      let isConst2 = true;
+      for (let i = 0; i < p[0].powers.length; i++) {
+        if (p[0].powers[i] !== 0) {
+          isConst2 = false;
+          break;
+        }
+      }
+      if (isConst2) return p[0].coeff;
+    }
     return null;
   }
   const skipWs = () => {
@@ -9705,7 +9753,11 @@ function polyFromExpression(expr, vars) {
         if (denom === null || Math.abs(denom) <= EPS) {
           return fail("division only by a nonzero numeric constant");
         }
-        p = normalize(p.map((t) => ({ coeff: t.coeff / denom, powers: t.powers })));
+        const nextP = [];
+        for (let i = 0; i < p.length; i++) {
+          nextP.push({ coeff: p[i].coeff / denom, powers: p[i].powers });
+        }
+        p = normalize(nextP);
       } else {
         break;
       }
@@ -9734,23 +9786,64 @@ 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 powers = new Array(lt.powers.length);
+      for (let i = 0; i < lt.powers.length; i++) {
+        powers[i] = lt.powers[i] - g[0].powers[i];
+      }
       const factor2 = [
         {
           coeff: lt.coeff / g[0].coeff,
-          powers: lt.powers.map((x, i) => x - g[0].powers[i])
+          powers
         }
       ];
       work = polySub(work, polyMul(factor2, g));
@@ -9762,52 +9855,88 @@ function polyReduce(p, G) {
   return normalize(rem);
 }
 function lcmPowers(a, b) {
-  return a.map((x, i) => Math.max(x, b[i]));
+  const len = a.length;
+  const out = new Array(len);
+  for (let i = 0; i < len; i++) {
+    out[i] = Math.max(a[i], b[i]);
+  }
+  return out;
 }
 function sPoly(f, g) {
   const l = lcmPowers(f[0].powers, g[0].powers);
-  const mf = [{ coeff: 1 / f[0].coeff, powers: l.map((x, i) => x - f[0].powers[i]) }];
-  const mg = [{ coeff: 1 / g[0].coeff, powers: l.map((x, i) => x - g[0].powers[i]) }];
+  const mfPowers = new Array(l.length);
+  const mgPowers = new Array(l.length);
+  for (let i = 0; i < l.length; i++) {
+    mfPowers[i] = l[i] - f[0].powers[i];
+    mgPowers[i] = l[i] - g[0].powers[i];
+  }
+  const mf = [{ coeff: 1 / f[0].coeff, powers: mfPowers }];
+  const mg = [{ coeff: 1 / g[0].coeff, powers: mgPowers }];
   return polySub(polyMul(mf, f), polyMul(mg, g));
 }
 function monic(p) {
   if (p.length === 0) return p;
   const c = p[0].coeff;
-  return p.map((t) => ({ coeff: t.coeff / c, powers: [...t.powers] }));
+  const out = [];
+  for (let i = 0; i < p.length; i++) {
+    out.push({ coeff: p[i].coeff / c, powers: [...p[i].powers] });
+  }
+  return out;
 }
 function buchberger(input) {
-  let G = input.map(normalize).filter((p) => p.length > 0).map(monic);
+  let G = [];
+  for (let i = 0; i < input.length; i++) {
+    const p = normalize(input[i]);
+    if (p.length > 0) {
+      G.push(monic(p));
+    }
+  }
   if (G.length === 0) return [];
   const pairs = [];
   for (let i = 0; i < G.length; i++) {
     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]);
     }
   }
-  G = G.filter(
-    (g, i) => !G.some(
-      (h, j) => j !== i && h.length > 0 && divides(h[0].powers, g[0].powers) && (cmpPowers(h[0].powers, g[0].powers) !== 0 || j < i)
-    )
-  );
-  G = G.map(
-    (g, i) => monic(
-      polyReduce(
-        g,
-        G.filter((_, j) => j !== i)
-      )
-    )
-  ).filter((g) => g.length > 0);
+  const minimalG = [];
+  for (let i = 0; i < G.length; i++) {
+    const g = G[i];
+    let isDivisible = false;
+    for (let j = 0; j < G.length; j++) {
+      if (i === j) continue;
+      const h = G[j];
+      if (h.length > 0 && divides(h[0].powers, g[0].powers) && (cmpPowers(h[0].powers, g[0].powers) !== 0 || j < i)) {
+        isDivisible = true;
+        break;
+      }
+    }
+    if (!isDivisible) minimalG.push(g);
+  }
+  G = minimalG;
+  const reducedG = [];
+  for (let i = 0; i < G.length; i++) {
+    const others = [];
+    for (let j = 0; j < G.length; j++) {
+      if (i !== j) others.push(G[j]);
+    }
+    const reduced = monic(polyReduce(G[i], others));
+    if (reduced.length > 0) reducedG.push(reduced);
+  }
+  G = reducedG;
   G.sort((a, b) => cmpPowers(b[0].powers, a[0].powers));
   return G;
 }
@@ -9817,10 +9946,18 @@ function polyToString(p, vars) {
     const r = Math.round(c);
     return Math.abs(c - r) < 1e-9 ? String(r) : String(Number(c.toPrecision(12)));
   };
-  const terms = [...p].reverse().map((t) => {
-    const varPart = t.powers.map((e, i) => e === 0 ? "" : e === 1 ? vars[i] : `${vars[i]}^${e}`).filter(Boolean).join("*");
-    return varPart ? `${fmt(t.coeff)}*${varPart}` : fmt(t.coeff);
-  });
+  const terms = [];
+  for (let i = p.length - 1; i >= 0; i--) {
+    const t = p[i];
+    const parts = [];
+    for (let j = 0; j < t.powers.length; j++) {
+      const e = t.powers[j];
+      if (e === 1) parts.push(vars[j]);
+      else if (e > 1) parts.push(`${vars[j]}^${e}`);
+    }
+    const varPart = parts.join("*");
+    terms.push(varPart ? `${fmt(t.coeff)}*${varPart}` : fmt(t.coeff));
+  }
   return terms.join(" + ").replace(/\+ -/g, "- ");
 }
 
@@ -10614,7 +10751,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);
@@ -10900,7 +11037,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;
@@ -10918,7 +11055,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);
@@ -10997,7 +11134,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 });
     }
   }
@@ -17449,6 +17586,8 @@ function _betweennessOnce(adj, directed, normalise, seed) {
     if (denom > 0) {
       for (let i = 0; i < n; i++) cb[i] /= denom;
     }
+  } else if (!directed) {
+    for (let i = 0; i < n; i++) cb[i] /= 2;
   }
   return cb;
 }
@@ -22008,11 +22147,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(),
@@ -22035,7 +22174,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;
@@ -22316,6 +22458,36 @@ function rightArithShiftBigNumber(x, y) {
   }
   return x.div(new BigNumber9(2).pow(y)).floor();
 }
+function rightLogShiftBigNumber(x, y) {
+  if (x.isFinite() && !x.isInteger() || y.isFinite() && !y.isInteger()) {
+    throw new Error("Integers expected in function rightLogShift");
+  }
+  const BigNumber9 = x.constructor;
+  if (x.isNaN() || y.isNaN() || y.isNegative() && !y.isZero()) {
+    return new BigNumber9(NaN);
+  }
+  if (x.isZero() || y.isZero()) {
+    return x;
+  }
+  if (!y.isFinite()) {
+    if (x.isNegative() || !x.isFinite()) {
+      return new BigNumber9(NaN);
+    }
+    return new BigNumber9(0);
+  }
+  let val = x;
+  if (val.isNegative()) {
+    const MASK = new BigNumber9(4294967296);
+    val = val.mod(MASK);
+    if (val.isNegative()) {
+      val = val.plus(MASK);
+    }
+  }
+  if (y.lt(55)) {
+    return val.div(Math.pow(2, y.toNumber()) + "").floor();
+  }
+  return val.div(new BigNumber9(2).pow(y)).floor();
+}
 
 // src/bitwise/bitNot.ts
 var name15 = "bitNot";
@@ -22352,7 +22524,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)
       )
@@ -23194,26 +23365,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(),
@@ -23221,9 +23402,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)
+    });
   }
 );
 
@@ -24655,9 +24839,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);
@@ -24694,6 +24876,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);
+      }
+    }
   }
 );
 
@@ -24806,11 +24997,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}`);
@@ -24836,11 +25027,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: {
@@ -25451,17 +25641,79 @@ var createMatrixFromColumns = /* @__PURE__ */ factory(
           (item) => typeof item.toArray === "function"
         );
         const hasArray = arr10.some((item) => Array.isArray(item));
+        const isSparse = allMatrix && !hasArray && arr10.some(
+          (item) => typeof item.storage === "function" && item.storage() === "sparse"
+        );
+        if (isSparse) {
+          return _createSparseMatrixFromColumns(arr10);
+        }
         const arrays = arr10.map(
           (item) => typeof item.toArray === "function" ? item.toArray() : item
         );
         const result = _createArray(arrays);
         if (allMatrix && !hasArray) {
-          return matrix2(result);
+          return matrix2(result, "dense");
         }
         return result;
       }
-      // TODO implement this properly for SparseMatrix
     });
+    function _createSparseMatrixFromColumns(arr10) {
+      const M = arr10.length;
+      const N2 = checkVectorTypeAndReturnLength(arr10[0]);
+      const entries = [];
+      for (let j = 0; j < M; j++) {
+        const colVec = arr10[j];
+        const colLength = checkVectorTypeAndReturnLength(colVec);
+        if (colLength !== N2) {
+          throw new TypeError(
+            "The vectors had different length: " + (N2 | 0) + " \u2260 " + (colLength | 0)
+          );
+        }
+        if (typeof colVec.forEach === "function") {
+          const s = size2(colVec);
+          const is1D = s.length === 1;
+          const isCol = s.length === 2 && s[1] === 1;
+          colVec.forEach((val, idx) => {
+            let row2;
+            if (is1D) {
+              row2 = idx[0];
+            } else if (isCol) {
+              row2 = idx[0];
+            } else {
+              row2 = idx[1];
+            }
+            if (val !== 0) {
+              entries.push({ row: row2, col: j, value: val });
+            }
+          });
+        } else {
+          const f = flatten5(colVec);
+          for (let i = 0; i < N2; i++) {
+            if (f[i] !== 0) {
+              entries.push({ row: i, col: j, value: f[i] });
+            }
+          }
+        }
+      }
+      entries.sort((a, b) => {
+        if (a.col !== b.col) return a.col - b.col;
+        return a.row - b.row;
+      });
+      const values = [];
+      const index = [];
+      const ptr = new Array(M + 1).fill(0);
+      for (let i = 0; i < entries.length; i++) {
+        ptr[entries[i].col + 1]++;
+      }
+      for (let j = 1; j <= M; j++) {
+        ptr[j] += ptr[j - 1];
+      }
+      for (let i = 0; i < entries.length; i++) {
+        values.push(entries[i].value);
+        index.push(entries[i].row);
+      }
+      return matrix2({ values, index, ptr, size: [N2, M] }, "sparse");
+    }
     function _createArray(arr10) {
       if (arr10.length === 0)
         throw new TypeError("At least one column is needed to construct a matrix.");
@@ -25520,17 +25772,79 @@ var createMatrixFromRows = /* @__PURE__ */ factory(
           (item) => typeof item.toArray === "function"
         );
         const hasArray = arr10.some((item) => Array.isArray(item));
+        const isSparse = allMatrix && !hasArray && arr10.some(
+          (item) => typeof item.storage === "function" && item.storage() === "sparse"
+        );
+        if (isSparse) {
+          return _createSparseMatrixFromRows(arr10);
+        }
         const arrays = arr10.map(
           (item) => typeof item.toArray === "function" ? item.toArray() : item
         );
         const result = _createArray(arrays);
         if (allMatrix && !hasArray) {
-          return matrix2(result);
+          return matrix2(result, "dense");
         }
         return result;
       }
-      // TODO implement this properly for SparseMatrix
     });
+    function _createSparseMatrixFromRows(arr10) {
+      const N2 = arr10.length;
+      const M = checkVectorTypeAndReturnLength(arr10[0]);
+      const entries = [];
+      for (let i = 0; i < N2; i++) {
+        const rowVec = arr10[i];
+        const rowLength = checkVectorTypeAndReturnLength(rowVec);
+        if (rowLength !== M) {
+          throw new TypeError(
+            "The vectors had different length: " + (M | 0) + " \u2260 " + (rowLength | 0)
+          );
+        }
+        if (typeof rowVec.forEach === "function") {
+          const s = size2(rowVec);
+          const is1D = s.length === 1;
+          const isCol = s.length === 2 && s[1] === 1;
+          rowVec.forEach((val, idx) => {
+            let col;
+            if (is1D) {
+              col = idx[0];
+            } else if (isCol) {
+              col = idx[0];
+            } else {
+              col = idx[1];
+            }
+            if (val !== 0) {
+              entries.push({ row: i, col, value: val });
+            }
+          });
+        } else {
+          const f = flatten5(rowVec);
+          for (let j = 0; j < M; j++) {
+            if (f[j] !== 0) {
+              entries.push({ row: i, col: j, value: f[j] });
+            }
+          }
+        }
+      }
+      entries.sort((a, b) => {
+        if (a.col !== b.col) return a.col - b.col;
+        return a.row - b.row;
+      });
+      const values = [];
+      const index = [];
+      const ptr = new Array(M + 1).fill(0);
+      for (let i = 0; i < entries.length; i++) {
+        ptr[entries[i].col + 1]++;
+      }
+      for (let j = 1; j <= M; j++) {
+        ptr[j] += ptr[j - 1];
+      }
+      for (let i = 0; i < entries.length; i++) {
+        values.push(entries[i].value);
+        index.push(entries[i].row);
+      }
+      return matrix2({ values, index, ptr, size: [N2, M] }, "sparse");
+    }
     function _createArray(arr10) {
       if (arr10.length === 0)
         throw new TypeError("At least one row is needed to construct a matrix.");
@@ -27745,6 +28059,10 @@ var createMatAlgo11xS0s = /* @__PURE__ */ factory(
   name108,
   dependencies108,
   ({ typed: typed3, equalScalar: equalScalar3 }) => {
+    let _dtCache;
+    let _cbCache;
+    let _eqCache;
+    let _cfCache;
     return function matAlgo11xS0s(s, b, callback, inverse) {
       const avalues = s._values;
       const aindex = s._index;
@@ -27762,10 +28080,19 @@ var createMatAlgo11xS0s = /* @__PURE__ */ factory(
       let cf = callback;
       if (typeof adt === "string") {
         dt = adt;
-        eq = typed3.find(equalScalar3, [dt, dt]);
+        if (dt === _dtCache && callback === _cbCache) {
+          eq = _eqCache;
+          cf = _cfCache;
+        } else {
+          eq = typed3.find(equalScalar3, [dt, dt]) || equalScalar3;
+          cf = typed3.find(callback, [dt, dt]) || callback;
+          _dtCache = dt;
+          _cbCache = callback;
+          _eqCache = eq;
+          _cfCache = cf;
+        }
         zero = typed3.convert(0, dt);
         b = typed3.convert(b, dt);
-        cf = typed3.find(callback, [dt, dt]);
       }
       const cvalues = [];
       const cindex = [];
@@ -28056,19 +28383,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;
@@ -28102,6 +28432,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);
+    }
   }
 );
 
@@ -28185,9 +28551,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";
 
@@ -28199,45 +28562,52 @@ var createConcat = /* @__PURE__ */ factory(
   dependencies115,
   ({ typed: typed3, matrix: matrix2, isInteger: isInteger3 }) => {
     return typed3(name115, {
-      // TODO: change signature to '...Array | Matrix, dim?' when supported
       "...Array | Matrix | number | BigNumber": function(args) {
-        let i;
         const len = args.length;
+        if (len === 0) {
+          throw new SyntaxError("At least one matrix expected");
+        }
+        const lastArg = args[len - 1];
+        const hasDim = isNumber(lastArg) || isBigNumber(lastArg);
+        const dimIndex = hasDim ? len - 1 : len;
         let dim = -1;
-        let prevDim;
+        if (hasDim) {
+          dim = lastArg.valueOf();
+          if (!isInteger3(dim)) {
+            throw new TypeError("Integer number expected for dimension");
+          }
+        }
         let asMatrix = false;
+        let prevDim = -1;
         const matrices = [];
-        for (i = 0; i < len; i++) {
+        for (let i = 0; i < dimIndex; i++) {
           const arg3 = args[i];
+          if (isNumber(arg3) || isBigNumber(arg3)) {
+            throw new Error("Dimension must be specified as last argument");
+          }
           if (isMatrix(arg3)) {
             asMatrix = true;
           }
-          if (isNumber(arg3) || isBigNumber(arg3)) {
-            if (i !== len - 1) {
-              throw new Error("Dimension must be specified as last argument");
-            }
-            prevDim = dim;
-            dim = arg3.valueOf();
-            if (!isInteger3(dim)) {
-              throw new TypeError("Integer number expected for dimension");
-            }
-            if (dim < 0 || i > 0 && dim > prevDim) {
-              throw new IndexError(dim, prevDim + 1);
-            }
-          } else {
-            const m = clone(arg3).valueOf();
-            const size2 = arraySize(m);
-            matrices[i] = m;
-            prevDim = dim;
-            dim = size2.length - 1;
-            if (i > 0 && dim !== prevDim) {
-              throw new DimensionError(prevDim + 1, dim + 1);
-            }
+          const m = clone(arg3).valueOf();
+          const size2 = arraySize(m);
+          matrices.push(m);
+          const currentDim = size2.length - 1;
+          if (i === 0) {
+            prevDim = currentDim;
+          } else if (currentDim !== prevDim) {
+            throw new DimensionError(prevDim + 1, currentDim + 1);
           }
         }
         if (matrices.length === 0) {
           throw new SyntaxError("At least one matrix expected");
         }
+        if (hasDim) {
+          if (dim < 0 || dim > prevDim) {
+            throw new DimensionError(dim, dim < 0 ? 0 : prevDim, dim < 0 ? "<" : ">");
+          }
+        } else {
+          dim = prevDim;
+        }
         let res = matrices.shift();
         while (matrices.length) {
           res = concat(res, matrices.shift(), dim);
@@ -28449,6 +28819,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"];
@@ -28737,7 +29110,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 "";
@@ -28763,7 +29136,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;
@@ -28933,6 +29306,7 @@ var createMatAlgo03xDSf = /* @__PURE__ */ factory(
   name121,
   dependencies121,
   ({ typed: typed3 }) => {
+    const signaturesCache = /* @__PURE__ */ new WeakMap();
     return function matAlgo03xDSf(denseMatrix, sparseMatrix, callback, inverse) {
       const adata = denseMatrix._data;
       const asize = denseMatrix._size;
@@ -28961,7 +29335,17 @@ var createMatAlgo03xDSf = /* @__PURE__ */ factory(
       if (typeof adt === "string" && adt === bdt && adt !== "mixed") {
         dt = adt;
         zero = typed3.convert(0, dt);
-        cf = typed3.find(callback, [dt, dt]);
+        let callbacksForDt = signaturesCache.get(callback);
+        if (!callbacksForDt) {
+          callbacksForDt = /* @__PURE__ */ new Map();
+          signaturesCache.set(callback, callbacksForDt);
+        }
+        let cachedCf = callbacksForDt.get(dt);
+        if (!cachedCf) {
+          cachedCf = typed3.find(callback, [dt, dt]);
+          callbacksForDt.set(dt, cachedCf);
+        }
+        cf = cachedCf;
       }
       const cdata = [];
       for (let z = 0; z < rows; z++) {
@@ -29519,7 +29903,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);
@@ -31452,7 +31836,7 @@ var createRightLogShift = /* @__PURE__ */ factory(
       name153,
       {
         "number, number": rightLogShiftNumber,
-        // 'BigNumber, BigNumber': ..., // TODO: implement BigNumber support for rightLogShift
+        "BigNumber, BigNumber": rightLogShiftBigNumber,
         "SparseMatrix, number | BigNumber": typed3.referToSelf(
           (self) => (x, y) => {
             if (equalScalar3(y, 0)) {
@@ -34141,8 +34525,16 @@ var createPermutations = /* @__PURE__ */ factory(
           result = result.times(i);
         }
         return result;
-      }
-      // TODO: implement support for collection in permutations
+      },
+      "Array | Matrix": typed3.referToSelf(
+        (self) => (n) => deepMap(n, self)
+      ),
+      "Array | Matrix, number | BigNumber": typed3.referToSelf(
+        (self) => (n, k) => deepMap(n, (n_val) => self(n_val, k))
+      ),
+      "number | BigNumber, Array | Matrix": typed3.referToSelf(
+        (self) => (n, k) => deepMap(k, (k_val) => self(n, k_val))
+      )
     });
   }
 );
@@ -35393,13 +35785,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(
@@ -35427,7 +35827,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(
@@ -35454,7 +35854,7 @@ var createDivide = /* @__PURE__ */ factory(
             ).valueOf();
           },
           "any, Array | Matrix": function(x, y) {
-            return multiply2(x, inv3(y));
+            return multiply2(x, pinv2(y));
           }
         },
         divideScalar2.signatures
@@ -37588,7 +37988,6 @@ var dependencies218 = [
   "abs",
   "add",
   "addScalar",
-  "matrix",
   "multiply",
   "multiplyScalar",
   "divideScalar",
@@ -37608,7 +38007,6 @@ var createIntersect = /* @__PURE__ */ factory(
     abs: abs2,
     add: add5,
     addScalar: addScalar2,
-    matrix: matrix2,
     multiply: multiply2,
     multiplyScalar: multiplyScalar2,
     divideScalar: divideScalar2,
@@ -37628,7 +38026,7 @@ var createIntersect = /* @__PURE__ */ factory(
           y.valueOf(),
           plane.valueOf()
         );
-        return arr10 === null ? null : matrix2(arr10);
+        return arr10 === null ? null : x.create(arr10, x.datatype());
       },
       "Matrix, Matrix, Matrix, Matrix": function(w, x, y, z) {
         const arr10 = _AAAA(
@@ -37637,7 +38035,7 @@ var createIntersect = /* @__PURE__ */ factory(
           y.valueOf(),
           z.valueOf()
         );
-        return arr10 === null ? null : matrix2(arr10);
+        return arr10 === null ? null : w.create(arr10, w.datatype());
       }
     });
     function _AAA(x, y, plane) {
@@ -37838,6 +38236,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)));
@@ -37923,11 +38330,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());
@@ -37968,7 +38375,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) {
@@ -41924,19 +42335,30 @@ var createDerivative = /* @__PURE__ */ factory(
     SymbolNode
   }) => {
     function plainDerivative(expr, variable, options = { simplify: true }) {
-      const cache = /* @__PURE__ */ new Map();
+      const order = options.order !== void 0 ? options.order : 1;
+      if (!Number.isInteger(order) || order < 0) {
+        throw new TypeError('Option "order" must be a non-negative integer');
+      }
       const variableName = variable.name;
-      function isConstCached(node) {
-        const cached = cache.get(node);
-        if (cached !== void 0) {
-          return cached;
+      let res = expr;
+      for (let i = 0; i < order; i++) {
+        let isConstCached2 = function(node) {
+          const cached = cache.get(node);
+          if (cached !== void 0) {
+            return cached;
+          }
+          const r = _isConst(isConstCached2, node, variableName);
+          cache.set(node, r);
+          return r;
+        };
+        var isConstCached = isConstCached2;
+        const cache = /* @__PURE__ */ new Map();
+        res = _derivative(res, isConstCached2);
+        if (options.simplify !== false && i < order - 1) {
+          res = simplify2(res);
         }
-        const res2 = _isConst(isConstCached, node, variableName);
-        cache.set(node, res2);
-        return res2;
       }
-      const res = _derivative(expr, isConstCached);
-      return options.simplify ? simplify2(res) : res;
+      return options.simplify !== false ? simplify2(res) : res;
     }
     function parseIdentifier(string2) {
       const symbol = parse3(string2);
@@ -41952,16 +42374,6 @@ var createDerivative = /* @__PURE__ */ factory(
       "Node, SymbolNode, Object": plainDerivative,
       "Node, string": (node, symbol) => plainDerivative(node, parseIdentifier(symbol)),
       "Node, string, Object": (node, symbol, options) => plainDerivative(node, parseIdentifier(symbol), options)
-      /* TODO: implement and test syntax with order of derivatives -> implement as an option {order: number}
-      'Node, SymbolNode, ConstantNode': function (expr, variable, {order}) {
-        let res = expr
-        for (let i = 0; i < order; i++) {
-          <create caching isConst>
-          res = _derivative(res, isConst)
-        }
-        return res
-      }
-      */
     });
     derivative3._simplify = true;
     derivative3.toTex = function(deriv) {
@@ -41970,7 +42382,11 @@ var createDerivative = /* @__PURE__ */ factory(
     const _derivTex = typed3("_derivTex", {
       "Node, SymbolNode": function(expr, x) {
         if (isConstantNode(expr) && typeOf(expr.value) === "string") {
-          return _derivTex(parse3(expr.value).toString(), x.toString(), 1);
+          return _derivTex(
+            parse3(expr.value).toString(),
+            x.toString(),
+            1
+          );
         } else {
           return _derivTex(expr.toTex(), x.toString(), 1);
         }
@@ -42026,7 +42442,9 @@ var createDerivative = /* @__PURE__ */ factory(
         return createConstantNode2(1);
       },
       "ParenthesisNode, function": function(node, isConst2) {
-        return new ParenthesisNode(_derivative(node.content, isConst2));
+        return new ParenthesisNode(
+          _derivative(node.content, isConst2)
+        );
       },
       "FunctionAssignmentNode, function": function(node, isConst2) {
         if (isConst2(node)) {
@@ -42797,7 +43215,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;
@@ -42815,9 +43232,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++) {
@@ -43057,8 +43475,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");
@@ -43640,7 +44059,7 @@ var createNuclearMagneton = /* @__PURE__ */ unitFactory(
 var createKlitzing = /* @__PURE__ */ unitFactory("klitzing", "25812.807459304513", "ohm");
 var createJosephson = /* @__PURE__ */ unitFactory(
   "josephson",
-  "4.835978484169836e14 Hz V",
+  "4.835978484169836e14",
   "Hz V^-1"
 );
 var createBohrRadius = /* @__PURE__ */ unitFactory("bohrRadius", "5.29177210544e-11", "m");
@@ -44775,7 +45194,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
@@ -46212,15 +46630,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]);
@@ -46234,7 +46654,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]);
@@ -46273,199 +46692,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)) {