mathjs 11.3.3 → 11.4.0

package/lib/esm/function/algebra/sylvester.js

@@ -0,0 +1,118 @@
+import { factory } from '../../utils/factory.js';
+var name = 'sylvester';
+var dependencies = ['typed', 'schur', 'matrixFromColumns', 'matrix', 'multiply', 'range', 'concat', 'transpose', 'index', 'subset', 'add', 'subtract', 'identity', 'lusolve', 'abs'];
+export var createSylvester = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    schur,
+    matrixFromColumns,
+    matrix,
+    multiply,
+    range,
+    concat,
+    transpose,
+    index,
+    subset,
+    add,
+    subtract,
+    identity,
+    lusolve,
+    abs
+  } = _ref;
+  /**
+   *
+   * Solves the real-valued Sylvester equation AX+XB=C for X, where A, B and C are
+   * matrices of appropriate dimensions, being A and B squared. Notice that other
+   * equivalent definitions for the Sylvester equation exist and this function
+   * assumes the one presented in the original publication of the the Bartels-
+   * Stewart algorithm, which is implemented by this function.
+   * https://en.wikipedia.org/wiki/Sylvester_equation
+   *
+   * Syntax:
+   *
+   *     math.sylvester(A, B, C)
+   *
+   * Examples:
+   *
+   *     const A = [[-1, -2], [1, 1]]
+   *     const B = [[2, -1], [1, -2]]
+   *     const C = [[-3, 2], [3, 0]]
+   *     math.sylvester(A, B, C)      // returns DenseMatrix [[-0.25, 0.25], [1.5, -1.25]]
+   *
+   * See also:
+   *
+   *     schur, lyap
+   *
+   * @param {Matrix | Array} A  Matrix A
+   * @param {Matrix | Array} B  Matrix B
+   * @param {Matrix | Array} C  Matrix C
+   * @return {Matrix | Array}   Matrix X, solving the Sylvester equation
+   */
+  return typed(name, {
+    'Matrix, Matrix, Matrix': _sylvester,
+    'Array, Matrix, Matrix': function ArrayMatrixMatrix(A, B, C) {
+      return _sylvester(matrix(A), B, C);
+    },
+    'Array, Array, Matrix': function ArrayArrayMatrix(A, B, C) {
+      return _sylvester(matrix(A), matrix(B), C);
+    },
+    'Array, Matrix, Array': function ArrayMatrixArray(A, B, C) {
+      return _sylvester(matrix(A), B, matrix(C));
+    },
+    'Matrix, Array, Matrix': function MatrixArrayMatrix(A, B, C) {
+      return _sylvester(A, matrix(B), C);
+    },
+    'Matrix, Array, Array': function MatrixArrayArray(A, B, C) {
+      return _sylvester(A, matrix(B), matrix(C));
+    },
+    'Matrix, Matrix, Array': function MatrixMatrixArray(A, B, C) {
+      return _sylvester(A, B, matrix(C));
+    },
+    'Array, Array, Array': function ArrayArrayArray(A, B, C) {
+      return _sylvester(matrix(A), matrix(B), matrix(C)).toArray();
+    }
+  });
+  function _sylvester(A, B, C) {
+    var n = B.size()[0];
+    var m = A.size()[0];
+    var sA = schur(A);
+    var F = sA.T;
+    var U = sA.U;
+    var sB = schur(multiply(-1, B));
+    var G = sB.T;
+    var V = sB.U;
+    var D = multiply(multiply(transpose(U), C), V);
+    var all = range(0, m);
+    var y = [];
+    var hc = (a, b) => concat(a, b, 1);
+    var vc = (a, b) => concat(a, b, 0);
+    for (var k = 0; k < n; k++) {
+      if (k < n - 1 && abs(subset(G, index(k + 1, k))) > 1e-5) {
+        var RHS = vc(subset(D, index(all, k)), subset(D, index(all, k + 1)));
+        for (var j = 0; j < k; j++) {
+          RHS = add(RHS, vc(multiply(y[j], subset(G, index(j, k))), multiply(y[j], subset(G, index(j, k + 1)))));
+        }
+        var gkk = multiply(identity(m), multiply(-1, subset(G, index(k, k))));
+        var gmk = multiply(identity(m), multiply(-1, subset(G, index(k + 1, k))));
+        var gkm = multiply(identity(m), multiply(-1, subset(G, index(k, k + 1))));
+        var gmm = multiply(identity(m), multiply(-1, subset(G, index(k + 1, k + 1))));
+        var LHS = vc(hc(add(F, gkk), gmk), hc(gkm, add(F, gmm)));
+        var yAux = lusolve(LHS, RHS);
+        y[k] = yAux.subset(index(range(0, m), 0));
+        y[k + 1] = yAux.subset(index(range(m, 2 * m), 0));
+        k++;
+      } else {
+        var _RHS = subset(D, index(all, k));
+        for (var _j = 0; _j < k; _j++) {
+          _RHS = add(_RHS, multiply(y[_j], subset(G, index(_j, k))));
+        }
+        var _gkk = subset(G, index(k, k));
+        var _LHS = subtract(F, multiply(_gkk, identity(m)));
+        y[k] = lusolve(_LHS, _RHS);
+      }
+    }
+    var Y = matrix(matrixFromColumns(...y));
+    var X = multiply(U, multiply(Y, transpose(V)));
+    return X;
+  }
+});

package/lib/esm/function/matrix/forEach.js

@@ -33,7 +33,7 @@ export var createForEach = /* #__PURE__ */factory(name, dependencies, _ref => {
   return typed(name, {
     'Array, function': _forEach,
     'Matrix, function': function MatrixFunction(x, callback) {
-      return x.forEach(callback);
+      x.forEach(callback);
     }
   });
 });

package/lib/esm/version.js

@@ -1,3 +1,3 @@
-export var version = '11.3.3';
+export var version = '11.4.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.3.3",
+  "version": "11.4.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",
@@ -43,13 +43,13 @@
     "@babel/register": "7.18.9",
     "@types/assert": "1.5.6",
     "@types/mocha": "10.0.0",
-    "@typescript-eslint/eslint-plugin": "5.42.0",
-    "@typescript-eslint/parser": "5.42.0",
+    "@typescript-eslint/eslint-plugin": "5.43.0",
+    "@typescript-eslint/parser": "5.43.0",
     "assert": "2.0.0",
     "babel-loader": "9.1.0",
     "benchmark": "2.1.4",
     "codecov": "3.8.3",
-    "core-js": "3.26.0",
+    "core-js": "3.26.1",
     "del": "6.1.1",
     "dtslint": "4.2.1",
     "eslint": "8.27.0",
@@ -57,7 +57,7 @@
     "eslint-config-standard": "17.0.0",
     "eslint-plugin-import": "2.26.0",
     "eslint-plugin-mocha": "10.1.0",
-    "eslint-plugin-n": "15.5.0",
+    "eslint-plugin-n": "15.5.1",
     "eslint-plugin-prettier": "4.2.1",
     "eslint-plugin-promise": "6.1.1",
     "expect-type": "0.15.0",
@@ -78,7 +78,7 @@
     "math-expression-evaluator": "1.4.0",
     "mkdirp": "1.0.4",
     "mocha": "10.1.0",
-    "mocha-junit-reporter": "2.1.1",
+    "mocha-junit-reporter": "2.2.0",
     "ndarray": "1.0.19",
     "ndarray-determinant": "1.0.0",
     "ndarray-gemm": "1.0.0",
@@ -91,8 +91,8 @@
     "process": "0.11.10",
     "sylvester": "0.0.21",
     "ts-node": "10.9.1",
-    "typescript": "4.8.4",
-    "webpack": "5.74.0",
+    "typescript": "4.9.3",
+    "webpack": "5.75.0",
     "zeros": "1.0.0"
   },
   "type": "module",

package/types/index.d.ts

@@ -465,6 +465,11 @@ declare namespace math {
     R: MathCollection
   }
 
+  interface SchurDecomposition {
+    U: MathCollection
+    T: MathCollection
+  }
+
   interface FractionDefinition {
     a: number
     b: number
@@ -894,6 +899,22 @@ declare namespace math {
       threshold?: number
     ): MathArray
 
+    /* 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.
+     * @param {number|Complex} constantCoeff
+     * @param {number|Complex} linearCoeff
+     * @param {number|Complex} quadraticCoeff
+     * @param {number|Complex} cubicCoeff
+     * @returns {Array<number|Complex>} array of roots of specified polynomial
+     */
+    polynomialRoot(
+      constantCoeff: number | Complex,
+      linearCoeff: number | Complex,
+      quadraticCoeff?: number | Complex,
+      cubicCoeff?: number | Complex
+    ): (number | Complex)[]
+
     /**
      * 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
@@ -1807,6 +1828,41 @@ declare namespace math {
      */
     expm(x: Matrix): Matrix
 
+    /**
+     * Solves the real-valued Sylvester equation AX-XB=C for X, where A, B and C are
+     * matrices of appropriate dimensions, being A and B squared. The method used is
+     * the Bartels-Stewart algorithm.
+     * https://en.wikipedia.org/wiki/Sylvester_equation
+     * @param A  Matrix A
+     * @param B  Matrix B
+     * @param C  Matrix C
+     * @returns  Matrix X, solving the Sylvester equation
+     */
+    sylvester(
+      A: Matrix | MathArray,
+      B: Matrix | MathArray,
+      C: Matrix | MathArray
+    ): Matrix | MathArray
+
+    /**
+     * Performs a real Schur decomposition of the real matrix A = UTU' where U is orthogonal
+     * and T is upper quasi-triangular.
+     * https://en.wikipedia.org/wiki/Schur_decomposition
+     * @param A  Matrix A
+     * @returns Object containing both matrix U and T of the Schur Decomposition A=UTU'
+     */
+    schur(A: Matrix | MathArray): SchurDecomposition
+
+    /**
+     * Solves the Continuous-time Lyapunov equation AP+PA'=Q for P, where Q is a positive semidefinite
+     * matrix.
+     * https://en.wikipedia.org/wiki/Lyapunov_equation
+     * @param A  Matrix A
+     * @param Q  Matrix Q
+     * @returns  Matrix P solution to the Continuous-time Lyapunov equation AP+PA'=Q
+     */
+    lyap(A: Matrix | MathArray, Q: Matrix | MathArray): Matrix | MathArray
+
     /**
      * Create a 2-dimensional identity matrix with size m x n or n x n. The
      * matrix has ones on the diagonal and zeros elsewhere.
@@ -3572,6 +3628,9 @@ declare namespace math {
     invDependencies: FactoryFunctionMap
     expmDependencies: FactoryFunctionMap
     sqrtmDependencies: FactoryFunctionMap
+    sylvesterDependencies: FactoryFunctionMap
+    schurDependencies: FactoryFunctionMap
+    lyapDependencies: FactoryFunctionMap
     divideDependencies: FactoryFunctionMap
     distanceDependencies: FactoryFunctionMap
     intersectDependencies: FactoryFunctionMap
@@ -3977,8 +4036,8 @@ declare namespace math {
      */
     forEach(
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      callback: (node: MathNode, path: string, parent: MathNode) => any
-    ): MathNode[]
+      callback: (node: MathNode, path: string, parent: MathNode) => void
+    ): void
 
     /**
      * Transform a node. Creates a new MathNode having it’s child's be the
@@ -4071,8 +4130,7 @@ declare namespace math {
      */
     traverse(
       callback: (node: MathNode, path: string, parent: MathNode) => void
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    ): any
+    ): void
   }
 
   interface Parser {
@@ -5273,6 +5331,26 @@ declare namespace math {
 
     expm(this: MathJsChain<Matrix>): MathJsChain<Matrix>
 
+    /**
+     * Performs a real Schur decomposition of the real matrix A = UTU' where U is orthogonal
+     * and T is upper quasi-triangular.
+     * https://en.wikipedia.org/wiki/Schur_decomposition
+     * @returns Object containing both matrix U and T of the Schur Decomposition A=UTU'
+     */
+    schur(this: MathJsChain<Matrix | MathArray>): SchurDecomposition
+
+    /**
+     * Solves the Continuous-time Lyapunov equation AP+PA'=Q for P, where Q is a positive semidefinite
+     * matrix.
+     * https://en.wikipedia.org/wiki/Lyapunov_equation
+     * @param Q  Matrix Q
+     * @returns  Matrix P solution to the Continuous-time Lyapunov equation AP+PA'=Q
+     */
+    lyap(
+      this: MathJsChain<Matrix | MathArray>,
+      Q: Matrix | MathArray
+    ): MathJsChain<Matrix | MathArray>
+
     /**
      * Create a 2-dimensional identity matrix with size m x n or n x n. The
      * matrix has ones on the diagonal and zeros elsewhere.
@@ -5323,7 +5401,7 @@ declare namespace math {
       this: MathJsChain<T>,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       callback: (value: any, index: any, matrix: T) => void
-    ): MathJsChain<T>
+    ): void
 
     /**
      * Calculate the inverse of a square matrix.