mathjs 11.5.1 → 11.7.0

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

@@ -0,0 +1,75 @@
+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
+
+    // calculate the max dimensions
+    var sizeMax = [];
+    for (var dim = 0; dim < N; dim++) {
+      sizeMax[dim] = Math.max(sizeA[dim], sizeB[dim]);
+    }
+
+    // check if the broadcasting rules applyes for both matrices
+    for (var _dim = 0; _dim < N; _dim++) {
+      _checkRules(sizeA, sizeMax, _dim);
+      _checkRules(sizeB, sizeMax, _dim);
+    }
+
+    // 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));
+    }
+
+    // stretches the matrices on each dimension to make them the same size
+    for (var _dim2 = 0; _dim2 < N; _dim2++) {
+      if (AA._size[_dim2] < sizeMax[_dim2]) {
+        AA = _stretch(AA, sizeMax[_dim2], _dim2);
+      }
+      if (BB._size[_dim2] < sizeMax[_dim2]) {
+        BB = _stretch(BB, sizeMax[_dim2], _dim2);
+      }
+    }
+
+    // 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);
+  }
+  function _checkRules(shape, sizeMax, dim) {
+    if (shape[dim] < sizeMax[dim] & shape[dim] > 1) {
+      throw new Error("shape missmatch: missmatch is found in arg with shape (".concat(shape, ") not possible to broadcast dimension ").concat(dim, " with size ").concat(shape[dim], " to size ").concat(sizeMax[dim]));
+    }
+  }
+});

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

@@ -2,12 +2,14 @@ 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';
 var name = 'matrixAlgorithmSuite';
-var dependencies = ['typed', 'matrix'];
+var dependencies = ['typed', 'matrix', 'concat'];
 export var createMatrixAlgorithmSuite = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
-    matrix
+    matrix,
+    concat
   } = _ref;
   var matAlgo13xDD = createMatAlgo13xDD({
     typed
@@ -15,6 +17,9 @@ export var createMatrixAlgorithmSuite = /* #__PURE__ */factory(name, dependencie
   var matAlgo14xDs = createMatAlgo14xDs({
     typed
   });
+  var broadcast = createBroadcast({
+    concat
+  });
 
   /**
    * Return a signatures object with the usual boilerplate of
@@ -40,60 +45,60 @@ export var createMatrixAlgorithmSuite = /* #__PURE__ */factory(name, dependencie
     if (elop) {
       // First the dense ones
       matrixSignatures = {
-        'DenseMatrix, DenseMatrix': (x, y) => matAlgo13xDD(x, y, elop),
-        'Array, Array': (x, y) => matAlgo13xDD(matrix(x), matrix(y), elop).valueOf(),
-        'Array, DenseMatrix': (x, y) => matAlgo13xDD(matrix(x), y, elop),
-        'DenseMatrix, Array': (x, y) => matAlgo13xDD(x, matrix(y), elop)
+        '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)
       };
       // Now incorporate sparse matrices
       if (options.SS) {
-        matrixSignatures['SparseMatrix, SparseMatrix'] = (x, y) => options.SS(x, y, elop, false);
+        matrixSignatures['SparseMatrix, SparseMatrix'] = (x, y) => options.SS(...broadcast(x, y), elop, false);
       }
       if (options.DS) {
-        matrixSignatures['DenseMatrix, SparseMatrix'] = (x, y) => options.DS(x, y, elop, false);
-        matrixSignatures['Array, SparseMatrix'] = (x, y) => options.DS(matrix(x), y, elop, false);
+        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);
       }
       if (SD) {
-        matrixSignatures['SparseMatrix, DenseMatrix'] = (x, y) => SD(y, x, elop, true);
-        matrixSignatures['SparseMatrix, Array'] = (x, y) => SD(matrix(y), x, elop, true);
+        matrixSignatures['SparseMatrix, DenseMatrix'] = (x, y) => SD(...broadcast(y, x), elop, true);
+        matrixSignatures['SparseMatrix, Array'] = (x, y) => SD(...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(x, y, self);
+          return matAlgo13xDD(...broadcast(x, y), self);
         }),
         'Array, Array': typed.referToSelf(self => (x, y) => {
-          return matAlgo13xDD(matrix(x), matrix(y), self).valueOf();
+          return matAlgo13xDD(...broadcast(matrix(x), matrix(y)), self).valueOf();
         }),
         'Array, DenseMatrix': typed.referToSelf(self => (x, y) => {
-          return matAlgo13xDD(matrix(x), y, self);
+          return matAlgo13xDD(...broadcast(matrix(x), y), self);
         }),
         'DenseMatrix, Array': typed.referToSelf(self => (x, y) => {
-          return matAlgo13xDD(x, matrix(y), self);
+          return matAlgo13xDD(...broadcast(x, matrix(y)), self);
         })
       };
       // Now incorporate sparse matrices
       if (options.SS) {
         matrixSignatures['SparseMatrix, SparseMatrix'] = typed.referToSelf(self => (x, y) => {
-          return options.SS(x, y, self, false);
+          return options.SS(...broadcast(x, y), self, false);
         });
       }
       if (options.DS) {
         matrixSignatures['DenseMatrix, SparseMatrix'] = typed.referToSelf(self => (x, y) => {
-          return options.DS(x, y, self, false);
+          return options.DS(...broadcast(x, y), self, false);
         });
         matrixSignatures['Array, SparseMatrix'] = typed.referToSelf(self => (x, y) => {
-          return options.DS(matrix(x), y, self, false);
+          return options.DS(...broadcast(matrix(x), y), self, false);
         });
       }
       if (SD) {
         matrixSignatures['SparseMatrix, DenseMatrix'] = typed.referToSelf(self => (x, y) => {
-          return SD(y, x, self, true);
+          return SD(...broadcast(y, x), self, true);
         });
         matrixSignatures['SparseMatrix, Array'] = typed.referToSelf(self => (x, y) => {
-          return SD(matrix(y), x, self, true);
+          return SD(...broadcast(matrix(y), x), self, true);
         });
       }
     }

package/lib/esm/version.js

@@ -1,3 +1,3 @@
-export var version = '11.5.1';
+export var version = '11.7.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": "11.5.1",
+  "version": "11.7.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",
@@ -25,7 +25,7 @@
     "unit"
   ],
   "dependencies": {
-    "@babel/runtime": "^7.20.13",
+    "@babel/runtime": "^7.21.0",
     "complex.js": "^2.1.1",
     "decimal.js": "^10.4.3",
     "escape-latex": "^1.2.0",
@@ -36,25 +36,25 @@
     "typed-function": "^4.1.0"
   },
   "devDependencies": {
-    "@babel/core": "7.20.12",
+    "@babel/core": "7.21.3",
     "@babel/plugin-transform-object-assign": "7.18.6",
-    "@babel/plugin-transform-runtime": "7.19.6",
+    "@babel/plugin-transform-runtime": "7.21.0",
     "@babel/preset-env": "7.20.2",
-    "@babel/register": "7.18.9",
+    "@babel/register": "7.21.0",
     "@types/assert": "1.5.6",
     "@types/mocha": "10.0.1",
-    "@typescript-eslint/eslint-plugin": "5.50.0",
-    "@typescript-eslint/parser": "5.50.0",
+    "@typescript-eslint/eslint-plugin": "5.55.0",
+    "@typescript-eslint/parser": "5.55.0",
     "assert": "2.0.0",
     "babel-loader": "9.1.2",
     "benchmark": "2.1.4",
-    "c8": "7.12.0",
+    "c8": "7.13.0",
     "codecov": "3.8.3",
-    "core-js": "3.27.2",
+    "core-js": "3.29.1",
     "del": "6.1.1",
     "dtslint": "4.2.1",
-    "eslint": "8.33.0",
-    "eslint-config-prettier": "8.6.0",
+    "eslint": "8.36.0",
+    "eslint-config-prettier": "8.7.0",
     "eslint-config-standard": "17.0.0",
     "eslint-plugin-import": "2.27.5",
     "eslint-plugin-mocha": "10.1.0",
@@ -75,7 +75,7 @@
     "karma-mocha": "2.0.1",
     "karma-mocha-reporter": "2.2.5",
     "karma-webpack": "5.0.0",
-    "mkdirp": "2.1.3",
+    "mkdirp": "2.1.5",
     "mocha": "10.2.0",
     "mocha-junit-reporter": "2.2.0",
     "ndarray": "1.0.19",
@@ -85,12 +85,12 @@
     "ndarray-pack": "1.2.1",
     "numericjs": "1.2.6",
     "pad-right": "0.2.2",
-    "prettier": "2.8.3",
+    "prettier": "2.8.4",
     "process": "0.11.10",
     "sylvester": "0.0.21",
     "ts-node": "10.9.1",
     "typescript": "4.9.5",
-    "webpack": "5.75.0",
+    "webpack": "5.76.1",
     "zeros": "1.0.0"
   },
   "type": "module",