mathjs 13.0.0 → 13.0.1

package/lib/cjs/function/matrix/eigs/complexEigs.js

@@ -606,7 +606,7 @@ function createComplexEigs(_ref) {
       b = randomOrthogonalVector(N, orthog, type);
       try {
         b = usolve(A, b);
-      } catch {
+      } catch (_unused) {
         // That direction didn't work, likely because the original matrix
         // was defective. But still make the full number of tries...
         continue;

package/lib/cjs/header.js

@@ -6,8 +6,8 @@
  * It features real and complex numbers, units, matrices, a large set of
  * mathematical functions, and a flexible expression parser.
  *
- * @version 13.0.0
- * @date    2024-05-31
+ * @version 13.0.1
+ * @date    2024-06-28
  *
  * @license
  * Copyright (C) 2013-2024 Jos de Jong <wjosdejong@gmail.com>

package/lib/cjs/type/matrix/DenseMatrix.js

@@ -345,7 +345,7 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
             submatrix = (0, _array.broadcastTo)(submatrix, iSize);
           }
           sSize = (0, _array.arraySize)(submatrix);
-        } catch {}
+        } catch (_unused) {}
       }
 
       // validate dimensions

package/lib/cjs/type/matrix/utils/broadcast.js

@@ -3,73 +3,43 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.createBroadcast = void 0;
+exports.broadcast = broadcast;
 var _array = require("../../../utils/array.js");
-var _factory = require("../../../utils/factory.js");
-const name = 'broadcast';
-const dependancies = ['concat'];
-const createBroadcast = exports.createBroadcast = /* #__PURE__ */(0, _factory.factory)(name, dependancies, _ref => {
-  let {
-    concat
-  } = _ref;
-  /**
-  * Broadcasts two matrices, and return both in an array
-  * It checks if it's possible with broadcasting rules
-  *
-  * @param {Matrix}   A      First Matrix
-  * @param {Matrix}   B      Second Matrix
-  *
-  * @return {Matrix[]}      [ broadcastedA, broadcastedB ]
-  */
-  return function (A, B) {
-    const N = Math.max(A._size.length, B._size.length); // max number of dims
-    if (A._size.length === B._size.length) {
-      if (A._size.every((dim, i) => dim === B._size[i])) {
-        // If matrices have the same size return them
-        return [A, B];
-      }
-    }
-    const sizeA = _padLeft(A._size, N, 0); // pad to the left to align dimensions to the right
-    const sizeB = _padLeft(B._size, N, 0); // pad to the left to align dimensions to the right
+var _object = require("../../../utils/object.js");
+/**
+* Broadcasts two matrices, and return both in an array
+* It checks if it's possible with broadcasting rules
+*
+* @param {Matrix}   A      First Matrix
+* @param {Matrix}   B      Second Matrix
+*
+* @return {Matrix[]}      [ broadcastedA, broadcastedB ]
+*/
 
-    // calculate the max dimensions
-    const sizeMax = [];
-    for (let dim = 0; dim < N; dim++) {
-      sizeMax[dim] = Math.max(sizeA[dim], sizeB[dim]);
-    }
-
-    // check if the broadcasting rules applyes for both matrices
-    (0, _array.checkBroadcastingRules)(sizeA, sizeMax);
-    (0, _array.checkBroadcastingRules)(sizeB, sizeMax);
+function broadcast(A, B) {
+  if ((0, _object.deepStrictEqual)(A.size(), B.size())) {
+    // If matrices have the same size return them
+    return [A, B];
+  }
 
-    // reshape A or B if needed to make them ready for concat
-    let AA = A.clone();
-    let BB = B.clone();
-    if (AA._size.length < N) {
-      AA.reshape(_padLeft(AA._size, N, 1));
-    } else if (BB._size.length < N) {
-      BB.reshape(_padLeft(BB._size, N, 1));
-    }
+  // calculate the broadcasted sizes
+  const newSize = (0, _array.broadcastSizes)(A.size(), B.size());
 
-    // stretches the matrices on each dimension to make them the same size
-    for (let dim = 0; dim < N; dim++) {
-      if (AA._size[dim] < sizeMax[dim]) {
-        AA = _stretch(AA, sizeMax[dim], dim);
-      }
-      if (BB._size[dim] < sizeMax[dim]) {
-        BB = _stretch(BB, sizeMax[dim], dim);
-      }
-    }
+  // return the array with the two broadcasted matrices
+  return [A, B].map(M => _broadcastTo(M, newSize));
+}
 
-    // return the array with the two broadcasted matrices
-    return [AA, BB];
-  };
-  function _padLeft(shape, N, filler) {
-    // pads an array of dimensions with numbers to the left, unitl the number of dimensions is N
-    return [...Array(N - shape.length).fill(filler), ...shape];
-  }
-  function _stretch(arrayToStretch, sizeToStretch, dimToStretch) {
-    // stretches a matrix up to a certain size in a certain dimension
-    return concat(...Array(sizeToStretch).fill(arrayToStretch), dimToStretch);
+/**
+ * Broadcasts a matrix to the given size.
+ *
+ * @param {Matrix} M - The matrix to be broadcasted.
+ * @param {number[]} size - The desired size of the broadcasted matrix.
+ * @returns {Matrix} The broadcasted matrix.
+ * @throws {Error} If the size parameter is not an array of numbers.
+ */
+function _broadcastTo(M, size) {
+  if ((0, _object.deepStrictEqual)(M.size(), size)) {
+    return M;
   }
-});
+  return M.create((0, _array.broadcastTo)(M.valueOf(), size), M.datatype());
+}

package/lib/cjs/type/matrix/utils/matrixAlgorithmSuite.js

@@ -10,12 +10,11 @@ var _matAlgo13xDD = require("./matAlgo13xDD.js");
 var _matAlgo14xDs = require("./matAlgo14xDs.js");
 var _broadcast = require("./broadcast.js");
 const name = 'matrixAlgorithmSuite';
-const dependencies = ['typed', 'matrix', 'concat'];
+const dependencies = ['typed', 'matrix'];
 const createMatrixAlgorithmSuite = exports.createMatrixAlgorithmSuite = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
     typed,
-    matrix,
-    concat
+    matrix
   } = _ref;
   const matAlgo13xDD = (0, _matAlgo13xDD.createMatAlgo13xDD)({
     typed
@@ -23,9 +22,6 @@ const createMatrixAlgorithmSuite = exports.createMatrixAlgorithmSuite = /* #__PU
   const matAlgo14xDs = (0, _matAlgo14xDs.createMatAlgo14xDs)({
     typed
   });
-  const broadcast = (0, _broadcast.createBroadcast)({
-    concat
-  });
 
   /**
    * Return a signatures object with the usual boilerplate of
@@ -51,60 +47,60 @@ const createMatrixAlgorithmSuite = exports.createMatrixAlgorithmSuite = /* #__PU
     if (elop) {
       // First the dense ones
       matrixSignatures = {
-        'DenseMatrix, DenseMatrix': (x, y) => matAlgo13xDD(...broadcast(x, y), elop),
-        'Array, Array': (x, y) => matAlgo13xDD(...broadcast(matrix(x), matrix(y)), elop).valueOf(),
-        'Array, DenseMatrix': (x, y) => matAlgo13xDD(...broadcast(matrix(x), y), elop),
-        'DenseMatrix, Array': (x, y) => matAlgo13xDD(...broadcast(x, matrix(y)), elop)
+        'DenseMatrix, DenseMatrix': (x, y) => matAlgo13xDD(...(0, _broadcast.broadcast)(x, y), elop),
+        'Array, Array': (x, y) => matAlgo13xDD(...(0, _broadcast.broadcast)(matrix(x), matrix(y)), elop).valueOf(),
+        'Array, DenseMatrix': (x, y) => matAlgo13xDD(...(0, _broadcast.broadcast)(matrix(x), y), elop),
+        'DenseMatrix, Array': (x, y) => matAlgo13xDD(...(0, _broadcast.broadcast)(x, matrix(y)), elop)
       };
       // Now incorporate sparse matrices
       if (options.SS) {
-        matrixSignatures['SparseMatrix, SparseMatrix'] = (x, y) => options.SS(...broadcast(x, y), elop, false);
+        matrixSignatures['SparseMatrix, SparseMatrix'] = (x, y) => options.SS(...(0, _broadcast.broadcast)(x, y), elop, false);
       }
       if (options.DS) {
-        matrixSignatures['DenseMatrix, SparseMatrix'] = (x, y) => options.DS(...broadcast(x, y), elop, false);
-        matrixSignatures['Array, SparseMatrix'] = (x, y) => options.DS(...broadcast(matrix(x), y), elop, false);
+        matrixSignatures['DenseMatrix, SparseMatrix'] = (x, y) => options.DS(...(0, _broadcast.broadcast)(x, y), elop, false);
+        matrixSignatures['Array, SparseMatrix'] = (x, y) => options.DS(...(0, _broadcast.broadcast)(matrix(x), y), elop, false);
       }
       if (SD) {
-        matrixSignatures['SparseMatrix, DenseMatrix'] = (x, y) => SD(...broadcast(y, x), elop, true);
-        matrixSignatures['SparseMatrix, Array'] = (x, y) => SD(...broadcast(matrix(y), x), elop, true);
+        matrixSignatures['SparseMatrix, DenseMatrix'] = (x, y) => SD(...(0, _broadcast.broadcast)(y, x), elop, true);
+        matrixSignatures['SparseMatrix, Array'] = (x, y) => SD(...(0, _broadcast.broadcast)(matrix(y), x), elop, true);
       }
     } else {
       // No elop, use this
       // First the dense ones
       matrixSignatures = {
         'DenseMatrix, DenseMatrix': typed.referToSelf(self => (x, y) => {
-          return matAlgo13xDD(...broadcast(x, y), self);
+          return matAlgo13xDD(...(0, _broadcast.broadcast)(x, y), self);
         }),
         'Array, Array': typed.referToSelf(self => (x, y) => {
-          return matAlgo13xDD(...broadcast(matrix(x), matrix(y)), self).valueOf();
+          return matAlgo13xDD(...(0, _broadcast.broadcast)(matrix(x), matrix(y)), self).valueOf();
         }),
         'Array, DenseMatrix': typed.referToSelf(self => (x, y) => {
-          return matAlgo13xDD(...broadcast(matrix(x), y), self);
+          return matAlgo13xDD(...(0, _broadcast.broadcast)(matrix(x), y), self);
         }),
         'DenseMatrix, Array': typed.referToSelf(self => (x, y) => {
-          return matAlgo13xDD(...broadcast(x, matrix(y)), self);
+          return matAlgo13xDD(...(0, _broadcast.broadcast)(x, matrix(y)), self);
         })
       };
       // Now incorporate sparse matrices
       if (options.SS) {
         matrixSignatures['SparseMatrix, SparseMatrix'] = typed.referToSelf(self => (x, y) => {
-          return options.SS(...broadcast(x, y), self, false);
+          return options.SS(...(0, _broadcast.broadcast)(x, y), self, false);
         });
       }
       if (options.DS) {
         matrixSignatures['DenseMatrix, SparseMatrix'] = typed.referToSelf(self => (x, y) => {
-          return options.DS(...broadcast(x, y), self, false);
+          return options.DS(...(0, _broadcast.broadcast)(x, y), self, false);
         });
         matrixSignatures['Array, SparseMatrix'] = typed.referToSelf(self => (x, y) => {
-          return options.DS(...broadcast(matrix(x), y), self, false);
+          return options.DS(...(0, _broadcast.broadcast)(matrix(x), y), self, false);
         });
       }
       if (SD) {
         matrixSignatures['SparseMatrix, DenseMatrix'] = typed.referToSelf(self => (x, y) => {
-          return SD(...broadcast(y, x), self, true);
+          return SD(...(0, _broadcast.broadcast)(y, x), self, true);
         });
         matrixSignatures['SparseMatrix, Array'] = typed.referToSelf(self => (x, y) => {
-          return SD(...broadcast(matrix(y), x), self, true);
+          return SD(...(0, _broadcast.broadcast)(matrix(y), x), self, true);
         });
       }
     }

package/lib/cjs/version.js

@@ -4,6 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.version = void 0;
-const version = exports.version = '13.0.0';
+const version = exports.version = '13.0.1';
 // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.

package/lib/esm/type/matrix/utils/broadcast.js

@@ -1,69 +1,40 @@
-import { checkBroadcastingRules } from '../../../utils/array.js';
-import { factory } from '../../../utils/factory.js';
-var name = 'broadcast';
-var dependancies = ['concat'];
-export var createBroadcast = /* #__PURE__ */factory(name, dependancies, _ref => {
-  var {
-    concat
-  } = _ref;
-  /**
-  * Broadcasts two matrices, and return both in an array
-  * It checks if it's possible with broadcasting rules
-  *
-  * @param {Matrix}   A      First Matrix
-  * @param {Matrix}   B      Second Matrix
-  *
-  * @return {Matrix[]}      [ broadcastedA, broadcastedB ]
-  */
-  return function (A, B) {
-    var N = Math.max(A._size.length, B._size.length); // max number of dims
-    if (A._size.length === B._size.length) {
-      if (A._size.every((dim, i) => dim === B._size[i])) {
-        // If matrices have the same size return them
-        return [A, B];
-      }
-    }
-    var sizeA = _padLeft(A._size, N, 0); // pad to the left to align dimensions to the right
-    var sizeB = _padLeft(B._size, N, 0); // pad to the left to align dimensions to the right
+import { broadcastSizes, broadcastTo } from '../../../utils/array.js';
+import { deepStrictEqual } from '../../../utils/object.js';
 
-    // calculate the max dimensions
-    var sizeMax = [];
-    for (var dim = 0; dim < N; dim++) {
-      sizeMax[dim] = Math.max(sizeA[dim], sizeB[dim]);
-    }
+/**
+* Broadcasts two matrices, and return both in an array
+* It checks if it's possible with broadcasting rules
+*
+* @param {Matrix}   A      First Matrix
+* @param {Matrix}   B      Second Matrix
+*
+* @return {Matrix[]}      [ broadcastedA, broadcastedB ]
+*/
 
-    // check if the broadcasting rules applyes for both matrices
-    checkBroadcastingRules(sizeA, sizeMax);
-    checkBroadcastingRules(sizeB, sizeMax);
+export function broadcast(A, B) {
+  if (deepStrictEqual(A.size(), B.size())) {
+    // If matrices have the same size return them
+    return [A, B];
+  }
 
-    // reshape A or B if needed to make them ready for concat
-    var AA = A.clone();
-    var BB = B.clone();
-    if (AA._size.length < N) {
-      AA.reshape(_padLeft(AA._size, N, 1));
-    } else if (BB._size.length < N) {
-      BB.reshape(_padLeft(BB._size, N, 1));
-    }
+  // calculate the broadcasted sizes
+  var newSize = broadcastSizes(A.size(), B.size());
 
-    // stretches the matrices on each dimension to make them the same size
-    for (var _dim = 0; _dim < N; _dim++) {
-      if (AA._size[_dim] < sizeMax[_dim]) {
-        AA = _stretch(AA, sizeMax[_dim], _dim);
-      }
-      if (BB._size[_dim] < sizeMax[_dim]) {
-        BB = _stretch(BB, sizeMax[_dim], _dim);
-      }
-    }
+  // return the array with the two broadcasted matrices
+  return [A, B].map(M => _broadcastTo(M, newSize));
+}
 
-    // return the array with the two broadcasted matrices
-    return [AA, BB];
-  };
-  function _padLeft(shape, N, filler) {
-    // pads an array of dimensions with numbers to the left, unitl the number of dimensions is N
-    return [...Array(N - shape.length).fill(filler), ...shape];
-  }
-  function _stretch(arrayToStretch, sizeToStretch, dimToStretch) {
-    // stretches a matrix up to a certain size in a certain dimension
-    return concat(...Array(sizeToStretch).fill(arrayToStretch), dimToStretch);
+/**
+ * Broadcasts a matrix to the given size.
+ *
+ * @param {Matrix} M - The matrix to be broadcasted.
+ * @param {number[]} size - The desired size of the broadcasted matrix.
+ * @returns {Matrix} The broadcasted matrix.
+ * @throws {Error} If the size parameter is not an array of numbers.
+ */
+function _broadcastTo(M, size) {
+  if (deepStrictEqual(M.size(), size)) {
+    return M;
   }
-});
+  return M.create(broadcastTo(M.valueOf(), size), M.datatype());
+}

package/lib/esm/type/matrix/utils/matrixAlgorithmSuite.js

@@ -2,14 +2,13 @@ import { factory } from '../../../utils/factory.js';
 import { extend } from '../../../utils/object.js';
 import { createMatAlgo13xDD } from './matAlgo13xDD.js';
 import { createMatAlgo14xDs } from './matAlgo14xDs.js';
-import { createBroadcast } from './broadcast.js';
+import { broadcast } from './broadcast.js';
 var name = 'matrixAlgorithmSuite';
-var dependencies = ['typed', 'matrix', 'concat'];
+var dependencies = ['typed', 'matrix'];
 export var createMatrixAlgorithmSuite = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
-    matrix,
-    concat
+    matrix
   } = _ref;
   var matAlgo13xDD = createMatAlgo13xDD({
     typed
@@ -17,9 +16,6 @@ export var createMatrixAlgorithmSuite = /* #__PURE__ */factory(name, dependencie
   var matAlgo14xDs = createMatAlgo14xDs({
     typed
   });
-  var broadcast = createBroadcast({
-    concat
-  });
 
   /**
    * Return a signatures object with the usual boilerplate of

package/lib/esm/version.js

@@ -1,3 +1,3 @@
-export var version = '13.0.0';
+export var version = '13.0.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": "13.0.0",
+  "version": "13.0.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",
@@ -25,7 +25,7 @@
     "unit"
   ],
   "dependencies": {
-    "@babel/runtime": "^7.24.6",
+    "@babel/runtime": "^7.24.7",
     "complex.js": "^2.1.1",
     "decimal.js": "^10.4.3",
     "escape-latex": "^1.2.0",
@@ -33,22 +33,23 @@
     "javascript-natural-sort": "^0.7.1",
     "seedrandom": "^3.0.5",
     "tiny-emitter": "^2.1.0",
-    "typed-function": "^4.1.1"
+    "typed-function": "^4.2.1"
   },
   "devDependencies": {
-    "@babel/core": "7.24.6",
-    "@babel/plugin-transform-object-assign": "7.24.6",
-    "@babel/plugin-transform-runtime": "7.24.6",
-    "@babel/preset-env": "7.24.6",
+    "@babel/core": "7.24.7",
+    "@babel/plugin-transform-object-assign": "7.24.7",
+    "@babel/plugin-transform-optional-catch-binding": "7.24.7",
+    "@babel/plugin-transform-runtime": "7.24.7",
+    "@babel/preset-env": "7.24.7",
     "@babel/register": "7.24.6",
     "@types/assert": "1.5.10",
-    "@types/mocha": "10.0.6",
-    "@typescript-eslint/eslint-plugin": "7.11.0",
-    "@typescript-eslint/parser": "7.11.0",
+    "@types/mocha": "10.0.7",
+    "@typescript-eslint/eslint-plugin": "7.14.1",
+    "@typescript-eslint/parser": "7.14.1",
     "assert": "2.1.0",
     "babel-loader": "9.1.3",
     "benchmark": "2.1.4",
-    "c8": "9.1.0",
+    "c8": "10.1.2",
     "codecov": "3.8.3",
     "core-js": "3.37.1",
     "del": "7.1.0",
@@ -64,7 +65,7 @@
     "expect-type": "0.19.0",
     "expr-eval": "2.0.2",
     "fancy-log": "2.0.0",
-    "glob": "10.4.1",
+    "glob": "10.4.2",
     "gulp": "5.0.0",
     "gulp-babel": "8.0.0",
     "handlebars": "4.7.8",
@@ -76,7 +77,7 @@
     "karma-mocha-reporter": "2.2.5",
     "karma-webpack": "5.0.1",
     "mkdirp": "3.0.1",
-    "mocha": "10.4.0",
+    "mocha": "10.5.2",
     "mocha-junit-reporter": "2.2.1",
     "ndarray": "1.0.19",
     "ndarray-determinant": "1.0.0",
@@ -85,13 +86,13 @@
     "ndarray-pack": "1.2.1",
     "numericjs": "1.2.6",
     "pad-right": "0.2.2",
-    "prettier": "3.2.5",
+    "prettier": "3.3.2",
     "process": "0.11.10",
     "sinon": "18.0.0",
     "sylvester": "0.0.21",
     "ts-node": "10.9.2",
-    "typescript": "5.4.5",
-    "webpack": "5.91.0",
+    "typescript": "5.5.2",
+    "webpack": "5.92.1",
     "zeros": "1.0.0"
   },
   "type": "module",

package/types/index.d.ts

@@ -4292,14 +4292,44 @@ export interface MathNode {
 }
 
 export interface Parser {
+  /**
+   * Evaluate an expression. Returns the result of the expression.
+   * @param expr The expression to evaluate
+   */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   evaluate(expr: string | string[]): any
+  /**
+   * Retrieve a variable or function from the parser’s scope.
+   * @param name The name of the variable or function to be retrieved
+   */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  get(variable: string): any
+  get(name: string): any
+  /**
+   * Retrieve an object with all defined variables in the parser’s scope.
+   * @returns An object with all defined variables
+   */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   getAll(): { [key: string]: any }
+  /**
+   * Retrieve a map with all defined variables in the parser’s scope.
+   */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  set: (variable: string, value: any) => void
+  getAllAsMap(): Map<string, any>
+  /**
+   * Set a variable or function in the parser’s scope.
+   * @param name The name of the variable or function to be set
+   * @param value The value of the variable or function to be set
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  set: (name: string, value: any) => void
+  /**
+   * Remove a variable or function from the parser’s scope.
+   * @param name The name of the variable or function to be removed
+   */
+  remove: (name: string) => void
+  /**
+   * Completely clear the parser’s scope.
+   */
   clear: () => void
 }