mathjs 14.8.1 → 14.9.0

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/utils/optimizeCallback.js

@@ -8,11 +8,10 @@ import { typeOf as _typeOf } from './is.js';
  * @param {Function} callback The original callback function to simplify.
  * @param {Array|Matrix} array The array that will be used with the callback function.
  * @param {string} name The name of the function that is using the callback.
- * @param {boolean} [isUnary=false] If true, the callback function is unary and will be optimized as such.
+ * @param {boolean} isUnary If true, the callback function is unary and will be optimized as such.
  * @returns {Function} Returns a simplified version of the callback function.
  */
-export function optimizeCallback(callback, array, name) {
-  var isUnary = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+export function optimizeCallback(callback, array, name, isUnary) {
   if (typed.isTypedFunction(callback)) {
     var numberOfArguments;
     if (isUnary) {

package/lib/esm/version.js

@@ -1,3 +1,3 @@
-export var version = '14.8.1';
+export var version = '14.9.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.8.1",
+  "version": "14.9.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",
@@ -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",

package/types/index.d.ts

@@ -1093,7 +1093,7 @@ export interface MathJsInstance extends MathJsFactory {
    * decomposition.
    * @param order The Symbolic Ordering and Analysis order: 0 - Natural
    * ordering, no permutation vector q is returned 1 - Matrix must be
-   * square, symbolic ordering and analisis is performed on M = A + A' 2 -
+   * square, symbolic ordering and analysis is performed on M = A + A' 2 -
    * Symbolic ordering and analysis is performed on M = A' * A. Dense
    * columns from A' are dropped, A recreated from A'. This is appropriate
    * for LU factorization of non-symmetric matrices. 3 - Symbolic ordering
@@ -1126,6 +1126,7 @@ export interface MathJsInstance extends MathJsFactory {
    * @param x A number or matrix for which to get the absolute value
    * @returns Absolute value of x
    */
+  abs(x: Complex): number
   abs<T extends MathType>(x: T): T
 
   /**
@@ -1328,7 +1329,7 @@ export interface MathJsInstance extends MathJsFactory {
    * @param args A list with numeric values or an Array or Matrix. Matrix
    * and Array input is flattened and returns a single number for the
    * whole matrix.
-   * @returns Returns the hypothenuse of the input values.
+   * @returns Returns the hypotenuse of the input values.
    */
   hypot<T extends number | BigNumber>(...args: T[]): T
   hypot<T extends number | BigNumber>(args: T[]): T
@@ -1546,7 +1547,7 @@ export interface MathJsInstance extends MathJsFactory {
    * strings will be converted to a number. For complex numbers, both real
    * and complex value are inverted.
    * @param x Number to be inverted
-   * @returns Retursn the value with inverted sign
+   * @returns Returns the value with inverted sign
    */
   unaryMinus<T extends MathType>(x: T): T
 
@@ -1757,7 +1758,7 @@ export interface MathJsInstance extends MathJsFactory {
    ************************************************************************/
 
   /**
-   * Calculates: The eucledian distance between two points in 2 and 3
+   * Calculates: The Euclidean distance between two points in 2 and 3
    * dimensional spaces. Distance between point and a line in 2 and 3
    * dimensional spaces. Pairwise distance between a set of 2D or 3D
    * points NOTE: When substituting coefficients of a line(a, b and c),
@@ -1897,6 +1898,14 @@ export interface MathJsInstance extends MathJsFactory {
    */
   cross(x: MathCollection, y: MathCollection): MathCollection
 
+  /**
+   * Transpose and complex conjugate a matrix. All values of the matrix are
+   * reflected over its main diagonal and then the complex conjugate is taken.
+   * This is equivalent to complex conjugation for scalars and vectors.
+   * @param x Matrix to be ctransposed
+   */
+  ctranspose(x: MathCollection): MathCollection
+
   /**
    * Calculate the determinant of a matrix.
    * @param x A Matrix
@@ -2081,7 +2090,7 @@ export interface MathJsInstance extends MathJsFactory {
 
   /**
    * Calculate the inverse of a square matrix.
-   * @param x Matrix to be inversed
+   * @param x Matrix to be inverted
    * @returns The inverse of x
    */
   inv<T extends number | Complex | MathCollection>(x: T): NoLiteralType<T>
@@ -2190,7 +2199,7 @@ export interface MathJsInstance extends MathJsFactory {
 
   /**
    * Calculate the Moore–Penrose inverse of a matrix.
-   * @param x Matrix to be inversed
+   * @param x Matrix to be inverted
    * @return The inverse of `x`.
    */
   pinv<T extends MathType>(x: T): T
@@ -2457,7 +2466,7 @@ export interface MathJsInstance extends MathJsFactory {
    * distributions
    * @param q First vector
    * @param p Second vector
-   * @returns Returns disance between q and p
+   * @returns Returns distance between q and p
    */
   kldivergence(q: MathCollection, p: MathCollection): number
 
@@ -2474,7 +2483,7 @@ export interface MathJsInstance extends MathJsFactory {
    * takes one array of integers as an argument. The following condition
    * must be enforced: every ai <= 0
    * @param a Integer number of objects in the subset
-   * @returns multinomial coefficent
+   * @returns multinomial coefficient
    */
   multinomial<T extends number | BigNumber>(a: T[]): NoLiteralType<T>
 
@@ -2579,7 +2588,7 @@ export interface MathJsInstance extends MathJsFactory {
    * Test element wise whether two matrices are equal. The function
    * accepts both matrices and scalar values.
    * @param x First matrix to compare
-   * @param y Second amtrix to compare
+   * @param y Second matrix to compare
    * @returns Returns true when the input matrices have the same size and
    * each of their elements is equal.
    */
@@ -2621,7 +2630,7 @@ export interface MathJsInstance extends MathJsFactory {
    * compare values smaller than approximately 2.22e-16. For matrices, the
    * function is evaluated element wise.
    * @param x First value to compare
-   * @param y Second value to vcompare
+   * @param y Second value to compare
    * @returns Returns true when x is larger than y, else returns false
    */
   larger(x: MathType | string, y: MathType | string): boolean | MathCollection
@@ -2633,7 +2642,7 @@ export interface MathJsInstance extends MathJsFactory {
    * to compare values smaller than approximately 2.22e-16. For matrices,
    * the function is evaluated element wise.
    * @param x First value to compare
-   * @param y Second value to vcompare
+   * @param y Second value to compare
    * @returns Returns true when x is larger than or equal to y, else
    * returns false
    */
@@ -2646,7 +2655,7 @@ export interface MathJsInstance extends MathJsFactory {
    * to compare values smaller than approximately 2.22e-16. For matrices,
    * the function is evaluated element wise.
    * @param x First value to compare
-   * @param y Second value to vcompare
+   * @param y Second value to compare
    * @returns Returns true when x is smaller than y, else returns false
    */
   smaller(x: MathType | string, y: MathType | string): boolean | MathCollection
@@ -2658,7 +2667,7 @@ export interface MathJsInstance extends MathJsFactory {
    * used to compare values smaller than approximately 2.22e-16. For
    * matrices, the function is evaluated element wise.
    * @param x First value to compare
-   * @param y Second value to vcompare
+   * @param y Second value to compare
    * @returns Returns true when x is smaller than or equal to y, else
    * returns false
    */
@@ -2692,7 +2701,7 @@ export interface MathJsInstance extends MathJsFactory {
    * strictly, thus null is unequal with everything except null, and
    * undefined is unequal with everything except undefined.
    * @param x First value to compare
-   * @param y Second value to vcompare
+   * @param y Second value to compare
    * @returns Returns true when the compared values are unequal, else
    * returns false
    */
@@ -5076,6 +5085,7 @@ export interface MathJsChain<TValue> {
    * Calculate the absolute value of a number. For matrices, the function
    * is evaluated element wise.
    */
+  abs(this: MathJsChain<Complex>): MathJsChain<number>
   abs<T extends MathType>(this: MathJsChain<T>): MathJsChain<T>
 
   /**
@@ -5814,6 +5824,13 @@ export interface MathJsChain<TValue> {
     y: MathCollection
   ): MathJsChain<MathCollection>
 
+  /**
+   * Transpose and complex conjugate a matrix. All values of the matrix are
+   * reflected over its main diagonal and then the complex conjugate is taken.
+   * This is equivalent to complex conjugation for scalars and vectors.
+   */
+  ctranspose(this: MathJsChain<MathCollection>): MathJsChain<MathCollection>
+
   /**
    * Calculate the difference between adjacent elements of the chained matrix or array.
    * @param dim The dimension to apply the difference on.
@@ -7300,6 +7317,7 @@ export const {
   apply, // @deprecated prior name of mapSlices
   concat,
   cross,
+  ctranspose,
   det,
   diag,
   dot,