@danielsimonjr/mathts-functions 0.13.2 → 0.14.0

package/dist/index.js

@@ -1695,11 +1695,28 @@ var cube = mathTyped2("cube", {
     return out;
   }
 });
+function cbrtAllRoots(z) {
+  const arg3 = z.arg() / 3;
+  const r = Math.cbrt(z.abs());
+  const rotate2 = (theta) => new Complex(r, 0).mul(new Complex(0, theta).exp());
+  return [rotate2(arg3), rotate2(arg3 + Math.PI * 2 / 3), rotate2(arg3 - Math.PI * 2 / 3)];
+}
 var cbrt = mathTyped2("cbrt", {
   number: (a) => Math.cbrt(a),
   Complex: (a) => a.pow(1 / 3),
   BigNumber: (a) => a.cbrt(),
   Dual: (a) => a.powConst(1 / 3),
+  // Two-argument allRoots forms (mathjs parity). When `allRoots` is true, all
+  // three complex cube roots are returned (principal first); otherwise the
+  // principal complex root. The real `number` case routes through the complex
+  // path exactly like mathjs `cbrt(8, true)` → [2, -1±i√3].
+  "number, boolean": (a, allRoots) => {
+    const z = new Complex(a, 0);
+    return allRoots ? cbrtAllRoots(z) : cbrtAllRoots(z)[0];
+  },
+  "Complex, boolean": (a, allRoots) => {
+    return allRoots ? cbrtAllRoots(a) : cbrtAllRoots(a)[0];
+  },
   // Parallel array cbrt
   Float64Array: async (a) => {
     if (computePool.shouldParallelize(a.length)) {
@@ -9250,11 +9267,12 @@ function substitute(expr, vars) {
 function expand(expr) {
   let result = expr;
   result = result.replace(/\(([^()]+)\)\^2/g, "($1)*($1)");
+  const splitTerms = (factor2) => factor2.replace(/\s*-\s*/g, " + -").split(/\s*\+\s*/).map((t) => t.trim()).filter((t) => t !== "");
   const mulPattern = /\(([^()]+)\)\s*\*\s*\(([^()]+)\)/g;
   let match;
   while ((match = mulPattern.exec(result)) !== null) {
-    const leftTerms = match[1].split(/\s*\+\s*/);
-    const rightTerms = match[2].split(/\s*\+\s*/);
+    const leftTerms = splitTerms(match[1]);
+    const rightTerms = splitTerms(match[2]);
     const products = [];
     for (const l of leftTerms) {
       for (const r of rightTerms) {
@@ -17224,9 +17242,9 @@ var createExpm1 = /* @__PURE__ */ factory(
 );
 
 // src/utils/bigint.ts
-function promoteLogarithm(log162, numberLog, config, cplx) {
+function promoteLogarithm(log162, numberLog, config2, cplx) {
   return function(b) {
-    if (b > 0 || config.predictable) {
+    if (b > 0 || config2.predictable) {
       if (b <= 0) return NaN;
       const s = b.toString(16);
       const s15 = s.substring(0, 15);
@@ -17243,7 +17261,7 @@ var log16 = log10Number(16);
 var createLog10 = /* @__PURE__ */ factory(
   name6,
   dependencies6,
-  ({ typed: typed3, config, Complex: Complex12 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex12 }) => {
     function complexLog(c) {
       return c.log().div(Math.LN10);
     }
@@ -17252,16 +17270,16 @@ var createLog10 = /* @__PURE__ */ factory(
     }
     return typed3(name6, {
       number: function(x) {
-        if (x >= 0 || config.predictable) {
+        if (x >= 0 || config2.predictable) {
           return log10Number(x);
         } else {
           return complexLogNumber(x);
         }
       },
-      bigint: promoteLogarithm(log16, log10Number, config, complexLogNumber),
+      bigint: promoteLogarithm(log16, log10Number, config2, complexLogNumber),
       Complex: complexLog,
       BigNumber: function(x) {
-        if (!x.isNegative() || config.predictable) {
+        if (!x.isNegative() || config2.predictable) {
           return x.log();
         } else {
           return complexLogNumber(x.toNumber());
@@ -17280,22 +17298,22 @@ var dependencies7 = ["typed", "config", "Complex"];
 var createLog2 = /* @__PURE__ */ factory(
   name7,
   dependencies7,
-  ({ typed: typed3, config, Complex: Complex12 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex12 }) => {
     function complexLog2Number(x) {
       return _log2Complex(new Complex12(x, 0));
     }
     return typed3(name7, {
       number: function(x) {
-        if (x >= 0 || config.predictable) {
+        if (x >= 0 || config2.predictable) {
           return log2Number(x);
         } else {
           return complexLog2Number(x);
         }
       },
-      bigint: promoteLogarithm(4, log2Number, config, complexLog2Number),
+      bigint: promoteLogarithm(4, log2Number, config2, complexLog2Number),
       Complex: _log2Complex,
       BigNumber: function(x) {
-        if (!x.isNegative() || config.predictable) {
+        if (!x.isNegative() || config2.predictable) {
           return x.log(2);
         } else {
           return complexLog2Number(x.toNumber());
@@ -17383,14 +17401,14 @@ var dependencies10 = ["config", "typed", "Complex"];
 var createSqrt = /* @__PURE__ */ factory(
   name10,
   dependencies10,
-  ({ config, typed: typed3, Complex: Complex12 }) => {
+  ({ config: config2, typed: typed3, Complex: Complex12 }) => {
     return typed3("sqrt", {
       number: _sqrtNumber,
       Complex: function(x) {
         return x.sqrt();
       },
       BigNumber: function(x) {
-        if (!x.isNegative() || config.predictable) {
+        if (!x.isNegative() || config2.predictable) {
           return x.sqrt();
         } else {
           return _sqrtNumber(x.toNumber());
@@ -17403,7 +17421,7 @@ var createSqrt = /* @__PURE__ */ factory(
     function _sqrtNumber(x) {
       if (isNaN(x)) {
         return NaN;
-      } else if (x >= 0 || config.predictable) {
+      } else if (x >= 0 || config2.predictable) {
         return Math.sqrt(x);
       } else {
         return new Complex12(x, 0).sqrt();
@@ -17486,7 +17504,7 @@ var dependencies13 = ["typed", "config", "?bignumber"];
 var createUnaryMinus = /* @__PURE__ */ factory(
   name13,
   dependencies13,
-  ({ typed: typed3, config, bignumber: bignumber2 }) => {
+  ({ typed: typed3, config: config2, bignumber: bignumber2 }) => {
     return typed3(name13, {
       number: unaryMinusNumber,
       "Complex | BigNumber | Fraction": (x) => x.neg(),
@@ -17499,7 +17517,7 @@ var createUnaryMinus = /* @__PURE__ */ factory(
       boolean: function(x) {
         const numValue = x ? 1 : 0;
         const negValue = -numValue;
-        const numberType = config?.number || "number";
+        const numberType = config2?.number || "number";
         switch (numberType) {
           case "BigNumber":
             if (!bignumber2) {
@@ -18534,8 +18552,8 @@ var dependencies30 = ["typed", "config", "?on"];
 var createPickRandom = /* @__PURE__ */ factory(
   name30,
   dependencies30,
-  ({ typed: typed3, config, on }) => {
-    let rng = createRng(config.randomSeed);
+  ({ typed: typed3, config: config2, on }) => {
+    let rng = createRng(config2.randomSeed);
     if (on) {
       on("config", function(curr, prev) {
         if (curr.randomSeed !== prev.randomSeed) {
@@ -18635,8 +18653,8 @@ var dependencies31 = ["typed", "config", "?on"];
 var createRandom = /* @__PURE__ */ factory(
   name31,
   dependencies31,
-  ({ typed: typed3, config, on }) => {
-    let rng = createRng(config.randomSeed);
+  ({ typed: typed3, config: config2, on }) => {
+    let rng = createRng(config2.randomSeed);
     if (on) {
       on("config", function(curr, prev) {
         if (curr.randomSeed !== prev.randomSeed) {
@@ -18715,7 +18733,7 @@ var dependencies32 = ["typed", "config"];
 var createEqualScalar = /* @__PURE__ */ factory(
   name32,
   dependencies32,
-  ({ typed: typed3, config }) => {
+  ({ typed: typed3, config: config2 }) => {
     const compareUnits2 = createCompareUnits({ typed: typed3 });
     return typed3(
       name32,
@@ -18724,10 +18742,10 @@ var createEqualScalar = /* @__PURE__ */ factory(
           return x === y;
         },
         "number, number": function(x, y) {
-          return nearlyEqual(x, y, config.relTol, config.absTol);
+          return nearlyEqual(x, y, config2.relTol, config2.absTol);
         },
         "BigNumber, BigNumber": function(x, y) {
-          return x.eq(y) || nearlyEqual2(x, y, config.relTol, config.absTol);
+          return x.eq(y) || nearlyEqual2(x, y, config2.relTol, config2.absTol);
         },
         "bigint, bigint": function(x, y) {
           return x === y;
@@ -18736,7 +18754,7 @@ var createEqualScalar = /* @__PURE__ */ factory(
           return x.equals(y);
         },
         "Complex, Complex": function(x, y) {
-          return complexEquals(x, y, config.relTol, config.absTol);
+          return complexEquals(x, y, config2.relTol, config2.absTol);
         }
       },
       compareUnits2
@@ -18941,10 +18959,10 @@ var dependencies36 = ["typed", "config", "Complex"];
 var createAcos = /* @__PURE__ */ factory(
   name36,
   dependencies36,
-  ({ typed: typed3, config, Complex: Complex12 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex12 }) => {
     return typed3(name36, {
       number: function(x) {
-        if (x >= -1 && x <= 1 || config.predictable) {
+        if (x >= -1 && x <= 1 || config2.predictable) {
           return Math.acos(x);
         } else {
           return new Complex12(x, 0).acos();
@@ -18966,10 +18984,10 @@ var dependencies37 = ["typed", "config", "Complex"];
 var createAcosh = /* @__PURE__ */ factory(
   name37,
   dependencies37,
-  ({ typed: typed3, config, Complex: Complex12 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex12 }) => {
     return typed3(name37, {
       number: function(x) {
-        if (x >= 1 || config.predictable) {
+        if (x >= 1 || config2.predictable) {
           return acoshNumber(x);
         }
         if (x <= -1) {
@@ -19012,10 +19030,10 @@ var dependencies39 = ["typed", "config", "Complex", "BigNumber"];
 var createAcoth = /* @__PURE__ */ factory(
   name39,
   dependencies39,
-  ({ typed: typed3, config, Complex: Complex12, BigNumber: BigNumber9 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex12, BigNumber: BigNumber9 }) => {
     return typed3(name39, {
       number: function(x) {
-        if (x >= 1 || x <= -1 || config.predictable) {
+        if (x >= 1 || x <= -1 || config2.predictable) {
           return acothNumber(x);
         }
         return new Complex12(x, 0).acoth();
@@ -19036,10 +19054,10 @@ var dependencies40 = ["typed", "config", "Complex", "BigNumber"];
 var createAcsc = /* @__PURE__ */ factory(
   name40,
   dependencies40,
-  ({ typed: typed3, config, Complex: Complex12, BigNumber: BigNumber9 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex12, BigNumber: BigNumber9 }) => {
     return typed3(name40, {
       number: function(x) {
-        if (x <= -1 || x >= 1 || config.predictable) {
+        if (x <= -1 || x >= 1 || config2.predictable) {
           return acscNumber(x);
         }
         return new Complex12(x, 0).acsc();
@@ -19079,10 +19097,10 @@ var dependencies42 = ["typed", "config", "Complex", "BigNumber"];
 var createAsec = /* @__PURE__ */ factory(
   name42,
   dependencies42,
-  ({ typed: typed3, config, Complex: Complex12, BigNumber: BigNumber9 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex12, BigNumber: BigNumber9 }) => {
     return typed3(name42, {
       number: function(x) {
-        if (x <= -1 || x >= 1 || config.predictable) {
+        if (x <= -1 || x >= 1 || config2.predictable) {
           return asecNumber(x);
         }
         return new Complex12(x, 0).asec();
@@ -19103,12 +19121,12 @@ var dependencies43 = ["typed", "config", "Complex", "BigNumber"];
 var createAsech = /* @__PURE__ */ factory(
   name43,
   dependencies43,
-  ({ typed: typed3, config, Complex: Complex12, BigNumber: BigNumber9 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex12, BigNumber: BigNumber9 }) => {
     return typed3(name43, {
       number: function(x) {
-        if (x <= 1 && x >= -1 || config.predictable) {
+        if (x <= 1 && x >= -1 || config2.predictable) {
           const xInv = 1 / x;
-          if (xInv > 0 || config.predictable) {
+          if (xInv > 0 || config2.predictable) {
             return asechNumber(x);
           }
           const ret = Math.sqrt(xInv * xInv - 1);
@@ -19132,10 +19150,10 @@ var dependencies44 = ["typed", "config", "Complex"];
 var createAsin = /* @__PURE__ */ factory(
   name44,
   dependencies44,
-  ({ typed: typed3, config, Complex: Complex12 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex12 }) => {
     return typed3(name44, {
       number: function(x) {
-        if (x >= -1 && x <= 1 || config.predictable) {
+        if (x >= -1 && x <= 1 || config2.predictable) {
           return Math.asin(x);
         } else {
           return new Complex12(x, 0).asin();
@@ -19197,10 +19215,10 @@ var dependencies47 = ["typed", "config", "Complex"];
 var createAtanh = /* @__PURE__ */ factory(
   name47,
   dependencies47,
-  ({ typed: typed3, config, Complex: Complex12 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex12 }) => {
     return typed3(name47, {
       number: function(x) {
-        if (x <= 1 && x >= -1 || config.predictable) {
+        if (x <= 1 && x >= -1 || config2.predictable) {
           return atanhNumber(x);
         }
         return new Complex12(x, 0).atanh();
@@ -19526,10 +19544,10 @@ var dependencies64 = ["typed", "config"];
 var createIsNegative = /* @__PURE__ */ factory(
   name64,
   dependencies64,
-  ({ typed: typed3, config }) => {
+  ({ typed: typed3, config: config2 }) => {
     return typed3(name64, {
-      number: (x) => nearlyEqual(x, 0, config.relTol, config.absTol) ? false : isNegativeNumber(x),
-      BigNumber: (x) => nearlyEqual2(x, new x.constructor(0), config.relTol, config.absTol) ? false : x.isNeg() && !x.isZero() && !x.isNaN(),
+      number: (x) => nearlyEqual(x, 0, config2.relTol, config2.absTol) ? false : isNegativeNumber(x),
+      BigNumber: (x) => nearlyEqual2(x, new x.constructor(0), config2.relTol, config2.absTol) ? false : x.isNeg() && !x.isZero() && !x.isNaN(),
       bigint: (x) => x < 0n,
       Fraction: (x) => x.s < 0n,
       // It's enough to decide on the sign
@@ -19566,10 +19584,10 @@ var dependencies66 = ["typed", "config"];
 var createIsPositive = /* @__PURE__ */ factory(
   name66,
   dependencies66,
-  ({ typed: typed3, config }) => {
+  ({ typed: typed3, config: config2 }) => {
     return typed3(name66, {
-      number: (x) => nearlyEqual(x, 0, config.relTol, config.absTol) ? false : isPositiveNumber(x),
-      BigNumber: (x) => nearlyEqual2(x, new x.constructor(0), config.relTol, config.absTol) ? false : !x.isNeg() && !x.isZero() && !x.isNaN(),
+      number: (x) => nearlyEqual(x, 0, config2.relTol, config2.absTol) ? false : isPositiveNumber(x),
+      BigNumber: (x) => nearlyEqual2(x, new x.constructor(0), config2.relTol, config2.absTol) ? false : !x.isNeg() && !x.isZero() && !x.isNaN(),
       bigint: (x) => x > 0n,
       Fraction: (x) => x.s > 0n && x.n > 0n,
       Unit: typed3.referToSelf(
@@ -19788,7 +19806,7 @@ var dependencies71 = ["typed", "config", "numeric"];
 var createUnaryPlus = /* @__PURE__ */ factory(
   name71,
   dependencies71,
-  ({ typed: typed3, config, numeric: numeric2 }) => {
+  ({ typed: typed3, config: config2, numeric: numeric2 }) => {
     return typed3(name71, {
       number: unaryPlusNumber,
       Complex: function(x) {
@@ -19811,10 +19829,10 @@ var createUnaryPlus = /* @__PURE__ */ factory(
         (self) => (x) => deepMap2(x, self, true)
       ),
       boolean: function(x) {
-        return numeric2(x ? 1 : 0, config.number);
+        return numeric2(x ? 1 : 0, config2.number);
       },
       string: function(x) {
-        return numeric2(x, safeNumberType(x, config));
+        return numeric2(x, safeNumberType(x, config2));
       }
     });
   }
@@ -19944,8 +19962,8 @@ var dependencies73 = ["typed", "config", "log2", "?on"];
 var createRandomInt = /* @__PURE__ */ factory(
   name73,
   dependencies73,
-  ({ typed: typed3, config, log2: log23, on }) => {
-    let rng = createRng(config.randomSeed);
+  ({ typed: typed3, config: config2, log2: log23, on }) => {
+    let rng = createRng(config2.randomSeed);
     if (on) {
       on("config", function(curr, prev) {
         if (curr.randomSeed !== prev.randomSeed) {
@@ -20237,12 +20255,12 @@ var dependencies82 = ["config", "?bignumber"];
 var createParseNumberWithConfig = /* @__PURE__ */ factory(
   name82,
   dependencies82,
-  ({ config, bignumber: bignumber2 }) => {
+  ({ config: config2, bignumber: bignumber2 }) => {
     function parseNumberWithConfig2(str) {
       if (typeof str !== "string") {
         throw new TypeError(`parseNumberWithConfig expects string, got ${typeof str}`);
       }
-      const numberType = config.number || "number";
+      const numberType = config2.number || "number";
       switch (numberType) {
         case "BigNumber":
           if (!bignumber2) {
@@ -20457,22 +20475,22 @@ var dependencies85 = ["typed", "config", "matrix", "BigNumber", "DenseMatrix", "
 var createIdentity = /* @__PURE__ */ factory(
   name85,
   dependencies85,
-  ({ typed: typed3, config, matrix: matrix2, BigNumber: BigNumber9, DenseMatrix: DenseMatrix6, SparseMatrix }) => {
+  ({ typed: typed3, config: config2, matrix: matrix2, BigNumber: BigNumber9, DenseMatrix: DenseMatrix6, SparseMatrix }) => {
     return typed3(name85, {
       "": function() {
-        return config.matrix === "Matrix" ? matrix2([]) : [];
+        return config2.matrix === "Matrix" ? matrix2([]) : [];
       },
       string: function(format6) {
         return matrix2(format6);
       },
       "number | BigNumber": function(rows) {
-        return _identity(rows, rows, config.matrix === "Matrix" ? "dense" : void 0);
+        return _identity(rows, rows, config2.matrix === "Matrix" ? "dense" : void 0);
       },
       "number | BigNumber, string": function(rows, format6) {
         return _identity(rows, rows, format6);
       },
       "number | BigNumber, number | BigNumber": function(rows, cols) {
-        return _identity(rows, cols, config.matrix === "Matrix" ? "dense" : void 0);
+        return _identity(rows, cols, config2.matrix === "Matrix" ? "dense" : void 0);
       },
       "number | BigNumber, number | BigNumber, string": function(rows, cols, format6) {
         return _identity(rows, cols, format6);
@@ -20535,10 +20553,10 @@ var createIdentity = /* @__PURE__ */ factory(
 );
 
 // src/matrix/utils/zerosAndOnes.ts
-function createZerosAndOnes(name254, defaultValue, { typed: typed3, config, matrix: matrix2, BigNumber: BigNumber9 }) {
+function createZerosAndOnes(name254, defaultValue, { typed: typed3, config: config2, matrix: matrix2, BigNumber: BigNumber9 }) {
   return typed3(name254, {
     "": function() {
-      return config.matrix === "Array" ? _zerosAndOnes([]) : _zerosAndOnes([], "default");
+      return config2.matrix === "Array" ? _zerosAndOnes([]) : _zerosAndOnes([], "default");
     },
     // math.zeros/ones(m, n, p, ..., format)
     // TODO: more accurate signature '...number | BigNumber, string' as soon as typed-function supports this
@@ -20547,7 +20565,7 @@ function createZerosAndOnes(name254, defaultValue, { typed: typed3, config, matr
       if (typeof last === "string") {
         const format6 = size2.pop();
         return _zerosAndOnes(size2, format6);
-      } else if (config.matrix === "Array") {
+      } else if (config2.matrix === "Array") {
         return _zerosAndOnes(size2);
       } else {
         return _zerosAndOnes(size2, "default");
@@ -23027,7 +23045,7 @@ var createCbrt = /* @__PURE__ */ factory(
   name105,
   dependencies105,
   ({
-    config,
+    config: config2,
     typed: typed3,
     isNegative: isNegative2,
     unaryMinus: unaryMinus2,
@@ -23038,8 +23056,14 @@ var createCbrt = /* @__PURE__ */ factory(
   }) => {
     return typed3(name105, {
       number: cbrtNumber,
-      // note: signature 'number, boolean' is also supported,
-      //       created by typed as it knows how to convert number to Complex
+      // The two-argument real form. mathjs assumes typed-function synthesizes
+      // this from `Complex, boolean` via a number→Complex conversion, but the
+      // MathTS typed instance does not, so it is registered explicitly: route
+      // through the complex cube-root path (all three roots when allRoots, the
+      // principal Complex root otherwise) — matching mathjs `cbrt(8, true)`.
+      "number, boolean": function(x, allRoots) {
+        return _cbrtComplex(new Complex12(x, 0), allRoots);
+      },
       Complex: _cbrtComplex,
       "Complex, boolean": _cbrtComplex,
       BigNumber: function(x) {
@@ -23057,7 +23081,7 @@ var createCbrt = /* @__PURE__ */ factory(
           new Complex12(cbrtNumber(abs2), 0).mul(new Complex12(0, arg3 + Math.PI * 2 / 3).exp()),
           new Complex12(cbrtNumber(abs2), 0).mul(new Complex12(0, arg3 - Math.PI * 2 / 3).exp())
         ];
-        return config.matrix === "Array" ? all : matrix2(all);
+        return config2.matrix === "Array" ? all : matrix2(all);
       } else {
         return principal;
       }
@@ -23333,7 +23357,7 @@ var dependencies110 = [
 var createRound = /* @__PURE__ */ factory(
   name110,
   dependencies110,
-  ({ typed: typed3, config, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros2, BigNumber: BigNumber9, DenseMatrix: DenseMatrix6 }) => {
+  ({ typed: typed3, config: config2, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros2, BigNumber: BigNumber9, DenseMatrix: DenseMatrix6 }) => {
     const matAlgo11xS0s = createMatAlgo11xS0s({ typed: typed3, equalScalar: equalScalar3 });
     const matAlgo12xSfs = createMatAlgo12xSfs({ typed: typed3, DenseMatrix: DenseMatrix6 });
     const matAlgo14xDs = createMatAlgo14xDs({ typed: typed3 });
@@ -23342,17 +23366,17 @@ var createRound = /* @__PURE__ */ factory(
     }
     return typed3(name110, {
       number: function(x) {
-        const xEpsilon = roundNumber(x, toExponent(config.relTol));
-        const xSelected = nearlyEqual(x, xEpsilon, config.relTol, config.absTol) ? xEpsilon : x;
+        const xEpsilon = roundNumber(x, toExponent(config2.relTol));
+        const xSelected = nearlyEqual(x, xEpsilon, config2.relTol, config2.absTol) ? xEpsilon : x;
         return roundNumber(xSelected);
       },
       "number, number": function(x, n) {
-        const epsilonExponent = toExponent(config.relTol);
+        const epsilonExponent = toExponent(config2.relTol);
         if (n >= epsilonExponent) {
           return roundNumber(x, n);
         }
         const xEpsilon = roundNumber(x, epsilonExponent);
-        const xSelected = nearlyEqual(x, xEpsilon, config.relTol, config.absTol) ? xEpsilon : x;
+        const xSelected = nearlyEqual(x, xEpsilon, config2.relTol, config2.absTol) ? xEpsilon : x;
         return roundNumber(xSelected, n);
       },
       "number, BigNumber": function(x, n) {
@@ -23378,20 +23402,20 @@ var createRound = /* @__PURE__ */ factory(
         return x.round(_n);
       },
       BigNumber: function(x) {
-        const xEpsilon = new BigNumber9(x).toDecimalPlaces(toExponent(config.relTol));
-        const xSelected = nearlyEqual2(x, xEpsilon, config.relTol, config.absTol) ? xEpsilon : x;
+        const xEpsilon = new BigNumber9(x).toDecimalPlaces(toExponent(config2.relTol));
+        const xSelected = nearlyEqual2(x, xEpsilon, config2.relTol, config2.absTol) ? xEpsilon : x;
         return xSelected.toDecimalPlaces(0);
       },
       "BigNumber, BigNumber": function(x, n) {
         if (!n.isInteger()) {
           throw new TypeError(NO_INT);
         }
-        const epsilonExponent = toExponent(config.relTol);
+        const epsilonExponent = toExponent(config2.relTol);
         if (n >= epsilonExponent) {
           return x.toDecimalPlaces(n.toNumber());
         }
         const xEpsilon = x.toDecimalPlaces(epsilonExponent);
-        const xSelected = nearlyEqual2(x, xEpsilon, config.relTol, config.absTol) ? xEpsilon : x;
+        const xSelected = nearlyEqual2(x, xEpsilon, config2.relTol, config2.absTol) ? xEpsilon : x;
         return xSelected.toDecimalPlaces(n.toNumber());
       },
       // bigints can't be rounded
@@ -23481,11 +23505,11 @@ var dependencies111 = ["typed", "config", "matrix", "BigNumber"];
 var createXgcd = /* @__PURE__ */ factory(
   name111,
   dependencies111,
-  ({ typed: typed3, config, matrix: matrix2, BigNumber: BigNumber9 }) => {
+  ({ typed: typed3, config: config2, matrix: matrix2, BigNumber: BigNumber9 }) => {
     return typed3(name111, {
       "number, number": function(a, b) {
         const res = xgcdNumber(a, b);
-        return config.matrix === "Array" ? res : matrix2(res);
+        return config2.matrix === "Array" ? res : matrix2(res);
       },
       "BigNumber, BigNumber": _xgcdBigNumber
       // TODO: implement support for Fraction
@@ -23521,7 +23545,7 @@ var createXgcd = /* @__PURE__ */ factory(
       } else {
         res = [a, !a.isZero() ? lastx : 0, lasty];
       }
-      return config.matrix === "Array" ? res : matrix2(res);
+      return config2.matrix === "Array" ? res : matrix2(res);
     }
   }
 );
@@ -23533,7 +23557,7 @@ var nlg16 = Math.log(16);
 var createLog = /* @__PURE__ */ factory(
   name112,
   dependencies112,
-  ({ typed: typed3, typeOf: typeOf3, config, divideScalar: divideScalar2, Complex: Complex12 }) => {
+  ({ typed: typed3, typeOf: typeOf3, config: config2, divideScalar: divideScalar2, Complex: Complex12 }) => {
     function complexLog(c) {
       return c.log();
     }
@@ -23542,16 +23566,16 @@ var createLog = /* @__PURE__ */ factory(
     }
     return typed3(name112, {
       number: function(x) {
-        if (x >= 0 || config.predictable) {
+        if (x >= 0 || config2.predictable) {
           return logNumber(x);
         } else {
           return complexLogNumber(x);
         }
       },
-      bigint: promoteLogarithm(nlg16, logNumber, config, complexLogNumber),
+      bigint: promoteLogarithm(nlg16, logNumber, config2, complexLogNumber),
       Complex: complexLog,
       BigNumber: function(x) {
-        if (!x.isNegative() || config.predictable) {
+        if (!x.isNegative() || config2.predictable) {
           return x.ln();
         } else {
           return complexLogNumber(x.toNumber());
@@ -23939,7 +23963,7 @@ var dependencies117 = ["typed", "config", "matrix"];
 var createResize = /* @__PURE__ */ factory(
   name117,
   dependencies117,
-  ({ typed: typed3, config, matrix: matrix2 }) => {
+  ({ typed: typed3, config: config2, matrix: matrix2 }) => {
     return typed3(name117, {
       "any, Array | Matrix": function(x, size2) {
         return _resize2(x, size2);
@@ -23961,7 +23985,7 @@ var createResize = /* @__PURE__ */ factory(
       if (typeof x === "string") {
         return _resizeString(x, sz, defaultValue);
       }
-      const asMatrix = Array.isArray(x) ? false : config.matrix !== "Array";
+      const asMatrix = Array.isArray(x) ? false : config2.matrix !== "Array";
       if (sz.length === 0) {
         let scalar = x;
         while (Array.isArray(scalar)) {
@@ -24260,7 +24284,7 @@ var createBernoulli = /* @__PURE__ */ factory(
   dependencies119,
   ({
     typed: typed3,
-    config,
+    config: config2,
     isInteger: _isInteger,
     number: number2,
     BigNumber: BigNumber9,
@@ -24288,9 +24312,9 @@ var createBernoulli = /* @__PURE__ */ factory(
         (a, b) => a.div(b)
       ),
       BigNumber: (index) => {
-        if (config.precision !== cachedPrecision) {
+        if (config2.precision !== cachedPrecision) {
           bigCache = [void 0];
-          cachedPrecision = config.precision;
+          cachedPrecision = config2.precision;
         }
         return _bernoulli(
           number2(index),
@@ -24995,7 +25019,7 @@ var dependencies128 = ["typed", "config", "add", "numeric", "parseNumberWithConf
 var createSum = /* @__PURE__ */ factory(
   name128,
   dependencies128,
-  ({ typed: typed3, config, add: add2, numeric: numeric2, parseNumberWithConfig: parseNumberWithConfig2 }) => {
+  ({ typed: typed3, config: config2, add: add2, numeric: numeric2, parseNumberWithConfig: parseNumberWithConfig2 }) => {
     return typed3(name128, {
       // sum(string) - single string input
       string: function(x) {
@@ -25040,7 +25064,7 @@ var createSum = /* @__PURE__ */ factory(
         }
       });
       if (sum3 === void 0) {
-        sum3 = numeric2(0, config.number);
+        sum3 = numeric2(0, config2.number);
       }
       return sum3;
     }
@@ -25289,12 +25313,12 @@ var bigTen = new Decimal(10);
 var createFloorNumber = /* @__PURE__ */ factory(
   name133,
   ["typed", "config", "round"],
-  ({ typed: typed3, config, round: round2 }) => {
+  ({ typed: typed3, config: config2, round: round2 }) => {
     function _floorNumber(x) {
       const f = Math.floor(x);
       const r = round2(x);
       if (f === r) return f;
-      if (nearlyEqual(x, r, config.relTol, config.absTol) && !nearlyEqual(x, f, config.relTol, config.absTol)) {
+      if (nearlyEqual(x, r, config2.relTol, config2.absTol) && !nearlyEqual(x, f, config2.relTol, config2.absTol)) {
         return r;
       }
       return f;
@@ -25317,13 +25341,13 @@ var createFloorNumber = /* @__PURE__ */ factory(
 var createFloor = /* @__PURE__ */ factory(
   name133,
   dependencies133,
-  ({ typed: typed3, config, round: round2, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros2, DenseMatrix: DenseMatrix6 }) => {
+  ({ typed: typed3, config: config2, round: round2, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros2, DenseMatrix: DenseMatrix6 }) => {
     const matAlgo11xS0s = createMatAlgo11xS0s({ typed: typed3, equalScalar: equalScalar3 });
     const matAlgo12xSfs = createMatAlgo12xSfs({ typed: typed3, DenseMatrix: DenseMatrix6 });
     const matAlgo14xDs = createMatAlgo14xDs({ typed: typed3 });
-    const floorNumber = createFloorNumber({ typed: typed3, config, round: round2 });
+    const floorNumber = createFloorNumber({ typed: typed3, config: config2, round: round2 });
     function _bigFloor(x) {
-      const bne = (a, b) => nearlyEqual2(a, b, config.relTol, config.absTol);
+      const bne = (a, b) => nearlyEqual2(a, b, config2.relTol, config2.absTol);
       const f = x.floor();
       const r = round2(x);
       if (f.eq(r)) return f;
@@ -25530,10 +25554,10 @@ var dependencies135 = [
 var createMod = /* @__PURE__ */ factory(
   name135,
   dependencies135,
-  ({ typed: typed3, config, round: round2, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros2, DenseMatrix: DenseMatrix6, concat: concat3 }) => {
+  ({ typed: typed3, config: config2, round: round2, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros2, DenseMatrix: DenseMatrix6, concat: concat3 }) => {
     const floor2 = createFloor({
       typed: typed3,
-      config,
+      config: config2,
       round: round2,
       matrix: matrix2,
       equalScalar: equalScalar3,
@@ -25831,7 +25855,7 @@ var createGcd = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     matrix: matrix2,
-    config,
+    config: config2,
     round: round2,
     equalScalar: equalScalar3,
     zeros: zeros2,
@@ -25841,7 +25865,7 @@ var createGcd = /* @__PURE__ */ factory(
   }) => {
     const mod2 = createMod({
       typed: typed3,
-      config,
+      config: config2,
       round: round2,
       matrix: matrix2,
       equalScalar: equalScalar3,
@@ -26098,10 +26122,10 @@ var dependencies142 = ["typed", "config", "divideScalar", "log", "Complex"];
 var createLog1p = /* @__PURE__ */ factory(
   name142,
   dependencies142,
-  ({ typed: typed3, config, divideScalar: divideScalar2, log: log3, Complex: Complex12 }) => {
+  ({ typed: typed3, config: config2, divideScalar: divideScalar2, log: log3, Complex: Complex12 }) => {
     return typed3(name142, {
       number: function(x) {
-        if (x >= -1 || config.predictable) {
+        if (x >= -1 || config2.predictable) {
           return log1p2(x);
         } else {
           return _log1pComplex(new Complex12(x, 0));
@@ -26110,7 +26134,7 @@ var createLog1p = /* @__PURE__ */ factory(
       Complex: _log1pComplex,
       BigNumber: function(x) {
         const y = x.plus(1);
-        if (!y.isNegative() || config.predictable) {
+        if (!y.isNegative() || config2.predictable) {
           return y.ln();
         } else {
           return _log1pComplex(new Complex12(x.toNumber(), 0));
@@ -26272,7 +26296,7 @@ var createPow = /* @__PURE__ */ factory(
   dependencies144,
   ({
     typed: typed3,
-    config,
+    config: config2,
     identity: identity2,
     multiply: multiply2,
     matrix: matrix2,
@@ -26287,7 +26311,7 @@ var createPow = /* @__PURE__ */ factory(
         return x.pow(y);
       },
       "BigNumber, BigNumber": function(x, y) {
-        if (y.isInteger() || x.gte(0) || config.predictable) {
+        if (y.isInteger() || x.gte(0) || config2.predictable) {
           return x.pow(y);
         } else {
           return new Complex12(x.toNumber(), 0).pow(y.toNumber(), 0);
@@ -26299,7 +26323,7 @@ var createPow = /* @__PURE__ */ factory(
         if (result != null) {
           return result;
         }
-        if (config.predictable) {
+        if (config2.predictable) {
           throw new Error("Result of pow is non-rational and cannot be expressed as a fraction");
         } else {
           return _pow(x.valueOf(), y.valueOf());
@@ -26318,7 +26342,7 @@ var createPow = /* @__PURE__ */ factory(
       }
     });
     function _pow(x, y) {
-      if (config.predictable && !isInteger(y) && x < 0) {
+      if (config2.predictable && !isInteger(y) && x < 0) {
         try {
           const yFrac = fraction2(y);
           const yNum = number2(yFrac);
@@ -26330,10 +26354,10 @@ var createPow = /* @__PURE__ */ factory(
         } catch {
         }
       }
-      if (config.predictable && (x < -1 && y === Infinity || x > -1 && x < 0 && y === -Infinity)) {
+      if (config2.predictable && (x < -1 && y === Infinity || x > -1 && x < 0 && y === -Infinity)) {
         return NaN;
       }
-      if (isInteger(y) || x >= 0 || config.predictable) {
+      if (isInteger(y) || x >= 0 || config2.predictable) {
         return powNumber(x, y);
       } else {
         if (isPowZeroAtInfinity(x, y)) {
@@ -26390,12 +26414,12 @@ var bigTen2 = new Decimal2(10);
 var createCeilNumber = /* @__PURE__ */ factory(
   name145,
   ["typed", "config", "round"],
-  ({ typed: typed3, config, round: round2 }) => {
+  ({ typed: typed3, config: config2, round: round2 }) => {
     function _ceilNumber(x) {
       const c = Math.ceil(x);
       const r = round2(x);
       if (c === r) return c;
-      if (nearlyEqual(x, r, config.relTol, config.absTol) && !nearlyEqual(x, c, config.relTol, config.absTol)) {
+      if (nearlyEqual(x, r, config2.relTol, config2.absTol) && !nearlyEqual(x, c, config2.relTol, config2.absTol)) {
         return r;
       }
       return c;
@@ -26418,13 +26442,13 @@ var createCeilNumber = /* @__PURE__ */ factory(
 var createCeil = /* @__PURE__ */ factory(
   name145,
   dependencies145,
-  ({ typed: typed3, config, round: round2, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros2, DenseMatrix: DenseMatrix6 }) => {
+  ({ typed: typed3, config: config2, round: round2, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros2, DenseMatrix: DenseMatrix6 }) => {
     const matAlgo11xS0s = createMatAlgo11xS0s({ typed: typed3, equalScalar: equalScalar3 });
     const matAlgo12xSfs = createMatAlgo12xSfs({ typed: typed3, DenseMatrix: DenseMatrix6 });
     const matAlgo14xDs = createMatAlgo14xDs({ typed: typed3 });
-    const ceilNumber = createCeilNumber({ typed: typed3, config, round: round2 });
+    const ceilNumber = createCeilNumber({ typed: typed3, config: config2, round: round2 });
     function _bigCeil(x) {
-      const bne = (a, b) => nearlyEqual2(a, b, config.relTol, config.absTol);
+      const bne = (a, b) => nearlyEqual2(a, b, config2.relTol, config2.absTol);
       const c = x.ceil();
       const r = round2(x);
       if (c.eq(r)) return c;
@@ -27030,7 +27054,7 @@ var createCompare = /* @__PURE__ */ factory(
   dependencies155,
   ({
     typed: typed3,
-    config,
+    config: config2,
     equalScalar: equalScalar3,
     matrix: matrix2,
     BigNumber: BigNumber9,
@@ -27049,13 +27073,13 @@ var createCompare = /* @__PURE__ */ factory(
     const compareUnits2 = createCompareUnits({ typed: typed3 });
     return typed3(
       name155,
-      createCompareNumber({ typed: typed3, config }),
+      createCompareNumber({ typed: typed3, config: config2 }),
       {
         "boolean, boolean": function(x, y) {
           return x === y ? 0 : x > y ? 1 : -1;
         },
         "BigNumber, BigNumber": function(x, y) {
-          return nearlyEqual2(x, y, config.relTol, config.absTol) ? new BigNumber9(0) : new BigNumber9(x.cmp(y));
+          return nearlyEqual2(x, y, config2.relTol, config2.absTol) ? new BigNumber9(0) : new BigNumber9(x.cmp(y));
         },
         "bigint, bigint": function(x, y) {
           return x === y ? 0n : x > y ? 1n : -1n;
@@ -27079,10 +27103,10 @@ var createCompare = /* @__PURE__ */ factory(
 var createCompareNumber = /* @__PURE__ */ factory(
   name155,
   ["typed", "config"],
-  ({ typed: typed3, config }) => {
+  ({ typed: typed3, config: config2 }) => {
     return typed3(name155, {
       "number, number": function(x, y) {
-        return nearlyEqual(x, y, config.relTol, config.absTol) ? 0 : x > y ? 1 : -1;
+        return nearlyEqual(x, y, config2.relTol, config2.absTol) ? 0 : x > y ? 1 : -1;
       }
     });
   }
@@ -27165,7 +27189,7 @@ var dependencies158 = [
 var createLarger = /* @__PURE__ */ factory(
   name158,
   dependencies158,
-  ({ typed: typed3, config, bignumber: bignumber2, matrix: matrix2, DenseMatrix: DenseMatrix6, concat: concat3, SparseMatrix }) => {
+  ({ typed: typed3, config: config2, bignumber: bignumber2, matrix: matrix2, DenseMatrix: DenseMatrix6, concat: concat3, SparseMatrix }) => {
     const matAlgo03xDSf = createMatAlgo03xDSf({ typed: typed3 });
     const matAlgo07xSSf = createMatAlgo07xSSf({ typed: typed3, SparseMatrix });
     const matAlgo12xSfs = createMatAlgo12xSfs({ typed: typed3, DenseMatrix: DenseMatrix6 });
@@ -27176,11 +27200,11 @@ var createLarger = /* @__PURE__ */ factory(
     });
     const compareUnits2 = createCompareUnits({ typed: typed3 });
     function bignumLarger(x, y) {
-      return x.gt(y) && !nearlyEqual2(x, y, config.relTol, config.absTol);
+      return x.gt(y) && !nearlyEqual2(x, y, config2.relTol, config2.absTol);
     }
     return typed3(
       name158,
-      createLargerNumber({ typed: typed3, config }),
+      createLargerNumber({ typed: typed3, config: config2 }),
       {
         "boolean, boolean": (x, y) => x > y,
         "BigNumber, BigNumber": bignumLarger,
@@ -27208,10 +27232,10 @@ var createLarger = /* @__PURE__ */ factory(
 var createLargerNumber = /* @__PURE__ */ factory(
   name158,
   ["typed", "config"],
-  ({ typed: typed3, config }) => {
+  ({ typed: typed3, config: config2 }) => {
     return typed3(name158, {
       "number, number": function(x, y) {
-        return x > y && !nearlyEqual(x, y, config.relTol, config.absTol);
+        return x > y && !nearlyEqual(x, y, config2.relTol, config2.absTol);
       }
     });
   }
@@ -27223,7 +27247,7 @@ var dependencies159 = ["typed", "config", "matrix", "DenseMatrix", "concat", "Sp
 var createLargerEq = /* @__PURE__ */ factory(
   name159,
   dependencies159,
-  ({ typed: typed3, config, matrix: matrix2, DenseMatrix: DenseMatrix6, concat: concat3, SparseMatrix }) => {
+  ({ typed: typed3, config: config2, matrix: matrix2, DenseMatrix: DenseMatrix6, concat: concat3, SparseMatrix }) => {
     const matAlgo03xDSf = createMatAlgo03xDSf({ typed: typed3 });
     const matAlgo07xSSf = createMatAlgo07xSSf({ typed: typed3, SparseMatrix });
     const matAlgo12xSfs = createMatAlgo12xSfs({ typed: typed3, DenseMatrix: DenseMatrix6 });
@@ -27235,11 +27259,11 @@ var createLargerEq = /* @__PURE__ */ factory(
     const compareUnits2 = createCompareUnits({ typed: typed3 });
     return typed3(
       name159,
-      createLargerEqNumber({ typed: typed3, config }),
+      createLargerEqNumber({ typed: typed3, config: config2 }),
       {
         "boolean, boolean": (x, y) => x >= y,
         "BigNumber, BigNumber": function(x, y) {
-          return x.gte(y) || nearlyEqual2(x, y, config.relTol, config.absTol);
+          return x.gte(y) || nearlyEqual2(x, y, config2.relTol, config2.absTol);
         },
         "bigint, bigint": function(x, y) {
           return x >= y;
@@ -27261,10 +27285,10 @@ var createLargerEq = /* @__PURE__ */ factory(
 var createLargerEqNumber = /* @__PURE__ */ factory(
   name159,
   ["typed", "config"],
-  ({ typed: typed3, config }) => {
+  ({ typed: typed3, config: config2 }) => {
     return typed3(name159, {
       "number, number": function(x, y) {
-        return x >= y || nearlyEqual(x, y, config.relTol, config.absTol);
+        return x >= y || nearlyEqual(x, y, config2.relTol, config2.absTol);
       }
     });
   }
@@ -27286,7 +27310,7 @@ var createSmaller = /* @__PURE__ */ factory(
   dependencies160,
   ({
     typed: typed3,
-    config,
+    config: config2,
     bignumber: bignumber2,
     matrix: matrix2,
     DenseMatrix: DenseMatrix6,
@@ -27303,11 +27327,11 @@ var createSmaller = /* @__PURE__ */ factory(
     });
     const compareUnits2 = createCompareUnits({ typed: typed3 });
     function bignumSmaller(x, y) {
-      return x.lt(y) && !nearlyEqual2(x, y, config.relTol, config.absTol);
+      return x.lt(y) && !nearlyEqual2(x, y, config2.relTol, config2.absTol);
     }
     return typed3(
       name160,
-      createSmallerNumber({ typed: typed3, config }),
+      createSmallerNumber({ typed: typed3, config: config2 }),
       {
         "boolean, boolean": (x, y) => x < y,
         "BigNumber, BigNumber": bignumSmaller,
@@ -27335,10 +27359,10 @@ var createSmaller = /* @__PURE__ */ factory(
 var createSmallerNumber = /* @__PURE__ */ factory(
   name160,
   ["typed", "config"],
-  ({ typed: typed3, config }) => {
+  ({ typed: typed3, config: config2 }) => {
     return typed3(name160, {
       "number, number": function(x, y) {
-        return x < y && !nearlyEqual(x, y, config.relTol, config.absTol);
+        return x < y && !nearlyEqual(x, y, config2.relTol, config2.absTol);
       }
     });
   }
@@ -27350,7 +27374,7 @@ var dependencies161 = ["typed", "config", "matrix", "DenseMatrix", "concat", "Sp
 var createSmallerEq = /* @__PURE__ */ factory(
   name161,
   dependencies161,
-  ({ typed: typed3, config, matrix: matrix2, DenseMatrix: DenseMatrix6, concat: concat3, SparseMatrix }) => {
+  ({ typed: typed3, config: config2, matrix: matrix2, DenseMatrix: DenseMatrix6, concat: concat3, SparseMatrix }) => {
     const matAlgo03xDSf = createMatAlgo03xDSf({ typed: typed3 });
     const matAlgo07xSSf = createMatAlgo07xSSf({ typed: typed3, SparseMatrix });
     const matAlgo12xSfs = createMatAlgo12xSfs({ typed: typed3, DenseMatrix: DenseMatrix6 });
@@ -27362,11 +27386,11 @@ var createSmallerEq = /* @__PURE__ */ factory(
     const compareUnits2 = createCompareUnits({ typed: typed3 });
     return typed3(
       name161,
-      createSmallerEqNumber({ typed: typed3, config }),
+      createSmallerEqNumber({ typed: typed3, config: config2 }),
       {
         "boolean, boolean": (x, y) => x <= y,
         "BigNumber, BigNumber": function(x, y) {
-          return x.lte(y) || nearlyEqual2(x, y, config.relTol, config.absTol);
+          return x.lte(y) || nearlyEqual2(x, y, config2.relTol, config2.absTol);
         },
         "bigint, bigint": (x, y) => x <= y,
         "Fraction, Fraction": (x, y) => x.compare(y) !== 1,
@@ -27386,10 +27410,10 @@ var createSmallerEq = /* @__PURE__ */ factory(
 var createSmallerEqNumber = /* @__PURE__ */ factory(
   name161,
   ["typed", "config"],
-  ({ typed: typed3, config }) => {
+  ({ typed: typed3, config: config2 }) => {
     return typed3(name161, {
       "number, number": function(x, y) {
-        return x <= y || nearlyEqual(x, y, config.relTol, config.absTol);
+        return x <= y || nearlyEqual(x, y, config2.relTol, config2.absTol);
       }
     });
   }
@@ -28322,7 +28346,7 @@ var createRange = /* @__PURE__ */ factory(
   dependencies173,
   ({
     typed: typed3,
-    config,
+    config: config2,
     matrix: matrix2,
     bignumber: bignumber2,
     smaller: smaller2,
@@ -28416,7 +28440,7 @@ var createRange = /* @__PURE__ */ factory(
       }
     });
     function _out(arr7) {
-      if (config.matrix === "Matrix") {
+      if (config2.matrix === "Matrix") {
         return matrix2 ? matrix2(arr7) : noMatrix();
       }
       return arr7;
@@ -28426,7 +28450,7 @@ var createRange = /* @__PURE__ */ factory(
       if (!r) {
         throw new SyntaxError('String "' + str + '" is no valid range');
       }
-      if (config.number === "BigNumber") {
+      if (config2.number === "BigNumber") {
         if (bignumber2 === void 0) {
           noBignumber();
         }
@@ -28485,7 +28509,7 @@ var createGamma = /* @__PURE__ */ factory(
   dependencies174,
   ({
     typed: typed3,
-    config,
+    config: config2,
     multiplyScalar: _multiplyScalar,
     pow: _pow,
     BigNumber: BigNumber9,
@@ -28531,7 +28555,7 @@ var createGamma = /* @__PURE__ */ factory(
       if (nNum < 8) {
         return new BigNumber9([1, 1, 2, 6, 24, 120, 720, 5040][nNum]);
       }
-      const precision = config.precision + (Math.log(nNum) | 0);
+      const precision = config2.precision + (Math.log(nNum) | 0);
       const Big = BigNumber9.clone({ precision });
       if (nNum % 2 === 1) {
         return n.times(bigFactorial(n.minus(1)));
@@ -28739,7 +28763,7 @@ var dependencies177 = ["typed", "config", "numeric", "larger", "isNaN"];
 var createMax = /* @__PURE__ */ factory(
   name177,
   dependencies177,
-  ({ typed: typed3, config, numeric: numeric2, larger: larger2, isNaN: mathIsNaN }) => {
+  ({ typed: typed3, config: config2, numeric: numeric2, larger: larger2, isNaN: mathIsNaN }) => {
     return typed3(name177, {
       // max([a, b, c, d, ...])
       "Array | Matrix": _max,
@@ -28796,7 +28820,7 @@ var createMax = /* @__PURE__ */ factory(
         throw new Error("Cannot calculate max of an empty array");
       }
       if (typeof res === "string") {
-        res = numeric2(res, safeNumberType(res, config));
+        res = numeric2(res, safeNumberType(res, config2));
       }
       return res;
     }
@@ -28818,7 +28842,7 @@ var dependencies178 = ["typed", "config", "numeric", "smaller", "isNaN"];
 var createMin = /* @__PURE__ */ factory(
   name178,
   dependencies178,
-  ({ typed: typed3, config, numeric: numeric2, smaller: smaller2, isNaN: mathIsNaN }) => {
+  ({ typed: typed3, config: config2, numeric: numeric2, smaller: smaller2, isNaN: mathIsNaN }) => {
     return typed3(name178, {
       // min([a, b, c, d, ...])
       "Array | Matrix": _min,
@@ -28875,7 +28899,7 @@ var createMin = /* @__PURE__ */ factory(
         throw new Error("Cannot calculate min of an empty array");
       }
       if (typeof min2 === "string") {
-        min2 = numeric2(min2, safeNumberType(min2, config));
+        min2 = numeric2(min2, safeNumberType(min2, config2));
       }
       return min2;
     }
@@ -30156,7 +30180,7 @@ var createSimplifyConstant = /* @__PURE__ */ factory(
   dependencies193,
   ({
     typed: typed3,
-    config,
+    config: config2,
     mathWithTransform,
     matrix: matrix2,
     parse: parse3,
@@ -30256,7 +30280,7 @@ var createSimplifyConstant = /* @__PURE__ */ factory(
     }
     const _toNumber = typed3({
       "string, Object": function(s, options) {
-        const numericType = safeNumberType(s, config);
+        const numericType = safeNumberType(s, config2);
         if (numericType === "BigNumber") {
           if (bignumber2 === void 0) {
             noBignumber();
@@ -30305,7 +30329,7 @@ var createSimplifyConstant = /* @__PURE__ */ factory(
       return new OperatorNode("-", "unaryMinus", [n]);
     }
     function _fractionToNode(f) {
-      const fromBigInt = (value) => config.number === "BigNumber" && bignumber2 ? bignumber2(value) : Number(value);
+      const fromBigInt = (value) => config2.number === "BigNumber" && bignumber2 ? bignumber2(value) : Number(value);
       const signBigInt = BigInt(f.s);
       const numeratorValue = signBigInt * f.n;
       const numeratorNode = numeratorValue < 0n ? new OperatorNode("-", "unaryMinus", [new ConstantNode(fromBigInt(-numeratorValue))]) : new ConstantNode(fromBigInt(numeratorValue));
@@ -33140,7 +33164,7 @@ var createIntersect = /* @__PURE__ */ factory(
   dependencies217,
   ({
     typed: typed3,
-    config,
+    config: config2,
     abs: abs2,
     add: add2,
     addScalar: addScalar2,
@@ -33268,7 +33292,7 @@ var createIntersect = /* @__PURE__ */ factory(
         multiplyScalar2(d2[0], d1[1])
       );
       if (isZero2(det2)) return null;
-      if (smaller2(abs2(det2), config.relTol)) {
+      if (smaller2(abs2(det2), config2.relTol)) {
         return null;
       }
       const d20o11 = multiplyScalar2(d2[0], o1[1]);
@@ -35252,7 +35276,7 @@ var createZeta = /* @__PURE__ */ factory(
   dependencies235,
   ({
     typed: typed3,
-    config,
+    config: config2,
     multiply: multiply2,
     pow: pow2,
     divide: divide2,
@@ -35282,7 +35306,7 @@ var createZeta = /* @__PURE__ */ factory(
         s,
         (value) => new BigNumber9(value),
         () => {
-          return Math.abs(Math.log10(config.relTol));
+          return Math.abs(Math.log10(config2.relTol));
         }
       ),
       Complex: zetaComplex
@@ -35303,7 +35327,7 @@ var createZeta = /* @__PURE__ */ factory(
       if (s.re === 0 && s.im === 0) {
         return new Complex12(-0.5);
       }
-      if (s.re === 1) {
+      if (s.re === 1 && s.im === 0) {
         return new Complex12(NaN, NaN);
       }
       if (s.re === Infinity && s.im === 0) {
@@ -35883,7 +35907,7 @@ function flattenToFloat649(matrix2, rows, cols) {
   return result;
 }
 function createRealSymmetric({
-  config,
+  config: config2,
   addScalar: addScalar2,
   subtract: subtract2,
   abs: abs2,
@@ -35908,7 +35932,7 @@ function createRealSymmetric({
     if (typeof a === "number" && typeof b === "number") return a <= b;
     return a.lte(b);
   }
-  function main(arr7, _N, prec = config.relTol, type, computeVectors) {
+  function main(arr7, _N, prec = config2.relTol, type, computeVectors) {
     if (type === "number") {
       return diag2(arr7, prec, computeVectors);
     }
@@ -36029,7 +36053,7 @@ function createRealSymmetric({
   }
   function getTheta(aii, ajj, aij) {
     const denom = ajj - aii;
-    if (Math.abs(denom) <= config.relTol) {
+    if (Math.abs(denom) <= config2.relTol) {
       return Math.PI / 4;
     } else {
       return 0.5 * Math.atan(2 * aij / (ajj - aii));
@@ -36037,7 +36061,7 @@ function createRealSymmetric({
   }
   function getThetaBig(aii, ajj, aij) {
     const denom = subtract2(ajj, aii);
-    if (bigLte(abs2(denom), bignumber2(config.relTol))) {
+    if (bigLte(abs2(denom), bignumber2(config2.relTol))) {
       return bignumber2(-1).acos().div(4);
     } else {
       return multiplyScalar2(
@@ -36248,7 +36272,7 @@ var createEigs = /* @__PURE__ */ factory(
   name237,
   dependencies237,
   ({
-    config,
+    config: config2,
     typed: typed3,
     matrix: matrix2,
     addScalar: addScalar2,
@@ -36283,7 +36307,7 @@ var createEigs = /* @__PURE__ */ factory(
     dot: dot3
   }) => {
     const doRealSymmetric = createRealSymmetric({
-      config,
+      config: config2,
       addScalar: addScalar2,
       subtract: subtract2,
       abs: abs2,
@@ -36351,7 +36375,7 @@ var createEigs = /* @__PURE__ */ factory(
     });
     function doEigs(mat, opts = {}) {
       const computeVectors = "eigenvectors" in opts ? opts.eigenvectors : true;
-      const prec = opts.precision ?? config.relTol;
+      const prec = opts.precision ?? config2.relTol;
       const result = computeValuesAndVectors(mat, prec, computeVectors);
       if (opts.matricize) {
         result.values = matrix2(result.values);
@@ -37810,7 +37834,7 @@ var createDerivative = /* @__PURE__ */ factory(
   dependencies244,
   ({
     typed: typed3,
-    config,
+    config: config2,
     parse: parse3,
     simplify: simplify2,
     equal: equal2,
@@ -38339,7 +38363,7 @@ var createDerivative = /* @__PURE__ */ factory(
       }
     });
     function createConstantNode2(value, valueType) {
-      return new ConstantNode(numeric2(value, valueType || safeNumberType(String(value), config)));
+      return new ConstantNode(numeric2(value, valueType || safeNumberType(String(value), config2)));
     }
     return derivative2;
   }
@@ -39104,7 +39128,7 @@ var createRotationMatrix = /* @__PURE__ */ factory(
   dependencies249,
   ({
     typed: typed3,
-    config,
+    config: config2,
     multiplyScalar: multiplyScalar2,
     addScalar: addScalar2,
     unaryMinus: unaryMinus2,
@@ -39118,13 +39142,13 @@ var createRotationMatrix = /* @__PURE__ */ factory(
   }) => {
     return typed3(name249, {
       "": function() {
-        return config.matrix === "Matrix" ? matrix2([]) : [];
+        return config2.matrix === "Matrix" ? matrix2([]) : [];
       },
       string: function(format6) {
         return matrix2(format6);
       },
       "number | BigNumber | Complex | Unit": function(theta) {
-        return _rotationMatrix2x2(theta, config.matrix === "Matrix" ? "dense" : void 0);
+        return _rotationMatrix2x2(theta, config2.matrix === "Matrix" ? "dense" : void 0);
       },
       "number | BigNumber | Complex | Unit, string": function(theta, format6) {
         return _rotationMatrix2x2(theta, format6);
@@ -39136,7 +39160,7 @@ var createRotationMatrix = /* @__PURE__ */ factory(
       },
       "number | BigNumber | Complex | Unit, Matrix": function(theta, v) {
         _validateVector(v);
-        const storageType = v.storage() || (config.matrix === "Matrix" ? "dense" : void 0);
+        const storageType = v.storage() || (config2.matrix === "Matrix" ? "dense" : void 0);
         return _rotationMatrix3x3(theta, v, storageType);
       },
       "number | BigNumber | Complex | Unit, Array, string": function(theta, v, format6) {
@@ -39667,8 +39691,8 @@ function unitFactory(name254, valueStr, unitStr) {
   return factory(
     name254,
     dependencies254,
-    ({ config, Unit: Unit2, BigNumber: BigNumber9 }) => {
-      const value = config.number === "BigNumber" ? new BigNumber9(valueStr) : parseFloat(valueStr);
+    ({ config: config2, Unit: Unit2, BigNumber: BigNumber9 }) => {
+      const value = config2.number === "BigNumber" ? new BigNumber9(valueStr) : parseFloat(valueStr);
       const unit2 = new Unit2(value, unitStr);
       unit2.fixPrefix = true;
       return unit2;
@@ -39680,8 +39704,8 @@ function numberFactory(name254, value) {
   return factory(
     name254,
     dependencies254,
-    ({ config, BigNumber: BigNumber9 }) => {
-      return config.number === "BigNumber" ? new BigNumber9(value) : value;
+    ({ config: config2, BigNumber: BigNumber9 }) => {
+      return config2.number === "BigNumber" ? new BigNumber9(value) : value;
     }
   );
 }
@@ -42307,6 +42331,13 @@ function casFactor(input) {
   }).then((r) => r.result);
 }
 
+// src/config-api.ts
+function config(options) {
+  const shared = factoryScope.config;
+  if (options) Object.assign(shared, options);
+  return { ...shared };
+}
+
 // src/help.ts
 import { createHelpClass, embeddedDocs } from "@danielsimonjr/mathts-expression";
 var savedConfig = {};
@@ -43772,6 +43803,7 @@ export {
   concat2 as concat,
   cond,
   conductanceQuantum,
+  config,
   conj,
   connectedComponents,
   convexHull,