mathjs 14.2.0 → 14.3.0

package/lib/esm/utils/array.js

@@ -11,7 +11,7 @@ import { deepStrictEqual } from './object.js';
  * This function checks the size of the first entry, it does not validate
  * whether all dimensions match. (use function `validate` for that)
  * @param {Array} x
- * @Return {Number[]} size
+ * @return {number[]} size
  */
 export function arraySize(x) {
   var s = [];
@@ -27,7 +27,7 @@ export function arraySize(x) {
  * has a size corresponding to the provided size array.
  * @param {Array} array    Array to be validated
  * @param {number[]} size  Array with the size of each dimension
- * @param {number} dim   Current dimension
+ * @param {number} dim     Current dimension
  * @throws DimensionError
  * @private
  */
@@ -48,7 +48,7 @@ function _validate(array, size, dim) {
       _validate(array[i], size, dimNext);
     }
   } else {
-    // last dimension. none of the childs may be an array
+    // last dimension. none of the children may be an array
     for (i = 0; i < len; i++) {
       if (Array.isArray(array[i])) {
         throw new DimensionError(size.length + 1, size.length, '>');
@@ -79,7 +79,7 @@ export function validate(array, size) {
 
 /**
  * Validate whether the source of the index matches the size of the Array
- * @param {Array | Matrix} array    Array to be validated
+ * @param {Array | Matrix} value    Array to be validated
  * @param {Index} index  Index with the source information to validate
  * @throws DimensionError
  */
@@ -112,8 +112,8 @@ export function validateIndex(index, length) {
 }
 
 /**
- * Test if and index has empty values
- * @param {number} index    Zero-based index
+ * Test if an index has empty values
+ * @param {Index} index    Zero-based index
  */
 export function isEmptyIndex(index) {
   for (var i = 0; i < index._dimensions.length; ++i) {
@@ -139,7 +139,7 @@ export function isEmptyIndex(index) {
  * Resize a multi dimensional array. The resized array is returned.
  * @param {Array | number} array         Array to be resized
  * @param {number[]} size Array with the size of each dimension
- * @param {*} [defaultValue=0]  Value to be filled in in new entries,
+ * @param {*} [defaultValue=0]  Value to be filled in new entries,
  *                              zero by default. Specify for example `null`,
  *                              to clearly see entries that are not explicitly
  *                              set.
@@ -177,7 +177,7 @@ export function resize(array, size, defaultValue) {
  * @param {Array} array         Array to be resized
  * @param {number[]} size       Array with the size of each dimension
  * @param {number} dim          Current dimension
- * @param {*} [defaultValue]    Value to be filled in in new entries,
+ * @param {*} [defaultValue]    Value to be filled in new entries,
  *                              undefined by default.
  * @private
  */
@@ -267,7 +267,7 @@ export function reshape(array, sizes) {
 
 /**
  * Replaces the wildcard -1 in the sizes array.
- * @param {number[]} sizes  List of sizes for each dimension. At most on wildcard.
+ * @param {number[]} sizes  List of sizes for each dimension. At most one wildcard.
  * @param {number} currentLength  Number of elements in the array.
  * @throws {Error}                If more than one wildcard or unable to replace it.
  * @returns {number[]}      The sizes array with wildcard replaced.
@@ -314,7 +314,7 @@ function _reshape(array, sizes) {
   // testing if there are enough elements for the requested shape
   var tmpArray = array;
   var tmpArray2;
-  // for each dimensions starting by the last one and ignoring the first one
+  // for each dimension starting by the last one and ignoring the first one
   for (var sizeIndex = sizes.length - 1; sizeIndex > 0; sizeIndex--) {
     var size = sizes[sizeIndex];
     tmpArray2 = [];
@@ -385,7 +385,7 @@ function _squeeze(array, dims, dim) {
 /**
  * Unsqueeze a multi dimensional array: add dimensions when missing
  *
- * Paramter `size` will be mutated to match the new, unqueezed matrix size.
+ * Parameter `size` will be mutated to match the new, unsqueezed matrix size.
  *
  * @param {Array} array
  * @param {number} dims       Desired number of dimensions of the array
@@ -418,7 +418,7 @@ export function unsqueeze(array, dims, outer, size) {
  * @param {Array} array
  * @param {number} dims Required number of dimensions
  * @param {number} dim  Current dimension
- * @returns {Array | *} Returns the squeezed array
+ * @returns {Array | *} Returns the unsqueezed array
  * @private
  */
 function _unsqueeze(array, dims, dim) {
@@ -488,7 +488,7 @@ export function filter(array, callback) {
 }
 
 /**
- * Filter values in a callback given a regular expression
+ * Filter values in an array given a regular expression
  * @param {Array} array
  * @param {RegExp} regexp
  * @return {Array} Returns the filtered array
@@ -602,7 +602,7 @@ export function getArrayDataType(array, typeOf) {
 
 /**
  * Return the last item from an array
- * @param {array}
+ * @param {Array} array
  * @returns {*}
  */
 export function last(array) {
@@ -611,8 +611,8 @@ export function last(array) {
 
 /**
  * Get all but the last element of array.
- * @param {array}
- * @returns {*}
+ * @param {Array} array
+ * @returns {Array}
  */
 export function initial(array) {
   return array.slice(0, array.length - 1);
@@ -620,7 +620,7 @@ export function initial(array) {
 
 /**
  * Recursively concatenate two matrices.
- * The contents of the matrices is not cloned.
+ * The contents of the matrices are not cloned.
  * @param {Array} a             Multi dimensional array
  * @param {Array} b             Multi dimensional array
  * @param {number} concatDim    The dimension on which to concatenate (zero-based)
@@ -649,8 +649,8 @@ function concatRecursive(a, b, concatDim, dim) {
  * Concatenates many arrays in the specified direction
  * @param {...Array} arrays All the arrays to concatenate
  * @param {number} concatDim The dimension on which to concatenate (zero-based)
- * @returns
-*/
+ * @returns {Array}
+ */
 export function concat() {
   var arrays = Array.prototype.slice.call(arguments, 0, -1);
   var concatDim = Array.prototype.slice.call(arguments, -1);
@@ -667,9 +667,9 @@ export function concat() {
 }
 
 /**
- * Receives two or more sizes and get's the broadcasted size for both.
+ * Receives two or more sizes and gets the broadcasted size for both.
  * @param  {...number[]} sizes Sizes to broadcast together
- * @returns
+ * @returns {number[]} The broadcasted size
  */
 export function broadcastSizes() {
   for (var _len = arguments.length, sizes = new Array(_len), _key = 0; _key < _len; _key++) {
@@ -706,16 +706,16 @@ export function checkBroadcastingRules(size, toSize) {
   for (var j = 0; j < dim; j++) {
     var n = N - dim + j;
     if (size[j] < toSize[n] && size[j] > 1 || size[j] > toSize[n]) {
-      throw new Error("shape missmatch: missmatch is found in arg with shape (".concat(size, ") not possible to broadcast dimension ").concat(dim, " with size ").concat(size[j], " to size ").concat(toSize[n]));
+      throw new Error("shape mismatch: mismatch is found in arg with shape (".concat(size, ") not possible to broadcast dimension ").concat(dim, " with size ").concat(size[j], " to size ").concat(toSize[n]));
     }
   }
 }
 
 /**
  * Broadcasts a single array to a certain size
- * @param {array} array Array to be broadcasted
+ * @param {Array} array Array to be broadcasted
  * @param {number[]} toSize Size to broadcast the array
- * @returns The broadcasted array
+ * @returns {Array} The broadcasted array
  */
 export function broadcastTo(array, toSize) {
   var Asize = arraySize(array);
@@ -746,14 +746,14 @@ export function broadcastTo(array, toSize) {
 /**
  * Broadcasts arrays and returns the broadcasted arrays in an array
  * @param  {...Array | any} arrays
- * @returns
+ * @returns {Array[]} The broadcasted arrays
  */
 export function broadcastArrays() {
   for (var _len2 = arguments.length, arrays = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
     arrays[_key2] = arguments[_key2];
   }
   if (arrays.length === 0) {
-    throw new Error('Insuficient number of argumnets in function broadcastArrays');
+    throw new Error('Insufficient number of arguments in function broadcastArrays');
   }
   if (arrays.length === 1) {
     return arrays[0];
@@ -770,11 +770,11 @@ export function broadcastArrays() {
 }
 
 /**
- * stretches a matrix up to a certain size in a certain dimension
+ * Stretches a matrix up to a certain size in a certain dimension
  * @param {Array} arrayToStretch
  * @param {number[]} sizeToStretch
  * @param {number} dimToStretch
- * @returns
+ * @returns {Array} The stretched array
  */
 export function stretch(arrayToStretch, sizeToStretch, dimToStretch) {
   return concat(...Array(sizeToStretch).fill(arrayToStretch), dimToStretch);
@@ -784,13 +784,13 @@ export function stretch(arrayToStretch, sizeToStretch, dimToStretch) {
 * Retrieves a single element from an array given an index.
 *
 * @param {Array} array - The array from which to retrieve the value.
-* @param {Array<number>} idx - An array of indices specifying the position of the desired element in each dimension.
+* @param {Array<number>} index - An array of indices specifying the position of the desired element in each dimension.
 * @returns {*} - The value at the specified position in the array.
 *
 * @example
 * const arr = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]];
 * const index = [1, 0, 1];
-* console.log(getValue(arr, index)); // 6
+* console.log(get(arr, index)); // 6
 */
 export function get(array, index) {
   if (!Array.isArray(array)) {
@@ -807,30 +807,101 @@ export function get(array, index) {
 }
 
 /**
- * Recursive function to map a multi-dimensional array.
+ * Recursively maps over each element of nested array using a provided callback function.
  *
- * @param {*} value - The current value being processed in the array.
- * @param {Array} index - The index of the current value being processed in the array.
- * @param {Array} array - The array being processed.
- * @param {Function} callback - Function that produces the element of the new Array, taking three arguments: the value of the element, the index of the element, and the Array being processed.
- * @returns {*} The new array with each element being the result of the callback function.
- */
-export function recurse(value, index, array, callback) {
-  if (Array.isArray(value)) {
-    return value.map(function (child, i) {
-      // we create a copy of the index array and append the new index value
-      return recurse(child, index.concat(i), array, callback);
-    });
-  } else {
-    // invoke the callback function with the right number of arguments
-    return callback(value, index, array);
+ * @param {Array} array - The array to be mapped.
+ * @param {Function} callback - The function to execute on each element, taking three arguments:
+ *   - `value` (any): The current element being processed in the array.
+ *   - `index` (Array<number>): The index of the current element being processed in the array.
+ *   - `array` (Array): The array `deepMap` was called upon.
+ * @param {boolean} [skipIndex=false] - If true, the callback function is called with only the value.
+ * @returns {Array} A new array with each element being the result of the callback function.
+ */
+export function deepMap(array, callback) {
+  var skipIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  if (array.length === 0) {
+    return [];
+  }
+  if (skipIndex) {
+    return recursiveMap(array);
+  }
+  var index = [];
+  return recursiveMapWithIndex(array, 0);
+  function recursiveMapWithIndex(value, depth) {
+    if (Array.isArray(value)) {
+      var N = value.length;
+      var result = Array(N);
+      for (var i = 0; i < N; i++) {
+        index[depth] = i;
+        result[i] = recursiveMapWithIndex(value[i], depth + 1);
+      }
+      return result;
+    } else {
+      return callback(value, index.slice(0, depth), array);
+    }
+  }
+  function recursiveMap(value) {
+    if (Array.isArray(value)) {
+      var N = value.length;
+      var result = Array(N);
+      for (var i = 0; i < N; i++) {
+        result[i] = recursiveMap(value[i]);
+      }
+      return result;
+    } else {
+      return callback(value);
+    }
+  }
+}
+
+/**
+ * Recursively iterates over each element in a multi-dimensional array and applies a callback function.
+ *
+ * @param {Array} array - The multi-dimensional array to iterate over.
+ * @param {Function} callback - The function to execute for each element. It receives three arguments:
+ *   - {any} value: The current element being processed in the array.
+ *   - {Array<number>} index: The index of the current element in each dimension.
+ *   - {Array} array: The original array being processed.
+ * @param {boolean} [skipIndex=false] - If true, the callback function is called with only the value.
+ */
+export function deepForEach(array, callback) {
+  var skipIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  if (array.length === 0) {
+    return;
+  }
+  if (skipIndex) {
+    recursiveForEach(array);
+    return;
+  }
+  var index = [];
+  recursiveForEachWithIndex(array, 0);
+  function recursiveForEachWithIndex(value, depth) {
+    if (Array.isArray(value)) {
+      var N = value.length;
+      for (var i = 0; i < N; i++) {
+        index[depth] = i;
+        recursiveForEachWithIndex(value[i], depth + 1);
+      }
+    } else {
+      callback(value, index.slice(0, depth), array);
+    }
+  }
+  function recursiveForEach(value) {
+    if (Array.isArray(value)) {
+      var N = value.length;
+      for (var i = 0; i < N; i++) {
+        recursiveForEach(value[i]);
+      }
+    } else {
+      callback(value);
+    }
   }
 }
 
 /**
  * Deep clones a multidimensional array
  * @param {Array} array
- * @returns cloned array
+ * @returns {Array} cloned array
  */
 export function clone(array) {
   return _extends([], array);

package/lib/esm/utils/collection.js

@@ -1,6 +1,6 @@
 import { isCollection, isMatrix } from './is.js';
 import { IndexError } from '../error/IndexError.js';
-import { arraySize } from './array.js';
+import { arraySize, deepMap as arrayDeepMap, deepForEach as arrayDeepForEach } from './array.js';
 import { _switch } from './switch.js';
 
 /**
@@ -27,15 +27,9 @@ export function containsCollections(array) {
  */
 export function deepForEach(array, callback) {
   if (isMatrix(array)) {
-    array = array.valueOf();
-  }
-  for (var i = 0, ii = array.length; i < ii; i++) {
-    var value = array[i];
-    if (Array.isArray(value)) {
-      deepForEach(value, callback);
-    } else {
-      callback(value);
-    }
+    array.forEach(x => callback(x));
+  } else {
+    arrayDeepForEach(array, callback, true);
   }
 }
 
@@ -52,13 +46,18 @@ export function deepForEach(array, callback) {
  * @return {Array | Matrix} res
  */
 export function deepMap(array, callback, skipZeros) {
-  if (array && typeof array.map === 'function') {
-    // TODO: replace array.map with a for loop to improve performance
-    return array.map(function (x) {
-      return deepMap(x, callback, skipZeros);
-    });
+  if (!skipZeros) {
+    if (isMatrix(array)) {
+      return array.map(x => callback(x));
+    } else {
+      return arrayDeepMap(array, callback, true);
+    }
+  }
+  var skipZerosCallback = x => x === 0 ? x : callback(x);
+  if (isMatrix(array)) {
+    return array.map(x => skipZerosCallback(x));
   } else {
-    return callback(array);
+    return arrayDeepMap(array, skipZerosCallback, true);
   }
 }
 

package/lib/esm/utils/optimizeCallback.js

@@ -14,9 +14,14 @@ export function optimizeCallback(callback, array, name) {
   if (typed.isTypedFunction(callback)) {
     var firstIndex = (array.isMatrix ? array.size() : arraySize(array)).map(() => 0);
     var firstValue = array.isMatrix ? array.get(firstIndex) : get(array, firstIndex);
-    var hasSingleSignature = Object.keys(callback.signatures).length === 1;
     var numberOfArguments = _findNumberOfArguments(callback, firstValue, firstIndex, array);
-    var fastCallback = hasSingleSignature ? Object.values(callback.signatures)[0] : callback;
+    var fastCallback;
+    if (array.isMatrix && array.dataType !== 'mixed' && array.dataType !== undefined) {
+      var singleSignature = _findSingleSignatureWithArity(callback, numberOfArguments);
+      fastCallback = singleSignature !== undefined ? singleSignature : callback;
+    } else {
+      fastCallback = callback;
+    }
     if (numberOfArguments >= 1 && numberOfArguments <= 3) {
       return function () {
         for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
@@ -34,6 +39,18 @@ export function optimizeCallback(callback, array, name) {
   }
   return callback;
 }
+function _findSingleSignatureWithArity(callback, arity) {
+  var matchingFunctions = [];
+  Object.entries(callback.signatures).forEach(_ref => {
+    var [signature, func] = _ref;
+    if (signature.split(',').length === arity) {
+      matchingFunctions.push(func);
+    }
+  });
+  if (matchingFunctions.length === 1) {
+    return matchingFunctions[0];
+  }
+}
 function _findNumberOfArguments(callback, value, index, array) {
   var testArgs = [value, index, array];
   for (var i = 3; i > 0; i--) {

package/lib/esm/version.js

@@ -1,3 +1,3 @@
-export var version = '14.2.0';
+export var version = '14.3.0';
 // 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.2.0",
+  "version": "14.3.0",
   "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",
@@ -26,7 +26,6 @@
   ],
   "dependencies": {
     "@babel/runtime": "^7.25.7",
-    "@lambdatest/node-tunnel": "^4.0.8",
     "complex.js": "^2.2.5",
     "decimal.js": "^10.4.3",
     "escape-latex": "^1.2.0",
@@ -37,18 +36,18 @@
     "typed-function": "^4.2.1"
   },
   "devDependencies": {
-    "@babel/core": "7.26.0",
+    "@babel/core": "7.26.9",
     "@babel/plugin-transform-object-assign": "7.25.9",
     "@babel/plugin-transform-optional-catch-binding": "7.25.9",
-    "@babel/plugin-transform-runtime": "7.25.9",
-    "@babel/preset-env": "7.26.0",
+    "@babel/plugin-transform-runtime": "7.26.9",
+    "@babel/preset-env": "7.26.9",
     "@babel/register": "7.25.9",
     "@types/assert": "1.5.11",
     "@types/mocha": "10.0.10",
-    "@typescript-eslint/eslint-plugin": "8.21.0",
-    "@typescript-eslint/parser": "8.21.0",
+    "@typescript-eslint/eslint-plugin": "8.25.0",
+    "@typescript-eslint/parser": "8.25.0",
     "assert": "2.1.0",
-    "babel-loader": "9.2.1",
+    "babel-loader": "10.0.0",
     "c8": "10.1.3",
     "codecov": "3.8.3",
     "core-js": "3.40.0",
@@ -87,14 +86,14 @@
     "ndarray-ops": "1.2.2",
     "ndarray-pack": "1.2.1",
     "numericjs": "1.2.6",
-    "prettier": "3.4.2",
+    "prettier": "3.5.2",
     "process": "0.11.10",
     "sinon": "19.0.2",
     "sylvester": "0.0.21",
-    "tinybench": "3.1.0",
+    "tinybench": "3.1.1",
     "ts-node": "10.9.2",
     "typescript": "5.7.3",
-    "webpack": "5.97.1",
+    "webpack": "5.98.0",
     "zeros": "1.0.0"
   },
   "type": "module",

package/types/index.d.ts

@@ -1456,7 +1456,7 @@ export interface MathJsInstance extends MathJsFactory {
 
   multiply<T extends MathArray>(x: T, y: T[]): T
   multiply<T extends MathArray>(x: T[], y: T): T
-  multiply<T extends MathArray>(x: T[], y: T[]): T
+  multiply<T extends MathArray>(x: T[], y: T[]): T[]
   multiply<T extends MathArray>(x: T, y: T): MathScalarType
   multiply(x: Unit, y: Unit): Unit
   multiply(x: number, y: number): number
@@ -4006,6 +4006,7 @@ export const {
   coulombDependencies,
   deuteronMassDependencies,
   efimovFactorDependencies,
+  eigsDependencies,
   electricConstantDependencies,
   electronMassDependencies,
   elementaryChargeDependencies,