mathjs 7.2.0 → 7.5.1

package/lib/expression/embeddedDocs/embeddedDocs.js

@@ -27,6 +27,12 @@ var _isNaN = require("./function/utils/isNaN");
 
 var _format = require("./function/utils/format");
 
+var _bin = require("./function/utils/bin");
+
+var _oct = require("./function/utils/oct");
+
+var _hex = require("./function/utils/hex");
+
 var _clone = require("./function/utils/clone");
 
 var _to = require("./function/units/to");
@@ -343,6 +349,8 @@ var _qr = require("./function/algebra/qr");
 
 var _usolve = require("./function/algebra/usolve");
 
+var _usolveAll = require("./function/algebra/usolveAll");
+
 var _slu = require("./function/algebra/slu");
 
 var _rationalize = require("./function/algebra/rationalize");
@@ -353,6 +361,8 @@ var _lup = require("./function/algebra/lup");
 
 var _lsolve = require("./function/algebra/lsolve");
 
+var _lsolveAll = require("./function/algebra/lsolveAll");
+
 var _derivative = require("./function/algebra/derivative");
 
 var _version = require("./constants/version");
@@ -427,6 +437,8 @@ var _column = require("./function/matrix/column");
 
 var _row = require("./function/matrix/row");
 
+var _rotationMatrix = require("./function/matrix/rotationMatrix");
+
 var embeddedDocs = {
   // construction functions
   bignumber: _bignumber.bignumberDocs,
@@ -668,12 +680,14 @@ var embeddedDocs = {
   // functions - algebra
   derivative: _derivative.derivativeDocs,
   lsolve: _lsolve.lsolveDocs,
+  lsolveAll: _lsolveAll.lsolveAllDocs,
   lup: _lup.lupDocs,
   lusolve: _lusolve.lusolveDocs,
   simplify: _simplify.simplifyDocs,
   rationalize: _rationalize.rationalizeDocs,
   slu: _slu.sluDocs,
   usolve: _usolve.usolveDocs,
+  usolveAll: _usolveAll.usolveAllDocs,
   qr: _qr.qrDocs,
   // functions - arithmetic
   abs: _abs.absDocs,
@@ -768,6 +782,7 @@ var embeddedDocs = {
   range: _range.rangeDocs,
   resize: _resize.resizeDocs,
   reshape: _reshape.reshapeDocs,
+  rotationMatrix: _rotationMatrix.rotationMatrixDocs,
   row: _row.rowDocs,
   size: _size.sizeDocs,
   sort: _sort.sortDocs,
@@ -856,6 +871,9 @@ var embeddedDocs = {
   // functions - utils
   clone: _clone.cloneDocs,
   format: _format.formatDocs,
+  bin: _bin.binDocs,
+  oct: _oct.octDocs,
+  hex: _hex.hexDocs,
   isNaN: _isNaN.isNaNDocs,
   isInteger: _isInteger.isIntegerDocs,
   isNegative: _isNegative.isNegativeDocs,

package/lib/expression/embeddedDocs/function/algebra/lsolve.js

@@ -8,8 +8,8 @@ var lsolveDocs = {
   name: 'lsolve',
   category: 'Algebra',
   syntax: ['x=lsolve(L, b)'],
-  description: 'Solves the linear system L * x = b where L is an [n x n] lower triangular matrix and b is a [n] column vector.',
+  description: 'Finds one solution of the linear system L * x = b where L is an [n x n] lower triangular matrix and b is a [n] column vector.',
   examples: ['a = [-2, 3; 2, 1]', 'b = [11, 9]', 'x = lsolve(a, b)'],
-  seealso: ['lup', 'lusolve', 'usolve', 'matrix', 'sparse']
+  seealso: ['lsolveAll', 'lup', 'lusolve', 'usolve', 'matrix', 'sparse']
 };
 exports.lsolveDocs = lsolveDocs;

package/lib/expression/embeddedDocs/function/algebra/lsolveAll.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.lsolveAllDocs = void 0;
+var lsolveAllDocs = {
+  name: 'lsolveAll',
+  category: 'Algebra',
+  syntax: ['x=lsolveAll(L, b)'],
+  description: 'Finds all solutions of the linear system L * x = b where L is an [n x n] lower triangular matrix and b is a [n] column vector.',
+  examples: ['a = [-2, 3; 2, 1]', 'b = [11, 9]', 'x = lsolve(a, b)'],
+  seealso: ['lsolve', 'lup', 'lusolve', 'usolve', 'matrix', 'sparse']
+};
+exports.lsolveAllDocs = lsolveAllDocs;

package/lib/expression/embeddedDocs/function/algebra/usolve.js

@@ -8,8 +8,8 @@ var usolveDocs = {
   name: 'usolve',
   category: 'Algebra',
   syntax: ['x=usolve(U, b)'],
-  description: 'Solves the linear system U * x = b where U is an [n x n] upper triangular matrix and b is a [n] column vector.',
+  description: 'Finds one solution of the linear system U * x = b where U is an [n x n] upper triangular matrix and b is a [n] column vector.',
   examples: ['x=usolve(sparse([1, 1, 1, 1; 0, 1, 1, 1; 0, 0, 1, 1; 0, 0, 0, 1]), [1; 2; 3; 4])'],
-  seealso: ['lup', 'lusolve', 'lsolve', 'matrix', 'sparse']
+  seealso: ['usolveAll', 'lup', 'lusolve', 'lsolve', 'matrix', 'sparse']
 };
 exports.usolveDocs = usolveDocs;

package/lib/expression/embeddedDocs/function/algebra/usolveAll.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usolveAllDocs = void 0;
+var usolveAllDocs = {
+  name: 'usolveAll',
+  category: 'Algebra',
+  syntax: ['x=usolve(U, b)'],
+  description: 'Finds all solutions of the linear system U * x = b where U is an [n x n] upper triangular matrix and b is a [n] column vector.',
+  examples: ['x=usolve(sparse([1, 1, 1, 1; 0, 1, 1, 1; 0, 0, 1, 1; 0, 0, 0, 1]), [1; 2; 3; 4])'],
+  seealso: ['usolve', 'lup', 'lusolve', 'lsolve', 'matrix', 'sparse']
+};
+exports.usolveAllDocs = usolveAllDocs;

package/lib/expression/embeddedDocs/function/matrix/rotationMatrix.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.rotationMatrixDocs = void 0;
+var rotationMatrixDocs = {
+  name: 'rotationMatrix',
+  category: 'Matrix',
+  syntax: ['rotationMatrix(theta)', 'rotationMatrix(theta, v)', 'rotationMatrix(theta, v, format)'],
+  description: 'Returns a 2-D rotation matrix (2x2) for a given angle (in radians). ' + 'Returns a 2-D rotation matrix (3x3) of a given angle (in radians) around given axis.',
+  examples: ['rotationMatrix(pi / 2)', 'rotationMatrix(unit("45deg"), [0, 0, 1])', 'rotationMatrix(1, matrix([0, 0, 1]), "sparse")'],
+  seealso: ['cos', 'sin']
+};
+exports.rotationMatrixDocs = rotationMatrixDocs;

package/lib/expression/embeddedDocs/function/utils/bin.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.binDocs = void 0;
+var binDocs = {
+  name: 'bin',
+  category: 'Utils',
+  syntax: ['bin(value)'],
+  description: 'Format a number as binary',
+  examples: ['bin(2)'],
+  seealso: ['oct', 'hex']
+};
+exports.binDocs = binDocs;

package/lib/expression/embeddedDocs/function/utils/hex.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hexDocs = void 0;
+var hexDocs = {
+  name: 'hex',
+  category: 'Utils',
+  syntax: ['hex(value)'],
+  description: 'Format a number as hexadecimal',
+  examples: ['hex(240)'],
+  seealso: ['bin', 'oct']
+};
+exports.hexDocs = hexDocs;

package/lib/expression/embeddedDocs/function/utils/oct.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.octDocs = void 0;
+var octDocs = {
+  name: 'oct',
+  category: 'Utils',
+  syntax: ['oct(value)'],
+  description: 'Format a number as octal',
+  examples: ['oct(56)'],
+  seealso: ['bin', 'hex']
+};
+exports.octDocs = octDocs;

package/lib/expression/parse.js

@@ -313,7 +313,24 @@ var createParse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
 
 
     if (parse.isDigitDot(c1)) {
-      state.tokenType = TOKENTYPE.NUMBER; // get number, can have a single dot
+      state.tokenType = TOKENTYPE.NUMBER; // check for binary, octal, or hex
+
+      var _c = currentString(state, 2);
+
+      if (_c === '0b' || _c === '0o' || _c === '0x') {
+        state.token += currentCharacter(state);
+        next(state);
+        state.token += currentCharacter(state);
+        next(state);
+
+        while (parse.isHexDigit(currentCharacter(state))) {
+          state.token += currentCharacter(state);
+          next(state);
+        }
+
+        return;
+      } // get number, can have a single dot
+
 
       if (currentCharacter(state) === '.') {
         state.token += currentCharacter(state);
@@ -525,6 +542,16 @@ var createParse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
   parse.isDigit = function isDigit(c) {
     return c >= '0' && c <= '9';
   };
+  /**
+   * checks if the given char c is a hex digit
+   * @param {string} c   a string with one character
+   * @return {boolean}
+   */
+
+
+  parse.isHexDigit = function isHexDigit(c) {
+    return c >= '0' && c <= '9' || c >= 'a' && c <= 'f' || c >= 'A' && c <= 'F';
+  };
   /**
    * Start of the parse levels below, in order of precedence
    * @return {Node} node

package/lib/factoriesAny.js

@@ -483,6 +483,12 @@ Object.defineProperty(exports, "createResize", {
     return _resize.createResize;
   }
 });
+Object.defineProperty(exports, "createRotationMatrix", {
+  enumerable: true,
+  get: function get() {
+    return _rotationMatrix.createRotationMatrix;
+  }
+});
 Object.defineProperty(exports, "createRow", {
   enumerable: true,
   get: function get() {
@@ -549,6 +555,24 @@ Object.defineProperty(exports, "createFormat", {
     return _format.createFormat;
   }
 });
+Object.defineProperty(exports, "createBin", {
+  enumerable: true,
+  get: function get() {
+    return _bin.createBin;
+  }
+});
+Object.defineProperty(exports, "createOct", {
+  enumerable: true,
+  get: function get() {
+    return _oct.createOct;
+  }
+});
+Object.defineProperty(exports, "createHex", {
+  enumerable: true,
+  get: function get() {
+    return _hex.createHex;
+  }
+});
 Object.defineProperty(exports, "createPrint", {
   enumerable: true,
   get: function get() {
@@ -633,6 +657,18 @@ Object.defineProperty(exports, "createUsolve", {
     return _usolve.createUsolve;
   }
 });
+Object.defineProperty(exports, "createLsolveAll", {
+  enumerable: true,
+  get: function get() {
+    return _lsolveAll.createLsolveAll;
+  }
+});
+Object.defineProperty(exports, "createUsolveAll", {
+  enumerable: true,
+  get: function get() {
+    return _usolveAll.createUsolveAll;
+  }
+});
 Object.defineProperty(exports, "createLeftShift", {
   enumerable: true,
   get: function get() {
@@ -2096,6 +2132,8 @@ var _reshape = require("./function/matrix/reshape");
 
 var _resize = require("./function/matrix/resize");
 
+var _rotationMatrix = require("./function/matrix/rotationMatrix");
+
 var _row = require("./function/matrix/row");
 
 var _size = require("./function/matrix/size");
@@ -2118,6 +2156,12 @@ var _prod = require("./function/statistics/prod");
 
 var _format = require("./function/string/format");
 
+var _bin = require("./function/string/bin");
+
+var _oct = require("./function/string/oct");
+
+var _hex = require("./function/string/hex");
+
 var _print = require("./function/string/print");
 
 var _to = require("./function/unit/to");
@@ -2146,6 +2190,10 @@ var _lsolve = require("./function/algebra/solver/lsolve");
 
 var _usolve = require("./function/algebra/solver/usolve");
 
+var _lsolveAll = require("./function/algebra/solver/lsolveAll");
+
+var _usolveAll = require("./function/algebra/solver/usolveAll");
+
 var _leftShift = require("./function/bitwise/leftShift");
 
 var _rightArithShift = require("./function/bitwise/rightArithShift");

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

@@ -23,7 +23,7 @@ var createLsolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
     DenseMatrix: DenseMatrix
   });
   /**
-   * Solves the linear equation system by forwards substitution. Matrix must be a lower triangular matrix.
+   * 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.
    *
    * `L * x = b`
    *
@@ -39,7 +39,7 @@ var createLsolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
    *
    * See also:
    *
-   *    lup, slu, usolve, lusolve
+   *    lsolveAll, lup, slu, usolve, lusolve
    *
    * @param {Matrix, Array} L       A N x N matrix or array (L)
    * @param {Matrix, Array} b       A column vector with the b values
@@ -49,19 +49,15 @@ var createLsolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
 
   return typed(name, {
     'SparseMatrix, Array | Matrix': function SparseMatrixArrayMatrix(m, b) {
-      // process matrix
       return _sparseForwardSubstitution(m, b);
     },
     'DenseMatrix, Array | Matrix': function DenseMatrixArrayMatrix(m, b) {
-      // process matrix
       return _denseForwardSubstitution(m, b);
     },
     'Array, Array | Matrix': function ArrayArrayMatrix(a, b) {
-      // create dense matrix from array
-      var m = matrix(a); // use matrix implementation
-
-      var r = _denseForwardSubstitution(m, b); // result
+      var m = matrix(a);
 
+      var r = _denseForwardSubstitution(m, b);
 
       return r.valueOf();
     }
@@ -69,48 +65,38 @@ var createLsolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
 
   function _denseForwardSubstitution(m, b) {
     // validate matrix and vector, return copy of column vector b
-    b = solveValidation(m, b, true); // column vector data
-
-    var bdata = b._data; // rows & columns
-
+    b = solveValidation(m, b, true);
+    var bdata = b._data;
     var rows = m._size[0];
     var columns = m._size[1]; // result
 
-    var x = []; // data
-
-    var data = m._data; // forward solve m * x = b, loop columns
+    var x = [];
+    var mdata = m._data; // loop columns
 
     for (var j = 0; j < columns; j++) {
-      // b[j]
-      var bj = bdata[j][0] || 0; // x[j]
-
-      var xj = void 0; // forward substitution (outer product) avoids inner looping when bj === 0
+      var bj = bdata[j][0] || 0;
+      var xj = void 0;
 
       if (!equalScalar(bj, 0)) {
-        // value @ [j, j]
-        var vjj = data[j][j]; // check vjj
+        // non-degenerate row, find solution
+        var vjj = mdata[j][j];
 
         if (equalScalar(vjj, 0)) {
-          // system cannot be solved
           throw new Error('Linear system cannot be solved since matrix is singular');
-        } // calculate xj
-
+        }
 
         xj = divideScalar(bj, vjj); // loop rows
 
         for (var i = j + 1; i < rows; i++) {
-          // update copy of b
-          bdata[i] = [subtract(bdata[i][0] || 0, multiplyScalar(xj, data[i][j]))];
+          bdata[i] = [subtract(bdata[i][0] || 0, multiplyScalar(xj, mdata[i][j]))];
         }
       } else {
-        // zero @ j
+        // degenerate row, we can choose any value
         xj = 0;
-      } // update x
-
+      }
 
       x[j] = [xj];
-    } // return vector
-
+    }
 
     return new DenseMatrix({
       data: x,
@@ -120,72 +106,59 @@ var createLsolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
 
   function _sparseForwardSubstitution(m, b) {
     // validate matrix and vector, return copy of column vector b
-    b = solveValidation(m, b, true); // column vector data
-
-    var bdata = b._data; // rows & columns
-
+    b = solveValidation(m, b, true);
+    var bdata = b._data;
     var rows = m._size[0];
-    var columns = m._size[1]; // matrix arrays
-
+    var columns = m._size[1];
     var values = m._values;
     var index = m._index;
-    var ptr = m._ptr; // vars
+    var ptr = m._ptr; // result
 
-    var i, k; // result
-
-    var x = []; // forward solve m * x = b, loop columns
+    var x = []; // loop columns
 
     for (var j = 0; j < columns; j++) {
-      // b[j]
-      var bj = bdata[j][0] || 0; // forward substitution (outer product) avoids inner looping when bj === 0
+      var bj = bdata[j][0] || 0;
 
       if (!equalScalar(bj, 0)) {
-        // value @ [j, j]
-        var vjj = 0; // lower triangular matrix values & index (column j)
+        // non-degenerate row, find solution
+        var vjj = 0; // matrix values & indices (column j)
 
-        var jvalues = [];
-        var jindex = []; // last index in column
+        var jValues = [];
+        var jIndices = []; // first and last index in the column
 
-        var l = ptr[j + 1]; // values in column, find value @ [j, j]
+        var firstIndex = ptr[j];
+        var lastIndex = ptr[j + 1]; // values in column, find value at [j, j]
 
-        for (k = ptr[j]; k < l; k++) {
-          // row
-          i = index[k]; // check row (rows are not sorted!)
+        for (var k = firstIndex; k < lastIndex; k++) {
+          var i = index[k]; // check row (rows are not sorted!)
 
           if (i === j) {
-            // update vjj
             vjj = values[k];
           } else if (i > j) {
             // store lower triangular
-            jvalues.push(values[k]);
-            jindex.push(i);
+            jValues.push(values[k]);
+            jIndices.push(i);
           }
-        } // at this point we must have a value @ [j, j]
+        } // at this point we must have a value in vjj
 
 
         if (equalScalar(vjj, 0)) {
-          // system cannot be solved, there is no value @ [j, j]
           throw new Error('Linear system cannot be solved since matrix is singular');
-        } // calculate xj
-
-
-        var xj = divideScalar(bj, vjj); // loop lower triangular
-
-        for (k = 0, l = jindex.length; k < l; k++) {
-          // row
-          i = jindex[k]; // update copy of b
+        }
 
-          bdata[i] = [subtract(bdata[i][0] || 0, multiplyScalar(xj, jvalues[k]))];
-        } // update x
+        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 {
-        // update x
+        // degenerate row, we can choose any value
         x[j] = [0];
       }
-    } // return vector
-
+    }
 
     return new DenseMatrix({
       data: x,