mathjs 11.2.0 → 11.3.0

package/lib/cjs/function/algebra/simplifyCore.js

@@ -4,53 +4,47 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createSimplifyCore = void 0;
-
 var _is = require("../../utils/is.js");
-
 var _operators = require("../../expression/operators.js");
-
 var _util = require("./simplify/util.js");
-
 var _factory = require("../../utils/factory.js");
-
 var name = 'simplifyCore';
 var dependencies = ['typed', 'parse', 'equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'ParenthesisNode', 'SymbolNode'];
 var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
-      parse = _ref.parse,
-      equal = _ref.equal,
-      isZero = _ref.isZero,
-      add = _ref.add,
-      subtract = _ref.subtract,
-      multiply = _ref.multiply,
-      divide = _ref.divide,
-      pow = _ref.pow,
-      AccessorNode = _ref.AccessorNode,
-      ArrayNode = _ref.ArrayNode,
-      ConstantNode = _ref.ConstantNode,
-      FunctionNode = _ref.FunctionNode,
-      IndexNode = _ref.IndexNode,
-      ObjectNode = _ref.ObjectNode,
-      OperatorNode = _ref.OperatorNode,
-      ParenthesisNode = _ref.ParenthesisNode,
-      SymbolNode = _ref.SymbolNode;
+    parse = _ref.parse,
+    equal = _ref.equal,
+    isZero = _ref.isZero,
+    add = _ref.add,
+    subtract = _ref.subtract,
+    multiply = _ref.multiply,
+    divide = _ref.divide,
+    pow = _ref.pow,
+    AccessorNode = _ref.AccessorNode,
+    ArrayNode = _ref.ArrayNode,
+    ConstantNode = _ref.ConstantNode,
+    FunctionNode = _ref.FunctionNode,
+    IndexNode = _ref.IndexNode,
+    ObjectNode = _ref.ObjectNode,
+    OperatorNode = _ref.OperatorNode,
+    ParenthesisNode = _ref.ParenthesisNode,
+    SymbolNode = _ref.SymbolNode;
   var node0 = new ConstantNode(0);
   var node1 = new ConstantNode(1);
   var nodeT = new ConstantNode(true);
-  var nodeF = new ConstantNode(false); // test if a node will always have a boolean value (true/false)
+  var nodeF = new ConstantNode(false);
+  // test if a node will always have a boolean value (true/false)
   // not sure if this list is complete
-
   function isAlwaysBoolean(node) {
     return (0, _is.isOperatorNode)(node) && ['and', 'not', 'or'].includes(node.op);
   }
-
   var _createUtil = (0, _util.createUtil)({
-    FunctionNode: FunctionNode,
-    OperatorNode: OperatorNode,
-    SymbolNode: SymbolNode
-  }),
-      hasProperty = _createUtil.hasProperty,
-      isCommutative = _createUtil.isCommutative;
+      FunctionNode: FunctionNode,
+      OperatorNode: OperatorNode,
+      SymbolNode: SymbolNode
+    }),
+    hasProperty = _createUtil.hasProperty,
+    isCommutative = _createUtil.isCommutative;
   /**
    * simplifyCore() performs single pass simplification suitable for
    * applications requiring ultimate performance. To roughly summarize,
@@ -95,40 +89,31 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
    *     Simplification options, as per simplify()
    * @return {Node} Returns expression with basic simplifications applied
    */
-
-
   function _simplifyCore(nodeToSimplify) {
     var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     var context = options ? options.context : undefined;
-
     if (hasProperty(nodeToSimplify, 'trivial', context)) {
       // This node does nothing if it has only one argument, so if so,
       // return that argument simplified
       if ((0, _is.isFunctionNode)(nodeToSimplify) && nodeToSimplify.args.length === 1) {
         return _simplifyCore(nodeToSimplify.args[0], options);
-      } // For other node types, we try the generic methods
-
-
+      }
+      // For other node types, we try the generic methods
       var simpChild = false;
       var childCount = 0;
       nodeToSimplify.forEach(function (c) {
         ++childCount;
-
         if (childCount === 1) {
           simpChild = _simplifyCore(c, options);
         }
       });
-
       if (childCount === 1) {
         return simpChild;
       }
     }
-
     var node = nodeToSimplify;
-
     if ((0, _is.isFunctionNode)(node)) {
       var op = (0, _operators.getOperator)(node.name);
-
       if (op) {
         // Replace FunctionNode with a new OperatorNode
         if (node.args.length > 2 && hasProperty(node, 'associative', context)) {
@@ -139,7 +124,6 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
             node.args.push(new OperatorNode(op, node.name, [last, seclast]));
           }
         }
-
         node = new OperatorNode(op, node.name, node.args);
       } else {
         return new FunctionNode(_simplifyCore(node.fn), node.args.map(function (n) {
@@ -147,17 +131,14 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
         }));
       }
     }
-
     if ((0, _is.isOperatorNode)(node) && node.isUnary()) {
       var a0 = _simplifyCore(node.args[0], options);
-
       if (node.op === '~') {
         // bitwise not
         if ((0, _is.isOperatorNode)(a0) && a0.isUnary() && a0.op === '~') {
           return a0.args[0];
         }
       }
-
       if (node.op === 'not') {
         // logical not
         if ((0, _is.isOperatorNode)(a0) && a0.isUnary() && a0.op === 'not') {
@@ -169,9 +150,7 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
           }
         }
       }
-
       var finish = true;
-
       if (node.op === '-') {
         // unary minus
         if ((0, _is.isOperatorNode)(a0)) {
@@ -185,46 +164,35 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
           }
         }
       }
-
       if (finish) return new OperatorNode(node.op, node.fn, [a0]);
     }
-
     if ((0, _is.isOperatorNode)(node) && node.isBinary()) {
       var _a = _simplifyCore(node.args[0], options);
-
       var a1 = _simplifyCore(node.args[1], options);
-
       if (node.op === '+') {
         if ((0, _is.isConstantNode)(_a) && isZero(_a.value)) {
           return a1;
         }
-
         if ((0, _is.isConstantNode)(a1) && isZero(a1.value)) {
           return _a;
         }
-
         if ((0, _is.isOperatorNode)(a1) && a1.isUnary() && a1.op === '-') {
           a1 = a1.args[0];
           node = new OperatorNode('-', 'subtract', [_a, a1]);
         }
       }
-
       if (node.op === '-') {
         if ((0, _is.isOperatorNode)(a1) && a1.isUnary() && a1.op === '-') {
           return _simplifyCore(new OperatorNode('+', 'add', [_a, a1.args[0]]), options);
         }
-
         if ((0, _is.isConstantNode)(_a) && isZero(_a.value)) {
           return _simplifyCore(new OperatorNode('-', 'unaryMinus', [a1]));
         }
-
         if ((0, _is.isConstantNode)(a1) && isZero(a1.value)) {
           return _a;
         }
-
         return new OperatorNode(node.op, node.fn, [_a, a1]);
       }
-
       if (node.op === '*') {
         if ((0, _is.isConstantNode)(_a)) {
           if (isZero(_a.value)) {
@@ -233,14 +201,12 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
             return a1;
           }
         }
-
         if ((0, _is.isConstantNode)(a1)) {
           if (isZero(a1.value)) {
             return node0;
           } else if (equal(a1.value, 1)) {
             return _a;
           }
-
           if (isCommutative(node, context)) {
             return new OperatorNode(node.op, node.fn, [a1, _a], node.implicit); // constants on left
           }
@@ -248,19 +214,15 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
 
         return new OperatorNode(node.op, node.fn, [_a, a1], node.implicit);
       }
-
       if (node.op === '/') {
         if ((0, _is.isConstantNode)(_a) && isZero(_a.value)) {
           return node0;
         }
-
         if ((0, _is.isConstantNode)(a1) && equal(a1.value, 1)) {
           return _a;
         }
-
         return new OperatorNode(node.op, node.fn, [_a, a1]);
       }
-
       if (node.op === '^') {
         if ((0, _is.isConstantNode)(a1)) {
           if (isZero(a1.value)) {
@@ -270,7 +232,6 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
           }
         }
       }
-
       if (node.op === 'and') {
         if ((0, _is.isConstantNode)(_a)) {
           if (_a.value) {
@@ -279,7 +240,6 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
             return nodeF;
           }
         }
-
         if ((0, _is.isConstantNode)(a1)) {
           if (a1.value) {
             if (isAlwaysBoolean(_a)) return _a;
@@ -288,7 +248,6 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
           }
         }
       }
-
       if (node.op === 'or') {
         if ((0, _is.isConstantNode)(_a)) {
           if (_a.value) {
@@ -297,7 +256,6 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
             if (isAlwaysBoolean(a1)) return a1;
           }
         }
-
         if ((0, _is.isConstantNode)(a1)) {
           if (a1.value) {
             return nodeT;
@@ -306,46 +264,36 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
           }
         }
       }
-
       return new OperatorNode(node.op, node.fn, [_a, a1]);
     }
-
     if ((0, _is.isOperatorNode)(node)) {
       return new OperatorNode(node.op, node.fn, node.args.map(function (a) {
         return _simplifyCore(a, options);
       }));
     }
-
     if ((0, _is.isArrayNode)(node)) {
       return new ArrayNode(node.items.map(function (n) {
         return _simplifyCore(n, options);
       }));
     }
-
     if ((0, _is.isAccessorNode)(node)) {
       return new AccessorNode(_simplifyCore(node.object, options), _simplifyCore(node.index, options));
     }
-
     if ((0, _is.isIndexNode)(node)) {
       return new IndexNode(node.dimensions.map(function (n) {
         return _simplifyCore(n, options);
       }));
     }
-
     if ((0, _is.isObjectNode)(node)) {
       var newProps = {};
-
       for (var prop in node.properties) {
         newProps[prop] = _simplifyCore(node.properties[prop], options);
       }
-
       return new ObjectNode(newProps);
-    } // cannot simplify
-
-
+    }
+    // cannot simplify
     return node;
   }
-
   return typed(name, {
     Node: _simplifyCore,
     'Node,Object': _simplifyCore

package/lib/cjs/function/algebra/solver/lsolve.js

@@ -4,24 +4,22 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createLsolve = void 0;
-
 var _factory = require("../../../utils/factory.js");
-
 var _solveValidation = require("./utils/solveValidation.js");
-
 var name = 'lsolve';
 var dependencies = ['typed', 'matrix', 'divideScalar', 'multiplyScalar', 'subtract', 'equalScalar', 'DenseMatrix'];
 var createLsolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
-      matrix = _ref.matrix,
-      divideScalar = _ref.divideScalar,
-      multiplyScalar = _ref.multiplyScalar,
-      subtract = _ref.subtract,
-      equalScalar = _ref.equalScalar,
-      DenseMatrix = _ref.DenseMatrix;
+    matrix = _ref.matrix,
+    divideScalar = _ref.divideScalar,
+    multiplyScalar = _ref.multiplyScalar,
+    subtract = _ref.subtract,
+    equalScalar = _ref.equalScalar,
+    DenseMatrix = _ref.DenseMatrix;
   var solveValidation = (0, _solveValidation.createSolveValidation)({
     DenseMatrix: DenseMatrix
   });
+
   /**
    * Finds one solution of a linear equation system by forwards substitution. Matrix must be a lower triangular matrix. Throws an error if there's no solution.
    *
@@ -46,7 +44,6 @@ var createLsolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
    *
    * @return {DenseMatrix | Array}  A column vector with the linear system solution (x)
    */
-
   return typed(name, {
     'SparseMatrix, Array | Matrix': function SparseMatrixArrayMatrix(m, b) {
       return _sparseForwardSubstitution(m, b);
@@ -56,37 +53,35 @@ var createLsolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
     },
     'Array, Array | Matrix': function ArrayArrayMatrix(a, b) {
       var m = matrix(a);
-
       var r = _denseForwardSubstitution(m, b);
-
       return r.valueOf();
     }
   });
-
   function _denseForwardSubstitution(m, b) {
     // validate matrix and vector, return copy of column vector b
     b = solveValidation(m, b, true);
     var bdata = b._data;
     var rows = m._size[0];
-    var columns = m._size[1]; // result
+    var columns = m._size[1];
 
+    // result
     var x = [];
-    var mdata = m._data; // loop columns
+    var mdata = m._data;
 
+    // loop columns
     for (var j = 0; j < columns; j++) {
       var bj = bdata[j][0] || 0;
       var xj = void 0;
-
       if (!equalScalar(bj, 0)) {
         // non-degenerate row, find solution
-        var vjj = mdata[j][j];
 
+        var vjj = mdata[j][j];
         if (equalScalar(vjj, 0)) {
           throw new Error('Linear system cannot be solved since matrix is singular');
         }
+        xj = divideScalar(bj, vjj);
 
-        xj = divideScalar(bj, vjj); // loop rows
-
+        // loop rows
         for (var i = j + 1; i < rows; i++) {
           bdata[i] = [subtract(bdata[i][0] || 0, multiplyScalar(xj, mdata[i][j]))];
         }
@@ -94,16 +89,13 @@ var createLsolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
         // degenerate row, we can choose any value
         xj = 0;
       }
-
       x[j] = [xj];
     }
-
     return new DenseMatrix({
       data: x,
       size: [rows, 1]
     });
   }
-
   function _sparseForwardSubstitution(m, b) {
     // validate matrix and vector, return copy of column vector b
     b = solveValidation(m, b, true);
@@ -112,26 +104,31 @@ var createLsolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
     var columns = m._size[1];
     var values = m._values;
     var index = m._index;
-    var ptr = m._ptr; // result
+    var ptr = m._ptr;
 
-    var x = []; // loop columns
+    // result
+    var x = [];
 
+    // loop columns
     for (var j = 0; j < columns; j++) {
       var bj = bdata[j][0] || 0;
-
       if (!equalScalar(bj, 0)) {
         // non-degenerate row, find solution
-        var vjj = 0; // matrix values & indices (column j)
 
+        var vjj = 0;
+        // matrix values & indices (column j)
         var jValues = [];
-        var jIndices = []; // first and last index in the column
+        var jIndices = [];
 
+        // first and last index in the column
         var firstIndex = ptr[j];
-        var lastIndex = ptr[j + 1]; // values in column, find value at [j, j]
+        var lastIndex = ptr[j + 1];
 
+        // values in column, find value at [j, j]
         for (var k = firstIndex; k < lastIndex; k++) {
-          var i = index[k]; // check row (rows are not sorted!)
+          var i = index[k];
 
+          // check row (rows are not sorted!)
           if (i === j) {
             vjj = values[k];
           } else if (i > j) {
@@ -139,27 +136,23 @@ var createLsolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
             jValues.push(values[k]);
             jIndices.push(i);
           }
-        } // at this point we must have a value in vjj
-
+        }
 
+        // at this point we must have a value in vjj
         if (equalScalar(vjj, 0)) {
           throw new Error('Linear system cannot be solved since matrix is singular');
         }
-
         var xj = divideScalar(bj, vjj);
-
         for (var _k = 0, l = jIndices.length; _k < l; _k++) {
           var _i = jIndices[_k];
           bdata[_i] = [subtract(bdata[_i][0] || 0, multiplyScalar(xj, jValues[_k]))];
         }
-
         x[j] = [xj];
       } else {
         // degenerate row, we can choose any value
         x[j] = [0];
       }
     }
-
     return new DenseMatrix({
       data: x,
       size: [rows, 1]

package/lib/cjs/function/algebra/solver/lsolveAll.js

@@ -1,31 +1,27 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createLsolveAll = void 0;
-
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-
 var _factory = require("../../../utils/factory.js");
-
 var _solveValidation = require("./utils/solveValidation.js");
-
 var name = 'lsolveAll';
 var dependencies = ['typed', 'matrix', 'divideScalar', 'multiplyScalar', 'subtract', 'equalScalar', 'DenseMatrix'];
 var createLsolveAll = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
-      matrix = _ref.matrix,
-      divideScalar = _ref.divideScalar,
-      multiplyScalar = _ref.multiplyScalar,
-      subtract = _ref.subtract,
-      equalScalar = _ref.equalScalar,
-      DenseMatrix = _ref.DenseMatrix;
+    matrix = _ref.matrix,
+    divideScalar = _ref.divideScalar,
+    multiplyScalar = _ref.multiplyScalar,
+    subtract = _ref.subtract,
+    equalScalar = _ref.equalScalar,
+    DenseMatrix = _ref.DenseMatrix;
   var solveValidation = (0, _solveValidation.createSolveValidation)({
     DenseMatrix: DenseMatrix
   });
+
   /**
    * Finds all solutions of a linear equation system by forwards substitution. Matrix must be a lower triangular matrix.
    *
@@ -50,7 +46,6 @@ var createLsolveAll = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
    *
    * @return {DenseMatrix[] | Array[]}  An array of affine-independent column vectors (x) that solve the linear system
    */
-
   return typed(name, {
     'SparseMatrix, Array | Matrix': function SparseMatrixArrayMatrix(m, b) {
       return _sparseForwardSubstitution(m, b);
@@ -60,42 +55,42 @@ var createLsolveAll = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
     },
     'Array, Array | Matrix': function ArrayArrayMatrix(a, b) {
       var m = matrix(a);
-
       var R = _denseForwardSubstitution(m, b);
-
       return R.map(function (r) {
         return r.valueOf();
       });
     }
   });
-
   function _denseForwardSubstitution(m, b_) {
     // the algorithm is derived from
     // https://www.overleaf.com/read/csvgqdxggyjv
+
     // array of right-hand sides
     var B = [solveValidation(m, b_, true)._data.map(function (e) {
       return e[0];
     })];
     var M = m._data;
     var rows = m._size[0];
-    var columns = m._size[1]; // loop columns
+    var columns = m._size[1];
 
+    // loop columns
     for (var i = 0; i < columns; i++) {
-      var L = B.length; // loop right-hand sides
+      var L = B.length;
 
+      // loop right-hand sides
       for (var k = 0; k < L; k++) {
         var b = B[k];
-
         if (!equalScalar(M[i][i], 0)) {
           // non-singular row
-          b[i] = divideScalar(b[i], M[i][i]);
 
+          b[i] = divideScalar(b[i], M[i][i]);
           for (var j = i + 1; j < columns; j++) {
             // b[j] -= b[i] * M[j,i]
             b[j] = subtract(b[j], multiplyScalar(b[i], M[j][i]));
           }
         } else if (!equalScalar(b[i], 0)) {
           // singular row, nonzero RHS
+
           if (k === 0) {
             // There is no valid solution
             return [];
@@ -107,18 +102,16 @@ var createLsolveAll = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
           }
         } else if (k === 0) {
           // singular row, RHS is zero
+
           var bNew = (0, _toConsumableArray2["default"])(b);
           bNew[i] = 1;
-
           for (var _j = i + 1; _j < columns; _j++) {
             bNew[_j] = subtract(bNew[_j], M[_j][i]);
           }
-
           B.push(bNew);
         }
       }
     }
-
     return B.map(function (x) {
       return new DenseMatrix({
         data: x.map(function (e) {
@@ -128,7 +121,6 @@ var createLsolveAll = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
       });
     });
   }
-
   function _sparseForwardSubstitution(m, b_) {
     // array of right-hand sides
     var B = [solveValidation(m, b_, true)._data.map(function (e) {
@@ -138,25 +130,29 @@ var createLsolveAll = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
     var columns = m._size[1];
     var values = m._values;
     var index = m._index;
-    var ptr = m._ptr; // loop columns
+    var ptr = m._ptr;
 
+    // loop columns
     for (var i = 0; i < columns; i++) {
-      var L = B.length; // loop right-hand sides
+      var L = B.length;
 
+      // loop right-hand sides
       for (var k = 0; k < L; k++) {
-        var b = B[k]; // values & indices (column i)
+        var b = B[k];
 
+        // values & indices (column i)
         var iValues = [];
-        var iIndices = []; // first & last indeces in column
+        var iIndices = [];
 
+        // first & last indeces in column
         var firstIndex = ptr[i];
-        var lastIndex = ptr[i + 1]; // find the value at [i, i]
+        var lastIndex = ptr[i + 1];
 
+        // find the value at [i, i]
         var Mii = 0;
-
         for (var j = firstIndex; j < lastIndex; j++) {
-          var J = index[j]; // check row
-
+          var J = index[j];
+          // check row
           if (J === i) {
             Mii = values[j];
           } else if (J > i) {
@@ -165,17 +161,17 @@ var createLsolveAll = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
             iIndices.push(J);
           }
         }
-
         if (!equalScalar(Mii, 0)) {
           // non-singular row
-          b[i] = divideScalar(b[i], Mii);
 
+          b[i] = divideScalar(b[i], Mii);
           for (var _j2 = 0, _lastIndex = iIndices.length; _j2 < _lastIndex; _j2++) {
             var _J = iIndices[_j2];
             b[_J] = subtract(b[_J], multiplyScalar(b[i], iValues[_j2]));
           }
         } else if (!equalScalar(b[i], 0)) {
           // singular row, nonzero RHS
+
           if (k === 0) {
             // There is no valid solution
             return [];
@@ -187,19 +183,17 @@ var createLsolveAll = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
           }
         } else if (k === 0) {
           // singular row, RHS is zero
+
           var bNew = (0, _toConsumableArray2["default"])(b);
           bNew[i] = 1;
-
           for (var _j3 = 0, _lastIndex2 = iIndices.length; _j3 < _lastIndex2; _j3++) {
             var _J2 = iIndices[_j3];
             bNew[_J2] = subtract(bNew[_J2], iValues[_j3]);
           }
-
           B.push(bNew);
         }
       }
     }
-
     return B.map(function (x) {
       return new DenseMatrix({
         data: x.map(function (e) {