mathjs 14.8.2 → 14.9.1

package/lib/esm/function/matrix/map.js

@@ -76,58 +76,141 @@ export var createMap = /* #__PURE__ */factory(name, dependencies, _ref => {
       throw new Error('Last argument must be a callback function');
     }
     var firstArrayIsMatrix = Arrays[0].isMatrix;
-    var newSize = broadcastSizes(...Arrays.map(M => M.isMatrix ? M.size() : arraySize(M)));
+    var sizes = Arrays.map(M => M.isMatrix ? M.size() : arraySize(M));
+    var newSize = broadcastSizes(...sizes);
+    var numberOfArrays = Arrays.length;
     var _get = firstArrayIsMatrix ? (matrix, idx) => matrix.get(idx) : get;
-    var broadcastedArrays = firstArrayIsMatrix ? Arrays.map(M => M.isMatrix ? M.create(broadcastTo(M.toArray(), newSize), M.datatype()) : Arrays[0].create(broadcastTo(M.valueOf(), newSize))) : Arrays.map(M => M.isMatrix ? broadcastTo(M.toArray(), newSize) : broadcastTo(M, newSize));
-    var callback;
-    if (typed.isTypedFunction(multiCallback)) {
-      var firstIndex = newSize.map(() => 0);
-      var firstValues = broadcastedArrays.map(array => _get(array, firstIndex));
-      var callbackCase = _getTypedCallbackCase(multiCallback, firstValues, firstIndex, broadcastedArrays);
-      callback = _getLimitedCallback(callbackCase);
-    } else {
-      var numberOfArrays = Arrays.length;
-      var _callbackCase = _getCallbackCase(multiCallback, numberOfArrays);
-      callback = _getLimitedCallback(_callbackCase);
+    var firstValues = Arrays.map((collection, i) => {
+      var firstIndex = sizes[i].map(() => 0);
+      return collection.isMatrix ? collection.get(firstIndex) : get(collection, firstIndex);
+    });
+    var callbackArgCount = typed.isTypedFunction(multiCallback) ? _getTypedCallbackArgCount(multiCallback, firstValues, newSize.map(() => 0), Arrays) : _getCallbackArgCount(multiCallback, numberOfArrays);
+    if (callbackArgCount < 2) {
+      var _callback = _getLimitedCallback(callbackArgCount, multiCallback, null);
+      return mapMultiple(Arrays, _callback);
     }
-    var broadcastedArraysCallback = (x, idx) => callback([x, ...broadcastedArrays.slice(1).map(Array => _get(Array, idx))], idx);
+    var broadcastedArrays = firstArrayIsMatrix ? Arrays.map(M => M.isMatrix ? M.create(broadcastTo(M.toArray(), newSize), M.datatype()) : Arrays[0].create(broadcastTo(M.valueOf(), newSize))) : Arrays.map(M => M.isMatrix ? broadcastTo(M.toArray(), newSize) : broadcastTo(M, newSize));
+    var callback = _getLimitedCallback(callbackArgCount, multiCallback, broadcastedArrays);
+    var broadcastedArraysCallback = (x, idx) => callback([x, ...broadcastedArrays.slice(1).map(array => _get(array, idx))], idx);
     if (firstArrayIsMatrix) {
       return broadcastedArrays[0].map(broadcastedArraysCallback);
     } else {
       return _mapArray(broadcastedArrays[0], broadcastedArraysCallback);
     }
-    function _getLimitedCallback(callbackCase) {
-      switch (callbackCase) {
-        case 0:
-          return x => multiCallback(...x);
-        case 1:
-          return (x, idx) => multiCallback(...x, idx);
-        case 2:
-          return (x, idx) => multiCallback(...x, idx, ...broadcastedArrays);
-      }
+  }
+  function mapMultiple(collections, callback) {
+    // collections can be matrices or arrays
+    // callback must be a function of the form (collections, [index])
+    var firstCollection = collections[0];
+    var arrays = collections.map(collection => collection.isMatrix ? collection.valueOf() : collection);
+    var sizes = collections.map(collection => collection.isMatrix ? collection.size() : arraySize(collection));
+    var finalSize = broadcastSizes(...sizes);
+    // the offset means for each initial array, how much smaller is it than the final size
+    var offsets = sizes.map(size => finalSize.length - size.length);
+    var maxDepth = finalSize.length - 1;
+    var callbackUsesIndex = callback.length > 1;
+    var index = callbackUsesIndex ? [] : null;
+    var resultsArray = iterate(arrays, 0);
+    if (firstCollection.isMatrix) {
+      var resultsMatrix = firstCollection.create();
+      resultsMatrix._data = resultsArray;
+      resultsMatrix._size = finalSize;
+      return resultsMatrix;
+    } else {
+      return resultsArray;
     }
-    function _getCallbackCase(callback, numberOfArrays) {
-      if (callback.length > numberOfArrays + 1) {
-        return 2;
-      }
-      if (callback.length === numberOfArrays + 1) {
-        return 1;
+    function iterate(arrays) {
+      var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      // each array can have different sizes
+      var currentDimensionSize = finalSize[depth];
+      var result = Array(currentDimensionSize);
+      if (depth < maxDepth) {
+        var _loop = function _loop(i) {
+          if (index) index[depth] = i;
+          // if there is an offset greater than the current dimension
+          // pass the array, if the size of the array is 1 pass the first
+          // element of the array
+          result[i] = iterate(arrays.map((array, arrayIndex) => offsets[arrayIndex] > depth ? array : array.length === 1 ? array[0] : array[i]), depth + 1);
+        };
+        for (var i = 0; i < currentDimensionSize; i++) {
+          _loop(i);
+        }
+      } else {
+        var _loop2 = function _loop2(_i) {
+          if (index) index[depth] = _i;
+          result[_i] = callback(arrays.map(a => a.length === 1 ? a[0] : a[_i]), index ? index.slice() : undefined);
+        };
+        for (var _i = 0; _i < currentDimensionSize; _i++) {
+          _loop2(_i);
+        }
       }
-      return 0;
+      return result;
     }
-    function _getTypedCallbackCase(callback, values, idx, arrays) {
-      if (typed.resolve(callback, [...values, idx, ...arrays]) !== null) {
-        return 2;
-      }
-      if (typed.resolve(callback, [...values, idx]) !== null) {
-        return 1;
-      }
-      if (typed.resolve(callback, values) !== null) {
-        return 0;
-      }
-      // this should never happen
+  }
+
+  /**
+    * Creates a limited callback based on the argument pattern.
+    * @param {number} callbackArgCount - The argument pattern (0, 1, or 2)
+    * @param {Function} multiCallback - The original callback function
+    * @param {Array} broadcastedArrays - The broadcasted arrays (for case 2)
+    * @returns {Function} The limited callback function
+    */
+  function _getLimitedCallback(callbackArgCount, multiCallback, broadcastedArrays) {
+    switch (callbackArgCount) {
+      case 0:
+        return x => multiCallback(...x);
+      case 1:
+        return (x, idx) => multiCallback(...x, idx);
+      case 2:
+        return (x, idx) => multiCallback(...x, idx, ...broadcastedArrays);
+    }
+  }
+
+  /**
+     * Determines the argument pattern of a regular callback function.
+     * @param {Function} callback - The callback function to analyze
+     * @param {number} numberOfArrays - Number of arrays being processed
+     * @returns {number} 0 = values only, 1 = values + index, 2 = values + index + arrays
+     */
+  function _getCallbackArgCount(callback, numberOfArrays) {
+    var callbackStr = callback.toString();
+    // Check if the callback function uses `arguments`
+    if (/arguments/.test(callbackStr)) return 2;
+
+    // Extract the parameters of the callback function
+    var paramsStr = callbackStr.match(/\(.*?\)/);
+    // Check if the callback function uses rest parameters
+    if (/\.\.\./.test(paramsStr)) return 2;
+    if (callback.length > numberOfArrays + 1) {
+      return 2;
+    }
+    if (callback.length === numberOfArrays + 1) {
+      return 1;
+    }
+    return 0;
+  }
+
+  /**
+  * Determines the argument pattern of a typed callback function.
+  * @param {Function} callback - The typed callback function to analyze
+  * @param {Array} values - Sample values for signature resolution
+  * @param {Array} idx - Sample index for signature resolution
+  * @param {Array} arrays - Sample arrays for signature resolution
+  * @returns {number} 0 = values only, 1 = values + index, 2 = values + index + arrays
+  */
+
+  function _getTypedCallbackArgCount(callback, values, idx, arrays) {
+    if (typed.resolve(callback, [...values, idx, ...arrays]) !== null) {
+      return 2;
+    }
+    if (typed.resolve(callback, [...values, idx]) !== null) {
+      return 1;
+    }
+    if (typed.resolve(callback, values) !== null) {
       return 0;
     }
+    // this should never happen
+    return 0;
   }
   /**
   * Map for a multi dimensional array

package/lib/esm/function/matrix/range.js

@@ -1,7 +1,7 @@
 import { factory } from '../../utils/factory.js';
 import { noBignumber, noMatrix } from '../../utils/noop.js';
 var name = 'range';
-var dependencies = ['typed', 'config', '?matrix', '?bignumber', 'smaller', 'smallerEq', 'larger', 'largerEq', 'add', 'isPositive'];
+var dependencies = ['typed', 'config', '?matrix', '?bignumber', 'equal', 'smaller', 'smallerEq', 'larger', 'largerEq', 'add', 'isZero', 'isPositive'];
 export var createRange = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -13,6 +13,7 @@ export var createRange = /* #__PURE__ */factory(name, dependencies, _ref => {
     larger,
     largerEq,
     add,
+    isZero,
     isPositive
   } = _ref;
   /**
@@ -181,6 +182,7 @@ export var createRange = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   function _range(start, end, step, includeEnd) {
     var array = [];
+    if (isZero(step)) throw new Error('Step must be non-zero');
     var ongoing = isPositive(step) ? includeEnd ? smallerEq : smaller : includeEnd ? largerEq : larger;
     var x = start;
     while (ongoing(x, end)) {

package/lib/esm/type/matrix/Range.js

@@ -1,5 +1,5 @@
 import { isBigInt, isBigNumber } from '../../utils/is.js';
-import { format, sign } from '../../utils/number.js';
+import { format, sign, nearlyEqual } from '../../utils/number.js';
 import { factory } from '../../utils/factory.js';
 var name = 'Range';
 var dependencies = [];
@@ -73,6 +73,9 @@ export var createRangeClass = /* #__PURE__ */factory(name, dependencies, () => {
     this.start = hasStart ? parseFloat(start) : 0;
     this.end = hasEnd ? parseFloat(end) : 0;
     this.step = hasStep ? parseFloat(step) : 1;
+    if (hasStep && nearlyEqual(this.step, 0)) {
+      throw new Error('Step must not be zero');
+    }
   }
 
   /**

package/lib/esm/version.js

@@ -1,3 +1,3 @@
-export var version = '14.8.2';
+export var version = '14.9.1';
 // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mathjs",
-  "version": "14.8.2",
+  "version": "14.9.1",
   "description": "Math.js is an extensive math library for JavaScript and Node.js. It features a flexible expression parser with support for symbolic computation, comes with a large set of built-in functions and constants, and offers an integrated solution to work with different data types like numbers, big numbers, complex numbers, fractions, units, and matrices.",
   "author": "Jos de Jong <wjosdejong@gmail.com> (https://github.com/josdejong)",
   "homepage": "https://mathjs.org",
@@ -44,15 +44,15 @@
     "@babel/register": "7.28.3",
     "@types/assert": "1.5.11",
     "@types/mocha": "10.0.10",
-    "@typescript-eslint/eslint-plugin": "8.44.1",
-    "@typescript-eslint/parser": "8.44.1",
+    "@typescript-eslint/eslint-plugin": "8.46.0",
+    "@typescript-eslint/parser": "8.46.0",
     "assert": "2.1.0",
     "babel-loader": "10.0.0",
     "c8": "10.1.3",
     "codecov": "3.8.3",
     "del": "8.0.1",
     "eigen": "0.2.2",
-    "es-check": "9.3.1",
+    "es-check": "9.4.4",
     "eslint": "8.57.1",
     "eslint-config-prettier": "9.1.0",
     "eslint-config-standard": "17.1.0",
@@ -77,7 +77,7 @@
     "karma-webdriver-launcher": "1.0.8",
     "karma-webpack": "5.0.1",
     "mkdirp": "3.0.1",
-    "mocha": "11.7.2",
+    "mocha": "11.7.4",
     "mocha-junit-reporter": "2.2.1",
     "ndarray": "1.0.19",
     "ndarray-determinant": "1.0.0",
@@ -91,8 +91,8 @@
     "sylvester": "0.0.21",
     "tinybench": "5.0.1",
     "ts-node": "10.9.2",
-    "typescript": "5.9.2",
-    "webpack": "5.101.3",
+    "typescript": "5.9.3",
+    "webpack": "5.102.1",
     "zeros": "1.0.0"
   },
   "type": "module",