mathjs 11.5.0 → 11.6.0

package/lib/esm/function/unit/to.js

@@ -1,15 +1,17 @@
 import { factory } from '../../utils/factory.js';
 import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 var name = 'to';
-var dependencies = ['typed', 'matrix'];
+var dependencies = ['typed', 'matrix', 'concat'];
 export var createTo = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
-    matrix
+    matrix,
+    concat
   } = _ref;
   var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
     typed,
-    matrix
+    matrix,
+    concat
   });
 
   /**
@@ -23,9 +25,9 @@ export var createTo = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * Examples:
    *
-   *    math.to(math.unit('2 inch'), 'cm')                   // returns Unit 5.08 cm
-   *    math.to(math.unit('2 inch'), math.unit(null, 'cm'))  // returns Unit 5.08 cm
-   *    math.to(math.unit(16, 'bytes'), 'bits')              // returns Unit 128 bits
+   *    math.to(math.unit('2 inch'), 'cm')             // returns Unit 5.08 cm
+   *    math.to(math.unit('2 inch'), math.unit('cm'))  // returns Unit 5.08 cm
+   *    math.to(math.unit(16, 'bytes'), 'bits')        // returns Unit 128 bits
    *
    * See also:
    *

package/lib/esm/header.js

@@ -10,7 +10,7 @@
  * @date    @@date
  *
  * @license
- * Copyright (C) 2013-2022 Jos de Jong <wjosdejong@gmail.com>
+ * Copyright (C) 2013-2023 Jos de Jong <wjosdejong@gmail.com>
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy

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.0';
+export var version = '11.6.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.0",
+  "version": "11.6.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.6",
+    "@babel/runtime": "^7.21.0",
     "complex.js": "^2.1.1",
     "decimal.js": "^10.4.3",
     "escape-latex": "^1.2.0",
@@ -36,48 +36,47 @@
     "typed-function": "^4.1.0"
   },
   "devDependencies": {
-    "@babel/core": "7.20.5",
+    "@babel/core": "7.21.0",
     "@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.45.0",
-    "@typescript-eslint/parser": "5.45.0",
+    "@typescript-eslint/eslint-plugin": "5.53.0",
+    "@typescript-eslint/parser": "5.53.0",
     "assert": "2.0.0",
-    "babel-loader": "9.1.0",
+    "babel-loader": "9.1.2",
     "benchmark": "2.1.4",
+    "c8": "7.13.0",
     "codecov": "3.8.3",
-    "core-js": "3.26.1",
+    "core-js": "3.28.0",
     "del": "6.1.1",
     "dtslint": "4.2.1",
-    "eslint": "8.29.0",
-    "eslint-config-prettier": "8.5.0",
+    "eslint": "8.34.0",
+    "eslint-config-prettier": "8.6.0",
     "eslint-config-standard": "17.0.0",
-    "eslint-plugin-import": "2.26.0",
+    "eslint-plugin-import": "2.27.5",
     "eslint-plugin-mocha": "10.1.0",
-    "eslint-plugin-n": "15.6.0",
+    "eslint-plugin-n": "15.6.1",
     "eslint-plugin-prettier": "4.2.1",
     "eslint-plugin-promise": "6.1.1",
     "expect-type": "0.15.0",
     "expr-eval": "2.0.2",
     "fancy-log": "2.0.0",
-    "glob": "8.0.3",
+    "glob": "8.1.0",
     "gulp": "4.0.2",
     "gulp-babel": "8.0.0",
     "handlebars": "4.7.7",
-    "istanbul": "0.4.5",
-    "jsep": "1.3.7",
+    "jsep": "1.3.8",
     "karma": "6.4.1",
     "karma-browserstack-launcher": "1.6.0",
     "karma-firefox-launcher": "2.1.2",
     "karma-mocha": "2.0.1",
     "karma-mocha-reporter": "2.2.5",
     "karma-webpack": "5.0.0",
-    "math-expression-evaluator": "1.4.0",
-    "mkdirp": "1.0.4",
-    "mocha": "10.1.0",
+    "mkdirp": "2.1.3",
+    "mocha": "10.2.0",
     "mocha-junit-reporter": "2.2.0",
     "ndarray": "1.0.19",
     "ndarray-determinant": "1.0.0",
@@ -85,13 +84,12 @@
     "ndarray-ops": "1.2.2",
     "ndarray-pack": "1.2.1",
     "numericjs": "1.2.6",
-    "nyc": "15.1.0",
     "pad-right": "0.2.2",
-    "prettier": "2.8.0",
+    "prettier": "2.8.4",
     "process": "0.11.10",
     "sylvester": "0.0.21",
     "ts-node": "10.9.1",
-    "typescript": "4.9.3",
+    "typescript": "4.9.5",
     "webpack": "5.75.0",
     "zeros": "1.0.0"
   },
@@ -163,7 +161,7 @@
     "test:browser": "karma start test/browser-test-config/local-karma.js",
     "test:browserstack": "karma start test/browser-test-config/browserstack-karma.js",
     "test:types": " tsc -p ./tsconfig.json && node --loader ts-node/esm ./test/typescript-tests/testTypes.ts",
-    "coverage": "nyc --reporter=lcov --reporter=text-summary mocha test/unit-tests && echo \"\nDetailed coverage report is available at ./coverage/lcov-report/index.html\"",
+    "coverage": "c8 --reporter=lcov --reporter=text-summary mocha test/unit-tests && echo \"\nDetailed coverage report is available at ./coverage/lcov-report/index.html\"",
     "prepublishOnly": "npm run test:all && npm run lint",
     "update-authors": "node ./tools/update-authors.js"
   },

package/types/index.d.ts

@@ -622,7 +622,7 @@ declare namespace math {
      * complex number
      * @returns Returns a complex value
      */
-    complex(arg?: Complex | string | PolarCoordinates): Complex
+    complex(arg?: MathNumericType | string | PolarCoordinates): Complex
     complex(arg?: MathCollection): MathCollection
     /**
      * @param re Argument specifying the real part of the complex number
@@ -776,7 +776,7 @@ declare namespace math {
      * @param unit The unit to be created
      * @returns The created unit
      */
-    unit(value: number | BigNumber, unit: string): Unit
+    unit(value: number | BigNumber | Fraction | Complex, unit: string): Unit
     unit(value: MathCollection, unit: string): Unit[]
 
     /*************************************************************************
@@ -899,6 +899,8 @@ declare namespace math {
       threshold?: number
     ): MathArray
 
+    lusolve(A: LUDecomposition, b: Matrix | MathArray): Matrix
+
     /* Finds the roots of a polynomial of degree three or less. Coefficients are given constant first
      * followed by linear and higher powers in order; coefficients beyond the degree of the polynomial
      * need not be specified.
@@ -1147,7 +1149,11 @@ declare namespace math {
      * @param y Denominator
      * @returns Quotient, x ./ y
      */
-    dotDivide(x: MathType, y: MathType): MathType
+    dotDivide<T extends MathCollection>(x: T, y: MathType): T
+    dotDivide<T extends MathCollection>(x: MathType, y: T): T
+    dotDivide(x: Unit, y: MathType): Unit
+    dotDivide(x: MathType, y: Unit): Unit
+    dotDivide(x: MathNumericType, y: MathNumericType): MathNumericType
 
     /**
      * Multiply two matrices element wise. The function accepts both
@@ -1156,7 +1162,11 @@ declare namespace math {
      * @param y Right hand value
      * @returns Multiplication of x and y
      */
-    dotMultiply(x: MathType, y: MathType): MathType
+    dotMultiply<T extends MathCollection>(x: T, y: MathType): T
+    dotMultiply<T extends MathCollection>(x: MathType, y: T): T
+    dotMultiply(x: Unit, y: MathType): Unit
+    dotMultiply(x: MathType, y: Unit): Unit
+    dotMultiply(x: MathNumericType, y: MathNumericType): MathNumericType
 
     /**
      * Calculates the power of x to y element wise.
@@ -1164,7 +1174,7 @@ declare namespace math {
      * @param y The exponent
      * @returns The value of x to the power y
      */
-    dotPow(x: MathType, y: MathType): MathType
+    dotPow<T extends MathType>(x: T, y: MathType): T
 
     /**
      * Calculate the exponent of a value. For matrices, the function is
@@ -1666,7 +1676,7 @@ declare namespace math {
       w: MathCollection,
       x: MathCollection,
       y: MathCollection,
-      z: MathCollection
+      z?: MathCollection
     ): MathArray
 
     /*************************************************************************
@@ -2072,6 +2082,19 @@ declare namespace math {
       defaultValue?: number | string
     ): T
 
+    /**
+     * Return a Rotation Matrix for a given angle in radians
+     * @param {number | BigNumber | Complex | Unit} theta    Rotation angle
+     * @param {Array | Matrix} [v]                           Rotation axis
+     * @param {string} [format]                              Result Matrix storage format. Default value: 'dense'.
+     * @return {Matrix}                                      Rotation Matrix
+     */
+    rotationMatrix<T extends MathCollection>(
+      theta?: number | BigNumber | Complex | Unit,
+      axis?: T,
+      format?: 'sparse' | 'dense'
+    ): T
+
     /**
      * Return a row from a Matrix.
      * @param value An array or matrix
@@ -3771,12 +3794,12 @@ declare namespace math {
     size(): number[]
     map(
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      callback: (a: any, b: number, c: Matrix) => any,
+      callback: (a: any, b: number[], c: Matrix) => any,
       skipZeros?: boolean
     ): Matrix
     forEach(
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      callback: (a: any, b: number, c: Matrix) => void,
+      callback: (a: any, b: number[], c: Matrix) => void,
       skipZeros?: boolean
     ): void
     toArray(): MathArray
@@ -4374,7 +4397,7 @@ declare namespace math {
     unit(this: MathJsChain<string>, unit?: string): MathJsChain<Unit>
     unit(this: MathJsChain<Unit>, unit?: string): MathJsChain<Unit>
     unit(
-      this: MathJsChain<number | BigNumber>,
+      this: MathJsChain<number | BigNumber | Fraction | Complex>,
       unit?: string
     ): MathJsChain<Unit>
     unit(this: MathJsChain<MathCollection>, unit?: string): MathJsChain<Unit[]>
@@ -4504,6 +4527,11 @@ declare namespace math {
       threshold?: number
     ): MathJsChain<MathArray>
 
+    lusolve(
+      this: MathJsChain<LUDecomposition>,
+      b: Matrix | MathArray
+    ): MathJsChain<Matrix>
+
     /**
      * Calculate the Matrix QR decomposition. Matrix A is decomposed in two
      * matrices (Q, R) where Q is an orthogonal matrix and R is an upper
@@ -4724,20 +4752,49 @@ declare namespace math {
      * and scalar values.
      * @param y Denominator
      */
-    dotDivide(this: MathJsChain<MathType>, y: MathType): MathJsChain<MathType>
+    dotDivide<T extends MathCollection>(
+      this: MathJsChain<T>,
+      y: MathType
+    ): MathJsChain<T>
+    dotDivide<T extends MathCollection>(
+      this: MathJsChain<MathType>,
+      y: T
+    ): MathJsChain<T>
+    dotDivide(this: MathJsChain<Unit>, y: MathType): MathJsChain<Unit>
+    dotDivide(this: MathJsChain<MathType>, y: Unit): MathJsChain<Unit>
+    dotDivide(
+      this: MathJsChain<MathNumericType>,
+      y: MathNumericType
+    ): MathJsChain<MathNumericType>
 
     /**
      * Multiply two matrices element wise. The function accepts both
      * matrices and scalar values.
      * @param y Right hand value
      */
-    dotMultiply(this: MathJsChain<MathType>, y: MathType): MathJsChain<MathType>
+    dotMultiply<T extends MathCollection>(
+      this: MathJsChain<T>,
+      y: MathType
+    ): MathJsChain<T>
+    dotMultiply<T extends MathCollection>(
+      this: MathJsChain<MathType>,
+      y: T
+    ): MathJsChain<T>
+    dotMultiply(this: MathJsChain<Unit>, y: MathType): MathJsChain<Unit>
+    dotMultiply(this: MathJsChain<MathType>, y: Unit): MathJsChain<Unit>
+    dotMultiply(
+      this: MathJsChain<MathNumericType>,
+      y: MathNumericType
+    ): MathJsChain<MathNumericType>
 
     /**
      * Calculates the power of x to y element wise.
      * @param y The exponent
      */
-    dotPow(this: MathJsChain<MathType>, y: MathType): MathJsChain<MathType>
+    dotPow<T extends MathType>(
+      this: MathJsChain<T>,
+      y: MathType
+    ): MathJsChain<T>
 
     /**
      * Calculate the exponent of a value. For matrices, the function is
@@ -5213,7 +5270,7 @@ declare namespace math {
       this: MathJsChain<MathCollection>,
       x: MathCollection,
       y: MathCollection,
-      z: MathCollection
+      z?: MathCollection
     ): MathJsChain<MathArray>
 
     /*************************************************************************