mathjs 11.3.2 → 11.4.0

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

@@ -1,4 +1,5 @@
-import { isConstantNode, isParenthesisNode } from '../../utils/is.js';
+import { isParenthesisNode } from '../../utils/is.js';
+import { isConstantNode, isVariableNode, isNumericNode, isConstantExpression } from './simplify/wildcards.js';
 import { factory } from '../../utils/factory.js';
 import { createUtil } from './simplify/util.js';
 import { hasOwnProperty } from '../../utils/object.js';
@@ -75,9 +76,15 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
    * expression is that variables starting with the following characters are
    * interpreted as wildcards:
    *
-   * - 'n' - matches any Node
-   * - 'c' - matches any ConstantNode
-   * - 'v' - matches any Node that is not a ConstantNode
+   * - 'n' - Matches any node [Node]
+   * - 'c' - Matches a constant literal (5 or 3.2) [ConstantNode]
+   * - 'cl' - Matches a constant literal; same as c [ConstantNode]
+   * - 'cd' - Matches a decimal literal (5 or -3.2) [ConstantNode or unaryMinus wrapping a ConstantNode]
+   * - 'ce' - Matches a constant expression (-5 or √3) [Expressions consisting of only ConstantNodes, functions, and operators]
+   * - 'v' - Matches a variable; anything not matched by c (-5 or x) [Node that is not a ConstantNode]
+   * - 'vl' - Matches a variable literal (x or y) [SymbolNode]
+   * - 'vd' - Matches a non-decimal expression; anything not matched by cd (x or √3) [Node that is not a ConstantNode or unaryMinus that is wrapping a ConstantNode]
+   * - 've' - Matches a variable expression; anything not matched by ce (x or 2x) [Expressions that contain a SymbolNode or other non-constant term]
    *
    * The default list of rules is exposed on the function as `simplify.rules`
    * and can be used as a basis to built a set of custom rules. Note that since
@@ -250,7 +257,7 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
       }
     }
   }, {
-    s: '-(c*v) -> v * (-c)',
+    s: '-(cl*v) -> v * (-cl)',
     // make non-constant terms positive
     assuming: {
       multiply: {
@@ -261,7 +268,7 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
       }
     }
   }, {
-    s: '-(c*v) -> (-c) * v',
+    s: '-(cl*v) -> (-cl) * v',
     // non-commutative version, part 1
     assuming: {
       multiply: {
@@ -272,7 +279,7 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
       }
     }
   }, {
-    s: '-(v*c) -> v * (-c)',
+    s: '-(v*cl) -> v * (-cl)',
     // non-commutative version, part 2
     assuming: {
       multiply: {
@@ -330,24 +337,24 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
   },
   // collect like factors; into a sum, only do this for nonconstants
   {
-    l: ' v   * ( v   * n1 + n2)',
-    r: 'v^2       * n1 +  v   * n2'
+    l: ' vd   * ( vd   * n1 + n2)',
+    r: 'vd^2       * n1 +  vd   * n2'
   }, {
-    s: ' v   * (v^n4 * n1 + n2)   ->  v^(1+n4)  * n1 +  v   * n2',
+    s: ' vd   * (vd^n4 * n1 + n2)   ->  vd^(1+n4)  * n1 +  vd   * n2',
     assuming: {
       divide: {
         total: true
       }
     } // v*1/v = v^(1+-1) needs 1/v
   }, {
-    s: 'v^n3 * ( v   * n1 + n2)   ->  v^(n3+1)  * n1 + v^n3 * n2',
+    s: 'vd^n3 * ( vd   * n1 + n2)   ->  vd^(n3+1)  * n1 + vd^n3 * n2',
     assuming: {
       divide: {
         total: true
       }
     }
   }, {
-    s: 'v^n3 * (v^n4 * n1 + n2)   ->  v^(n3+n4) * n1 + v^n3 * n2',
+    s: 'vd^n3 * (vd^n4 * n1 + n2)   ->  vd^(n3+n4) * n1 + vd^n3 * n2',
     assuming: {
       divide: {
         total: true
@@ -390,8 +397,8 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
     l: 'n+-n',
     r: '0'
   }, {
-    l: 'v*n + v',
-    r: 'v*(n+1)'
+    l: 'vd*n + vd',
+    r: 'vd*(n+1)'
   },
   // NOTE: leftmost position is special:
   {
@@ -406,7 +413,7 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
     l: 'n3^(-n4)*n1 + n3^n5 * n2',
     r: 'n3^(-n4)*(n1 + n3^(n4+n5)*n2)'
   }, {
-    s: 'n*v + v -> (n+1)*v',
+    s: 'n*vd + vd -> (n+1)*vd',
     // noncommutative additional cases
     assuming: {
       multiply: {
@@ -435,10 +442,10 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
       }
     }
   }, {
-    l: 'n*c + c',
-    r: '(n+1)*c'
+    l: 'n*cd + cd',
+    r: '(n+1)*cd'
   }, {
-    s: 'c*n + c -> c*(n+1)',
+    s: 'cd*n + cd -> cd*(n+1)',
     assuming: {
       multiply: {
         commutative: false
@@ -469,7 +476,7 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
   },
   // final ordering of constants
   {
-    s: 'c+v -> v+c',
+    s: 'ce+ve -> ve+ce',
     assuming: {
       add: {
         commutative: true
@@ -481,7 +488,7 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
       }
     }
   }, {
-    s: 'v*c -> c*v',
+    s: 'vd*cd -> cd*vd',
     assuming: {
       multiply: {
         commutative: true
@@ -1047,9 +1054,8 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
       }
     } else if (rule instanceof SymbolNode) {
       // If the rule is a SymbolNode, then it carries a special meaning
-      // according to the first character of the symbol node name.
-      // c.* matches a ConstantNode
-      // n.* matches any node
+      // according to the first one or two characters of the symbol node name.
+      // These meanings are expalined in the documentation for simplify()
       if (rule.name.length === 0) {
         throw new Error('Symbol in rule has 0 length...!?');
       }
@@ -1058,29 +1064,83 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
         if (rule.name !== node.name) {
           return [];
         }
-      } else if (rule.name[0] === 'n' || rule.name.substring(0, 2) === '_p') {
-        // rule matches _anything_, so assign this node to the rule.name placeholder
-        // Assign node to the rule.name placeholder.
-        // Our parent will check for matches among placeholders.
-        res[0].placeholders[rule.name] = node;
-      } else if (rule.name[0] === 'v') {
-        // rule matches any variable thing (not a ConstantNode)
-        if (!isConstantNode(node)) {
-          res[0].placeholders[rule.name] = node;
-        } else {
-          // Mis-match: rule was expecting something other than a ConstantNode
-          return [];
-        }
-      } else if (rule.name[0] === 'c') {
-        // rule matches any ConstantNode
-        if (node instanceof ConstantNode) {
-          res[0].placeholders[rule.name] = node;
-        } else {
-          // Mis-match: rule was expecting a ConstantNode
-          return [];
-        }
       } else {
-        throw new Error('Invalid symbol in rule: ' + rule.name);
+        // wildcards are composed of up to two alphabetic or underscore characters
+        switch (rule.name[1] >= 'a' && rule.name[1] <= 'z' ? rule.name.substring(0, 2) : rule.name[0]) {
+          case 'n':
+          case '_p':
+            // rule matches _anything_, so assign this node to the rule.name placeholder
+            // Assign node to the rule.name placeholder.
+            // Our parent will check for matches among placeholders.
+            res[0].placeholders[rule.name] = node;
+            break;
+          case 'c':
+          case 'cl':
+            // rule matches a ConstantNode
+            if (isConstantNode(node)) {
+              res[0].placeholders[rule.name] = node;
+            } else {
+              // mis-match: rule does not encompass current node
+              return [];
+            }
+            break;
+          case 'v':
+            // rule matches anything other than a ConstantNode
+            if (!isConstantNode(node)) {
+              res[0].placeholders[rule.name] = node;
+            } else {
+              // mis-match: rule does not encompass current node
+              return [];
+            }
+            break;
+          case 'vl':
+            // rule matches VariableNode
+            if (isVariableNode(node)) {
+              res[0].placeholders[rule.name] = node;
+            } else {
+              // mis-match: rule does not encompass current node
+              return [];
+            }
+            break;
+          case 'cd':
+            // rule matches a ConstantNode or unaryMinus-wrapped ConstantNode
+            if (isNumericNode(node)) {
+              res[0].placeholders[rule.name] = node;
+            } else {
+              // mis-match: rule does not encompass current node
+              return [];
+            }
+            break;
+          case 'vd':
+            // rule matches anything other than a ConstantNode or unaryMinus-wrapped ConstantNode
+            if (!isNumericNode(node)) {
+              res[0].placeholders[rule.name] = node;
+            } else {
+              // mis-match: rule does not encompass current node
+              return [];
+            }
+            break;
+          case 'ce':
+            // rule matches expressions that have a constant value
+            if (isConstantExpression(node)) {
+              res[0].placeholders[rule.name] = node;
+            } else {
+              // mis-match: rule does not encompass current node
+              return [];
+            }
+            break;
+          case 've':
+            // rule matches expressions that do not have a constant value
+            if (!isConstantExpression(node)) {
+              res[0].placeholders[rule.name] = node;
+            } else {
+              // mis-match: rule does not encompass current node
+              return [];
+            }
+            break;
+          default:
+            throw new Error('Invalid symbol in rule: ' + rule.name);
+        }
       }
     } else if (rule instanceof ConstantNode) {
       // Literal constant must match exactly

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

@@ -286,20 +286,37 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
    * @return - Either a Node representing a binary expression or Fraction
    */
   function foldOp(fn, args, makeNode, options) {
-    return args.reduce(function (a, b) {
-      if (!isNode(a) && !isNode(b)) {
+    var first = args.shift();
+
+    // In the following reduction, sofar always has one of the three following
+    // forms: [NODE], [CONSTANT], or [NODE, CONSTANT]
+    var reduction = args.reduce((sofar, next) => {
+      if (!isNode(next)) {
+        var last = sofar.pop();
+        if (isNode(last)) {
+          return [last, next];
+        }
+        // Two constants in a row, try to fold them into one
         try {
-          return _eval(fn, [a, b], options);
-        } catch (ignoreandcontinue) {}
-        a = _toNode(a);
-        b = _toNode(b);
-      } else if (!isNode(a)) {
-        a = _toNode(a);
-      } else if (!isNode(b)) {
-        b = _toNode(b);
+          sofar.push(_eval(fn, [last, next], options));
+          return sofar;
+        } catch (ignoreandcontinue) {
+          sofar.push(last);
+          // fall through to Node case
+        }
       }
-      return makeNode([a, b]);
-    });
+
+      // Encountered a Node, or failed folding --
+      // collapse everything so far into a single tree:
+      sofar.push(_ensureNode(sofar.pop()));
+      var newtree = sofar.length === 1 ? sofar[0] : makeNode(sofar);
+      return [makeNode([newtree, _ensureNode(next)])];
+    }, [first]);
+    if (reduction.length === 1) {
+      return reduction[0];
+    }
+    // Might end up with a tree and a constant at the end:
+    return makeNode([reduction[0], _toNode(reduction[1])]);
   }
 
   // destroys the original node and returns a folded one

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/function/matrix/sqrtm.js

@@ -59,7 +59,7 @@ export var createSqrtm = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * Examples:
    *
-   *     math.sqrtm([[1, 2], [3, 4]]) // returns [[-2, 1], [1.5, -0.5]]
+   *     math.sqrtm([[33, 24], [48, 57]]) // returns [[5, 2], [4, 7]]
    *
    * See also:
    *

package/lib/esm/type/matrix/SparseMatrix.js

@@ -526,8 +526,10 @@ export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies,
         _remove(k, j, this._values, this._index, this._ptr);
       }
     } else {
-      // insert value @ (i, j)
-      _insert(k, i, j, v, this._values, this._index, this._ptr);
+      if (!eq(v, zero)) {
+        // insert value @ (i, j)
+        _insert(k, i, j, v, this._values, this._index, this._ptr);
+      }
     }
     return this;
   };

package/lib/esm/version.js

@@ -1,3 +1,3 @@
-export var version = '11.3.2';
+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.2",
+  "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",
@@ -25,7 +25,7 @@
     "unit"
   ],
   "dependencies": {
-    "@babel/runtime": "^7.19.4",
+    "@babel/runtime": "^7.20.1",
     "complex.js": "^2.1.1",
     "decimal.js": "^10.4.2",
     "escape-latex": "^1.2.0",
@@ -36,28 +36,28 @@
     "typed-function": "^4.1.0"
   },
   "devDependencies": {
-    "@babel/core": "7.19.6",
+    "@babel/core": "7.20.2",
     "@babel/plugin-transform-object-assign": "7.18.6",
     "@babel/plugin-transform-runtime": "7.19.6",
-    "@babel/preset-env": "7.19.4",
+    "@babel/preset-env": "7.20.2",
     "@babel/register": "7.18.9",
     "@types/assert": "1.5.6",
     "@types/mocha": "10.0.0",
-    "@typescript-eslint/eslint-plugin": "5.41.0",
-    "@typescript-eslint/parser": "5.41.0",
+    "@typescript-eslint/eslint-plugin": "5.43.0",
+    "@typescript-eslint/parser": "5.43.0",
     "assert": "2.0.0",
-    "babel-loader": "8.2.5",
+    "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.26.0",
+    "eslint": "8.27.0",
     "eslint-config-prettier": "8.5.0",
     "eslint-config-standard": "17.0.0",
     "eslint-plugin-import": "2.26.0",
     "eslint-plugin-mocha": "10.1.0",
-    "eslint-plugin-n": "15.3.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.0",
+    "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",