@danielsimonjr/mathts-functions 0.2.1 → 0.2.3

package/dist/index.js

@@ -13667,7 +13667,7 @@ var singularValues = mathTyped12("singularValues", {
 });
 var matrixExpm = mathTyped12("matrixExpm", {
   DenseMatrix: (A) => matrixExpmPrimitive(A),
-  "DenseMatrix, Object": (A, opts) => matrixExpmPrimitive(A),
+  "DenseMatrix, Object": (A, _opts) => matrixExpmPrimitive(A),
   Array: (A) => {
     const D = DenseMatrix.fromArray(A);
     return matrixExpmPrimitive(D).toArray();
@@ -13913,6 +13913,9 @@ var cbrt2 = Math.cbrt || function cbrt3(x) {
 var expm12 = Math.expm1 || function expm13(x) {
   return x >= 2e-4 || x <= -2e-4 ? Math.exp(x) - 1 : x + x * x / 2 + x * x * x / 6;
 };
+function isPowZeroAtInfinity(x, y) {
+  return x * x < 1 && y === Infinity || x * x > 1 && y === -Infinity;
+}
 function formatNumberToBase(n, base, size2) {
   const prefixes = { 2: "0b", 8: "0o", 16: "0x" };
   const prefix = prefixes[base];
@@ -16228,6 +16231,22 @@ function pickShallow(object, properties2) {
   return copy;
 }
 
+// src/error/MathjsError.ts
+var MathjsError = class _MathjsError extends Error {
+  isMathjsError = true;
+  /**
+   * Create a MathjsError
+   * @param message  Error message
+   */
+  constructor(message) {
+    super(message);
+    this.name = "MathjsError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _MathjsError);
+    }
+  }
+};
+
 // src/utils/factory.ts
 function factory(name256, dependencies256, create, meta) {
   function assertAndCreate(scope) {
@@ -16249,7 +16268,7 @@ function assertDependencies(name256, dependencies256, scope) {
     const missingDependencies = dependencies256.filter(
       (dependency) => scope[dependency] === void 0
     );
-    throw new Error(
+    throw new MathjsError(
       `Cannot create function "${name256}", some dependencies are missing: ${missingDependencies.map((d) => `"${d}"`).join(", ")}.`
     );
   }
@@ -17124,7 +17143,7 @@ function xgcdNumber(a, b) {
 }
 xgcdNumber.signature = n2;
 function powNumber(x, y) {
-  if (x * x < 1 && y === Infinity || x * x > 1 && y === -Infinity) {
+  if (isPowZeroAtInfinity(x, y)) {
     return 0;
   }
   return Math.pow(x, y);
@@ -20368,9 +20387,9 @@ var createRandomInt = /* @__PURE__ */ factory(
       });
     }
     return typed3(name73, {
-      "": () => _randomInt(0, 2),
-      number: (max2) => _randomInt(0, max2),
-      "number, number": (min2, max2) => _randomInt(min2, max2),
+      "": () => _randomInt2(0, 2),
+      number: (max2) => _randomInt2(0, max2),
+      "number, number": (min2, max2) => _randomInt2(min2, max2),
       bigint: (max2) => _randomBigint(0n, max2),
       "bigint, bigint": _randomBigint,
       "Array | Matrix": (size2) => _randomIntMatrix(size2, 0, 1),
@@ -20380,18 +20399,18 @@ var createRandomInt = /* @__PURE__ */ factory(
     function _randomIntMatrix(size2, min2, max2) {
       const res = randomMatrix(
         size2.valueOf(),
-        () => _randomInt(min2, max2)
+        () => _randomInt2(min2, max2)
       );
       return isMatrix(size2) ? size2.create(res, "number") : res;
     }
-    function _randomInt(min2, max2) {
+    function _randomInt2(min2, max2) {
       return Math.floor(min2 + rng() * (max2 - min2));
     }
     function _randomBigint(min2, max2) {
       const simpleCutoff = 2n ** 30n;
       const width = max2 - min2;
       if (width <= simpleCutoff) {
-        return min2 + BigInt(_randomInt(0, Number(width)));
+        return min2 + BigInt(_randomInt2(0, Number(width)));
       }
       const bits = log24(width);
       let picked = width;
@@ -20947,75 +20966,80 @@ var createIdentity = /* @__PURE__ */ factory(
   }
 );
 
+// src/matrix/utils/zerosAndOnes.ts
+function createZerosAndOnes(name256, defaultValue, { typed: typed3, config, matrix: matrix2, BigNumber: BigNumber9 }) {
+  return typed3(name256, {
+    "": function() {
+      return config.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
+    "...number | BigNumber | string": function(size2) {
+      const last = size2[size2.length - 1];
+      if (typeof last === "string") {
+        const format6 = size2.pop();
+        return _zerosAndOnes(size2, format6);
+      } else if (config.matrix === "Array") {
+        return _zerosAndOnes(size2);
+      } else {
+        return _zerosAndOnes(size2, "default");
+      }
+    },
+    Array: _zerosAndOnes,
+    Matrix: function(size2) {
+      const format6 = size2.storage();
+      return _zerosAndOnes(size2.valueOf(), format6);
+    },
+    "Array | Matrix, string": function(size2, format6) {
+      const sizeArray = Array.isArray(size2) ? size2 : size2.valueOf();
+      return _zerosAndOnes(sizeArray, format6);
+    }
+  });
+  function _zerosAndOnes(size2, format6) {
+    const hasBigNumbers = _normalize(size2);
+    const dflt = hasBigNumbers ? new BigNumber9(defaultValue) : defaultValue;
+    _validate(size2);
+    if (format6) {
+      const m = matrix2(format6);
+      if (size2.length > 0) {
+        return m.resize(size2, dflt);
+      }
+      return m;
+    } else {
+      const arr = [];
+      if (size2.length > 0) {
+        return resize(arr, size2, dflt);
+      }
+      return arr;
+    }
+  }
+  function _normalize(size2) {
+    let hasBigNumbers = false;
+    size2.forEach(function(value, index, arr) {
+      if (isBigNumber(value)) {
+        hasBigNumbers = true;
+        arr[index] = value.toNumber();
+      }
+    });
+    return hasBigNumbers;
+  }
+  function _validate(size2) {
+    size2.forEach(function(value) {
+      if (typeof value !== "number" || !isInteger(value) || value < 0) {
+        throw new Error(`Parameters in function ${name256} must be positive integers`);
+      }
+    });
+  }
+}
+
 // src/matrix/zeros.ts
 var name86 = "zeros";
 var dependencies86 = ["typed", "config", "matrix", "BigNumber"];
 var createZeros = /* @__PURE__ */ factory(
   name86,
   dependencies86,
-  ({ typed: typed3, config, matrix: matrix2, BigNumber: BigNumber9 }) => {
-    return typed3(name86, {
-      "": function() {
-        return config.matrix === "Array" ? _zeros([]) : _zeros([], "default");
-      },
-      // math.zeros(m, n, p, ..., format)
-      // TODO: more accurate signature '...number | BigNumber, string' as soon as typed-function supports this
-      "...number | BigNumber | string": function(size2) {
-        const last = size2[size2.length - 1];
-        if (typeof last === "string") {
-          const format6 = size2.pop();
-          return _zeros(size2, format6);
-        } else if (config.matrix === "Array") {
-          return _zeros(size2);
-        } else {
-          return _zeros(size2, "default");
-        }
-      },
-      Array: _zeros,
-      Matrix: function(size2) {
-        const format6 = size2.storage();
-        return _zeros(size2.valueOf(), format6);
-      },
-      "Array | Matrix, string": function(size2, format6) {
-        const sizeArray = Array.isArray(size2) ? size2 : size2.valueOf();
-        return _zeros(sizeArray, format6);
-      }
-    });
-    function _zeros(size2, format6) {
-      const hasBigNumbers = _normalize(size2);
-      const defaultValue = hasBigNumbers ? new BigNumber9(0) : 0;
-      _validate(size2);
-      if (format6) {
-        const m = matrix2(format6);
-        if (size2.length > 0) {
-          return m.resize(size2, defaultValue);
-        }
-        return m;
-      } else {
-        const arr = [];
-        if (size2.length > 0) {
-          return resize(arr, size2, defaultValue);
-        }
-        return arr;
-      }
-    }
-    function _normalize(size2) {
-      let hasBigNumbers = false;
-      size2.forEach(function(value, index, arr) {
-        if (isBigNumber(value)) {
-          hasBigNumbers = true;
-          arr[index] = value.toNumber();
-        }
-      });
-      return hasBigNumbers;
-    }
-    function _validate(size2) {
-      size2.forEach(function(value) {
-        if (typeof value !== "number" || !isInteger(value) || value < 0) {
-          throw new Error("Parameters in function zeros must be positive integers");
-        }
-      });
-    }
+  (deps) => {
+    return createZerosAndOnes(name86, 0, deps);
   }
 );
 
@@ -21025,69 +21049,8 @@ var dependencies87 = ["typed", "config", "matrix", "BigNumber"];
 var createOnes = /* @__PURE__ */ factory(
   name87,
   dependencies87,
-  ({ typed: typed3, config, matrix: matrix2, BigNumber: BigNumber9 }) => {
-    return typed3("ones", {
-      "": function() {
-        return config.matrix === "Array" ? _ones([]) : _ones([], "default");
-      },
-      // math.ones(m, n, p, ..., format)
-      // TODO: more accurate signature '...number | BigNumber, string' as soon as typed-function supports this
-      "...number | BigNumber | string": function(size2) {
-        const last = size2[size2.length - 1];
-        if (typeof last === "string") {
-          const format6 = size2.pop();
-          return _ones(size2, format6);
-        } else if (config.matrix === "Array") {
-          return _ones(size2);
-        } else {
-          return _ones(size2, "default");
-        }
-      },
-      Array: _ones,
-      Matrix: function(size2) {
-        const format6 = size2.storage();
-        return _ones(size2.valueOf(), format6);
-      },
-      "Array | Matrix, string": function(size2, format6) {
-        const sizeArray = Array.isArray(size2) ? size2 : size2.valueOf();
-        return _ones(sizeArray, format6);
-      }
-    });
-    function _ones(size2, format6) {
-      const hasBigNumbers = _normalize(size2);
-      const defaultValue = hasBigNumbers ? new BigNumber9(1) : 1;
-      _validate(size2);
-      if (format6) {
-        const m = matrix2(format6);
-        if (size2.length > 0) {
-          return m.resize(size2, defaultValue);
-        }
-        return m;
-      } else {
-        const arr = [];
-        if (size2.length > 0) {
-          return resize(arr, size2, defaultValue);
-        }
-        return arr;
-      }
-    }
-    function _normalize(size2) {
-      let hasBigNumbers = false;
-      size2.forEach(function(value, index, arr) {
-        if (isBigNumber(value)) {
-          hasBigNumbers = true;
-          arr[index] = value.toNumber();
-        }
-      });
-      return hasBigNumbers;
-    }
-    function _validate(size2) {
-      size2.forEach(function(value) {
-        if (typeof value !== "number" || !isInteger(value) || value < 0) {
-          throw new Error("Parameters in function ones must be positive integers");
-        }
-      });
-    }
+  (deps) => {
+    return createZerosAndOnes(name87, 1, deps);
   }
 );
 
@@ -23427,14 +23390,7 @@ var createCbrt = /* @__PURE__ */ factory(
         if (negate) {
           x.value = unaryMinus2(x.value);
         }
-        let third;
-        if (isBigNumber(x.value)) {
-          third = new BigNumber9(1).div(3);
-        } else if (isFraction(x.value)) {
-          third = new Fraction5(1, 3);
-        } else {
-          third = 1 / 3;
-        }
+        const third = _getThird(x.value);
         const result = x.pow(third);
         if (negate) {
           result.value = unaryMinus2(result.value);
@@ -23442,6 +23398,15 @@ var createCbrt = /* @__PURE__ */ factory(
         return result;
       }
     }
+    function _getThird(value) {
+      if (isBigNumber(value)) {
+        return new BigNumber9(1).div(3);
+      } else if (isFraction(value)) {
+        return new Fraction5(1, 3);
+      } else {
+        return 1 / 3;
+      }
+    }
   }
 );
 
@@ -24284,45 +24249,22 @@ function _switch2(mat) {
   return ret;
 }
 
-// src/error/ArgumentsError.ts
-var ArgumentsError = class _ArgumentsError extends Error {
-  fn;
-  count;
-  min;
-  max;
-  isArgumentsError = true;
-  /**
-   * Create an ArgumentsError
-   * @param fn     Function name
-   * @param count  Actual argument count
-   * @param min    Minimum required argument count
-   * @param max    Maximum required argument count (optional)
-   */
-  constructor(fn, count2, min2, max2) {
-    const message = "Wrong number of arguments in function " + fn + " (" + count2 + " provided, " + min2 + (max2 !== void 0 && max2 !== null ? "-" + max2 : "") + " expected)";
-    super(message);
-    this.fn = fn;
-    this.count = count2;
-    this.min = min2;
-    this.max = max2;
-    this.name = "ArgumentsError";
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _ArgumentsError);
-    }
-  }
-};
-
 // src/matrix/resize.ts
 var name117 = "resize";
-var dependencies117 = ["config", "matrix"];
+var dependencies117 = ["typed", "config", "matrix"];
 var createResize = /* @__PURE__ */ factory(
   name117,
   dependencies117,
-  ({ config, matrix: matrix2 }) => {
-    return function resize3(x, size2, defaultValue) {
-      if (arguments.length !== 2 && arguments.length !== 3) {
-        throw new ArgumentsError("resize", arguments.length, 2, 3);
+  ({ typed: typed3, config, matrix: matrix2 }) => {
+    return typed3(name117, {
+      "any, Array | Matrix": function(x, size2) {
+        return _resize2(x, size2);
+      },
+      "any, Array | Matrix, any": function(x, size2, defaultValue) {
+        return _resize2(x, size2, defaultValue);
       }
+    });
+    function _resize2(x, size2, defaultValue) {
       if (isMatrix(size2)) {
         size2 = size2.valueOf();
       }
@@ -24351,7 +24293,8 @@ var createResize = /* @__PURE__ */ factory(
         const res = resize(x, size2, defaultValue);
         return asMatrix ? matrix2(res) : res;
       }
-    };
+    }
+    ;
     function _resizeString(str, size2, defaultChar) {
       if (defaultChar !== void 0) {
         if (typeof defaultChar !== "string" || defaultChar.length !== 1) {
@@ -26661,7 +26604,7 @@ var createPow = /* @__PURE__ */ factory(
       if (isInteger(y) || x >= 0 || config.predictable) {
         return powNumber(x, y);
       } else {
-        if (x * x < 1 && y === Infinity || x * x > 1 && y === -Infinity) {
+        if (isPowZeroAtInfinity(x, y)) {
           return 0;
         }
         return new Complex8(x, 0).pow(y, 0);
@@ -31978,6 +31921,18 @@ function hasher(args) {
   return args[0].precision;
 }
 
+// src/utils/log.ts
+var warnOnce = /* @__PURE__ */ (() => {
+  const messages = {};
+  return function warnOnce2(...args) {
+    const message = args.join(", ");
+    if (!messages[message]) {
+      messages[message] = true;
+      console.warn("Warning:", ...args);
+    }
+  };
+})();
+
 // src/type/unit/Unit.ts
 var name205 = "Unit";
 var dependencies205 = [
@@ -32594,6 +32549,7 @@ var createUnitClass = /* @__PURE__ */ factory(
       return other;
     };
     Unit2.prototype.toNumber = function(valuelessUnit) {
+      warnOnce("Unit.toNumber is deprecated. Use Unit.toNumeric instead.");
       return toNumber(this.toNumeric(valuelessUnit));
     };
     Unit2.prototype.toNumeric = function(valuelessUnit) {
@@ -43188,12 +43144,12 @@ factoryScope.sech = sech;
 var parseNumberWithConfig = createParseNumberWithConfig(factoryScope);
 factoryScope.parseNumberWithConfig = parseNumberWithConfig;
 var divideScalar = createDivideScalar(factoryScope);
-var randomInt2 = createRandomInt(factoryScope);
+var _randomInt = createRandomInt(factoryScope);
 var mode = createMode(factoryScope);
 var prod = createProd(factoryScope);
-var bin2 = createBin(factoryScope);
-var hex2 = createHex(factoryScope);
-var oct2 = createOct(factoryScope);
+var _bin = createBin(factoryScope);
+var _hex = createHex(factoryScope);
+var _oct = createOct(factoryScope);
 var hasNumericValue = createHasNumericValue(factoryScope);
 var isFinite2 = createIsFinite(factoryScope);
 var isZero = createIsZero(factoryScope);
@@ -44990,7 +44946,7 @@ function _casSimplifyOne(expr) {
   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");
+  r = r.replace(/\b0\s*\*\s*[^+-]*/g, "0");
   const numericPattern = /^[\d\s+\-*/().^]+$/;
   if (numericPattern.test(r)) {
     try {
@@ -45223,7 +45179,7 @@ function casSimplify(input) {
     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");
+    r = r.replace(/\b0\s*\*\s*[^+-]*/g, "0");
     if (/^[\d\s+\-*/().^]+$/.test(r)) {
       try {
         const jsExpr = r.replace(/\^/g, "**");

package/package.json

@@ -1,71 +1,71 @@
-{
-  "name": "@danielsimonjr/mathts-functions",
-  "version": "0.2.1",
-  "description": "Mathematical functions for MathTS - arithmetic, algebra, trigonometry, statistics, and more",
-  "author": "Daniel Simon Jr.",
-  "license": "MIT",
-  "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
-  },
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "tsup src/index.ts --format esm --clean",
-    "dev": "tsup src/index.ts --format esm --dts --watch",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint src --ext .ts",
-    "lint:fix": "eslint src --ext .ts --fix",
-    "clean": "rm -rf dist",
-    "build:prod": "tsup src/index.ts --format esm --clean --minify --treeshake"
-  },
-  "dependencies": {
-    "@danielsimonjr/mathts-core": "*",
-    "@danielsimonjr/mathts-expression": "*",
-    "@danielsimonjr/mathts-matrix": "*",
-    "@danielsimonjr/mathts-parallel": "*",
-    "bignumber.js": "^9.1.2",
-    "complex.js": "^2.2.5",
-    "decimal.js": "^10.4.3",
-    "escape-latex": "^1.2.0",
-    "fraction.js": "^5.2.1",
-    "javascript-natural-sort": "^0.7.1",
-    "seedrandom": "^3.0.5",
-    "tiny-emitter": "^2.1.0",
-    "typed-function": "github:danielsimonjr/typed-function"
-  },
-  "devDependencies": {
-    "@types/node": "^25.5.2",
-    "tsup": "^8.0.0",
-    "typescript": "^5.3.0",
-    "vitest": "^4.1.5"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/danielsimonjr/mathts",
-    "directory": "functions"
-  },
-  "keywords": [
-    "math",
-    "typescript",
-    "functions",
-    "arithmetic",
-    "algebra",
-    "trigonometry",
-    "statistics"
-  ]
-}
+{
+  "name": "@danielsimonjr/mathts-functions",
+  "version": "0.2.3",
+  "description": "Mathematical functions for MathTS - arithmetic, algebra, trigonometry, statistics, and more",
+  "author": "Daniel Simon Jr.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --clean",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "clean": "rm -rf dist",
+    "build:prod": "tsup src/index.ts --format esm --clean --minify --treeshake"
+  },
+  "dependencies": {
+    "@danielsimonjr/mathts-core": "0.1.3",
+    "@danielsimonjr/mathts-expression": "0.2.2",
+    "@danielsimonjr/mathts-matrix": "0.1.4",
+    "@danielsimonjr/mathts-parallel": "0.2.1",
+    "bignumber.js": "^9.1.2",
+    "complex.js": "^2.2.5",
+    "decimal.js": "^10.4.3",
+    "escape-latex": "^1.2.0",
+    "fraction.js": "^5.2.1",
+    "javascript-natural-sort": "^0.7.1",
+    "seedrandom": "^3.0.5",
+    "tiny-emitter": "^2.1.0",
+    "typed-function": "github:danielsimonjr/typed-function"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^4.1.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/danielsimonjr/mathts",
+    "directory": "functions"
+  },
+  "keywords": [
+    "math",
+    "typescript",
+    "functions",
+    "arithmetic",
+    "algebra",
+    "trigonometry",
+    "statistics"
+  ]
+}