mathjs 7.3.0 → 7.6.0

package/lib/expression/embeddedDocs/embeddedDocs.js

@@ -437,6 +437,10 @@ var _column = require("./function/matrix/column");
 
 var _row = require("./function/matrix/row");
 
+var _rotationMatrix = require("./function/matrix/rotationMatrix");
+
+var _rotate = require("./function/matrix/rotate");
+
 var embeddedDocs = {
   // construction functions
   bignumber: _bignumber.bignumberDocs,
@@ -780,6 +784,8 @@ var embeddedDocs = {
   range: _range.rangeDocs,
   resize: _resize.resizeDocs,
   reshape: _reshape.reshapeDocs,
+  rotate: _rotate.rotateDocs,
+  rotationMatrix: _rotationMatrix.rotationMatrixDocs,
   row: _row.rowDocs,
   size: _size.sizeDocs,
   sort: _sort.sortDocs,

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.rotateDocs = void 0;
+var rotateDocs = {
+  name: 'rotate',
+  category: 'Matrix',
+  syntax: ['rotate(w, theta)', 'rotate(w, theta, v)'],
+  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: ['rotate([1, 0], math.pi / 2)', 'rotate(matrix([1, 0]), unit("35deg"))', 'rotate([1, 0, 0], unit("90deg"), [0, 0, 1])', 'rotate(matrix([1, 0, 0]), unit("90deg"), matrix([0, 0, 1]))'],
+  seealso: ['matrix', 'rotationMatrix']
+};
+exports.rotateDocs = rotateDocs;

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/node/FunctionNode.js

@@ -303,7 +303,7 @@ var createFunctionNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
     var latex = ''; // Match everything of the form ${identifier} or ${identifier[2]} or $$
     // while submatching identifier and 2 (in the second case)
 
-    var regex = new RegExp('\\$(?:\\{([a-z_][a-z_0-9]*)(?:\\[([0-9]+)\\])?\\}|\\$)', 'ig');
+    var regex = /\$(?:\{([a-z_][a-z_0-9]*)(?:\[([0-9]+)\])?\}|\$)/gi;
     var inputPos = 0; // position in the input string
 
     var match;

package/lib/expression/node/Node.js

@@ -134,8 +134,8 @@ var createNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
 
   Node.prototype.traverse = function (callback) {
     // execute callback for itself
-    callback(this, null, null); // eslint-disable-line standard/no-callback-literal
-    // recursively traverse over all childs of a node
+    // eslint-disable-next-line
+    callback(this, null, null); // recursively traverse over all childs of a node
 
     function _traverse(node, callback) {
       node.forEach(function (child, path, parent) {

package/lib/factoriesAny.js

@@ -483,6 +483,18 @@ Object.defineProperty(exports, "createResize", {
     return _resize.createResize;
   }
 });
+Object.defineProperty(exports, "createRotate", {
+  enumerable: true,
+  get: function get() {
+    return _rotate.createRotate;
+  }
+});
+Object.defineProperty(exports, "createRotationMatrix", {
+  enumerable: true,
+  get: function get() {
+    return _rotationMatrix.createRotationMatrix;
+  }
+});
 Object.defineProperty(exports, "createRow", {
   enumerable: true,
   get: function get() {
@@ -2126,6 +2138,10 @@ var _reshape = require("./function/matrix/reshape");
 
 var _resize = require("./function/matrix/resize");
 
+var _rotate = require("./function/matrix/rotate");
+
+var _rotationMatrix = require("./function/matrix/rotationMatrix");
+
 var _row = require("./function/matrix/row");
 
 var _size = require("./function/matrix/size");

package/lib/function/arithmetic/ceil.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createCeil = void 0;
 
+var _decimal = require("decimal.js");
+
 var _factory = require("../../utils/factory");
 
 var _collection = require("../../utils/collection");
@@ -15,13 +17,37 @@ var _nearlyEqual = require("../../utils/bignumber/nearlyEqual");
 
 var _number2 = require("../../plain/number");
 
+var _algorithm = require("../../type/matrix/utils/algorithm11");
+
+var _algorithm2 = require("../../type/matrix/utils/algorithm14");
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
 var name = 'ceil';
-var dependencies = ['typed', 'config', 'round'];
+var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar'];
 var createCeil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
       config = _ref.config,
-      round = _ref.round;
-
+      round = _ref.round,
+      matrix = _ref.matrix,
+      equalScalar = _ref.equalScalar;
+  var algorithm11 = (0, _algorithm.createAlgorithm11)({
+    typed: typed,
+    equalScalar: equalScalar
+  });
+  var algorithm14 = (0, _algorithm2.createAlgorithm14)({
+    typed: typed
+  });
   /**
    * Round a value towards plus infinity
    * If `x` is complex, both real and imaginary part are rounded towards plus infinity.
@@ -30,6 +56,7 @@ var createCeil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
    * Syntax:
    *
    *    math.ceil(x)
+   *    math.ceil(x, n)
    *
    * Examples:
    *
@@ -38,18 +65,27 @@ var createCeil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
    *    math.ceil(-4.2)              // returns number -4
    *    math.ceil(-4.7)              // returns number -4
    *
-   *    const c = math.complex(3.2, -2.7)
+   *    math.ceil(3.212, 2)          // returns number 3.22
+   *    math.ceil(3.288, 2)          // returns number 3.29
+   *    math.ceil(-4.212, 2)         // returns number -4.21
+   *    math.ceil(-4.782, 2)         // returns number -4.78
+   *
+   *    const c = math.complex(3.24, -2.71)
    *    math.ceil(c)                 // returns Complex 4 - 2i
+   *    math.ceil(c, 1)              // returns Complex 3.3 - 2.7i
    *
    *    math.ceil([3.2, 3.8, -4.7])  // returns Array [4, 4, -4]
+   *    math.ceil([3.21, 3.82, -4.71], 1)  // returns Array [3.3, 3.9, -4.7]
    *
    * See also:
    *
    *    floor, fix, round
    *
    * @param  {number | BigNumber | Fraction | Complex | Array | Matrix} x  Number to be rounded
+   * @param  {number | BigNumber | Array} [n=0]                            Number of decimals
    * @return {number | BigNumber | Fraction | Complex | Array | Matrix} Rounded value
    */
+
   return typed('ceil', {
     number: function number(x) {
       if ((0, _number.nearlyEqual)(x, round(x), config.epsilon)) {
@@ -58,9 +94,32 @@ var createCeil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
         return (0, _number2.ceilNumber)(x);
       }
     },
+    'number, number': function numberNumber(x, n) {
+      if ((0, _number.nearlyEqual)(x, round(x, n), config.epsilon)) {
+        return round(x, n);
+      } else {
+        var _$split = "".concat(x, "e").split('e'),
+            _$split2 = _slicedToArray(_$split, 2),
+            number = _$split2[0],
+            exponent = _$split2[1];
+
+        var result = Math.ceil(Number("".concat(number, "e").concat(Number(exponent) + n)));
+
+        var _$split3 = "".concat(result, "e").split('e');
+
+        var _$split4 = _slicedToArray(_$split3, 2);
+
+        number = _$split4[0];
+        exponent = _$split4[1];
+        return Number("".concat(number, "e").concat(Number(exponent) - n));
+      }
+    },
     Complex: function Complex(x) {
       return x.ceil();
     },
+    'Complex, number': function ComplexNumber(x, n) {
+      return x.ceil(n);
+    },
     BigNumber: function BigNumber(x) {
       if ((0, _nearlyEqual.nearlyEqual)(x, round(x), config.epsilon)) {
         return round(x);
@@ -68,12 +127,40 @@ var createCeil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
         return x.ceil();
       }
     },
+    'BigNumber, BigNumber': function BigNumberBigNumber(x, n) {
+      if ((0, _nearlyEqual.nearlyEqual)(x, round(x, n), config.epsilon)) {
+        return round(x, n);
+      } else {
+        return x.toDecimalPlaces(n.toNumber(), _decimal.Decimal.ROUND_CEIL);
+      }
+    },
     Fraction: function Fraction(x) {
       return x.ceil();
     },
+    'Fraction, number': function FractionNumber(x, n) {
+      return x.ceil(n);
+    },
     'Array | Matrix': function ArrayMatrix(x) {
       // deep map collection, skip zeros since ceil(0) = 0
       return (0, _collection.deepMap)(x, this, true);
+    },
+    'Array | Matrix, number': function ArrayMatrixNumber(x, n) {
+      var _this = this;
+
+      // deep map collection, skip zeros since ceil(0) = 0
+      return (0, _collection.deepMap)(x, function (i) {
+        return _this(i, n);
+      }, true);
+    },
+    'SparseMatrix, number | BigNumber': function SparseMatrixNumberBigNumber(x, y) {
+      return algorithm11(x, y, this, false);
+    },
+    'DenseMatrix, number | BigNumber': function DenseMatrixNumberBigNumber(x, y) {
+      return algorithm14(x, y, this, false);
+    },
+    'number | Complex | BigNumber, Array': function numberComplexBigNumberArray(x, y) {
+      // use matrix implementation
+      return algorithm14(matrix(y), x, this, true).valueOf();
     }
   });
 });

package/lib/function/arithmetic/fix.js

@@ -9,14 +9,19 @@ var _factory = require("../../utils/factory");
 
 var _collection = require("../../utils/collection");
 
+var _algorithm = require("../../type/matrix/utils/algorithm14");
+
 var name = 'fix';
-var dependencies = ['typed', 'Complex', 'ceil', 'floor'];
+var dependencies = ['typed', 'Complex', 'matrix', 'ceil', 'floor'];
 var createFix = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
       _Complex = _ref.Complex,
+      matrix = _ref.matrix,
       ceil = _ref.ceil,
       floor = _ref.floor;
-
+  var algorithm14 = (0, _algorithm.createAlgorithm14)({
+    typed: typed
+  });
   /**
    * Round a value towards zero.
    * For matrices, the function is evaluated element wise.
@@ -32,34 +37,67 @@ var createFix = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
    *    math.fix(-4.2)               // returns number -4
    *    math.fix(-4.7)               // returns number -4
    *
-   *    const c = math.complex(3.2, -2.7)
+   *    math.fix(3.12, 1)                // returns number 3.1
+   *    math.fix(3.18, 1)                // returns number 3.1
+   *    math.fix(-4.12, 1)               // returns number -4.1
+   *    math.fix(-4.17, 1)               // returns number -4.1
+   *
+   *    const c = math.complex(3.22, -2.78)
    *    math.fix(c)                  // returns Complex 3 - 2i
+   *    math.fix(c, 1)               // returns Complex 3.2 - 2.7i
    *
-   *    math.fix([3.2, 3.8, -4.7])   // returns Array [3, 3, -4]
+   *    math.fix([3.2, 3.8, -4.7])      // returns Array [3, 3, -4]
+   *    math.fix([3.2, 3.8, -4.7], 1)   // returns Array [3.2, 3.8, -4.7]
    *
    * See also:
    *
    *    ceil, floor, round
    *
-   * @param {number | BigNumber | Fraction | Complex | Array | Matrix} x Number to be rounded
-   * @return {number | BigNumber | Fraction | Complex | Array | Matrix}            Rounded value
+   * @param  {number | BigNumber | Fraction | Complex | Array | Matrix} x    Number to be rounded
+   * @param  {number | BigNumber | Array} [n=0]                             Number of decimals
+   * @return {number | BigNumber | Fraction | Complex | Array | Matrix}     Rounded value
    */
+
   return typed('fix', {
     number: function number(x) {
       return x > 0 ? floor(x) : ceil(x);
     },
+    'number, number | BigNumber': function numberNumberBigNumber(x, n) {
+      return x > 0 ? floor(x, n) : ceil(x, n);
+    },
     Complex: function Complex(x) {
       return new _Complex(x.re > 0 ? Math.floor(x.re) : Math.ceil(x.re), x.im > 0 ? Math.floor(x.im) : Math.ceil(x.im));
     },
+    'Complex, number | BigNumber': function ComplexNumberBigNumber(x, n) {
+      return new _Complex(x.re > 0 ? floor(x.re, n) : ceil(x.re, n), x.im > 0 ? floor(x.im, n) : ceil(x.im, n));
+    },
     BigNumber: function BigNumber(x) {
       return x.isNegative() ? ceil(x) : floor(x);
     },
+    'BigNumber, number | BigNumber': function BigNumberNumberBigNumber(x, n) {
+      return x.isNegative() ? ceil(x, n) : floor(x, n);
+    },
     Fraction: function Fraction(x) {
       return x.s < 0 ? x.ceil() : x.floor();
     },
+    'Fraction, number | BigNumber': function FractionNumberBigNumber(x, n) {
+      return x.s < 0 ? x.ceil(n) : x.floor(n);
+    },
     'Array | Matrix': function ArrayMatrix(x) {
       // deep map collection, skip zeros since fix(0) = 0
       return (0, _collection.deepMap)(x, this, true);
+    },
+    'Array | Matrix, number | BigNumber': function ArrayMatrixNumberBigNumber(x, n) {
+      var _this = this;
+
+      // deep map collection, skip zeros since fix(0) = 0
+      return (0, _collection.deepMap)(x, function (i) {
+        return _this(i, n);
+      }, true);
+    },
+    'number | Complex | BigNumber, Array': function numberComplexBigNumberArray(x, y) {
+      // use matrix implementation
+      return algorithm14(matrix(y), x, this, true).valueOf();
     }
   });
 });

package/lib/function/arithmetic/floor.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createFloor = void 0;
 
+var _decimal = require("decimal.js");
+
 var _factory = require("../../utils/factory");
 
 var _collection = require("../../utils/collection");
@@ -13,13 +15,37 @@ var _number = require("../../utils/number");
 
 var _nearlyEqual = require("../../utils/bignumber/nearlyEqual");
 
+var _algorithm = require("../../type/matrix/utils/algorithm11");
+
+var _algorithm2 = require("../../type/matrix/utils/algorithm14");
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
 var name = 'floor';
-var dependencies = ['typed', 'config', 'round'];
+var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar'];
 var createFloor = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
       config = _ref.config,
-      round = _ref.round;
-
+      round = _ref.round,
+      matrix = _ref.matrix,
+      equalScalar = _ref.equalScalar;
+  var algorithm11 = (0, _algorithm.createAlgorithm11)({
+    typed: typed,
+    equalScalar: equalScalar
+  });
+  var algorithm14 = (0, _algorithm2.createAlgorithm14)({
+    typed: typed
+  });
   /**
    * Round a value towards minus infinity.
    * For matrices, the function is evaluated element wise.
@@ -27,6 +53,7 @@ var createFloor = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
    * Syntax:
    *
    *    math.floor(x)
+   *    math.floor(x, n)
    *
    * Examples:
    *
@@ -35,18 +62,27 @@ var createFloor = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
    *    math.floor(-4.2)             // returns number -5
    *    math.floor(-4.7)             // returns number -5
    *
-   *    const c = math.complex(3.2, -2.7)
-   *    math.floor(c)                // returns Complex 3 - 3i
+   *    math.floor(3.212, 2)          // returns number 3.21
+   *    math.floor(3.288, 2)          // returns number 3.28
+   *    math.floor(-4.212, 2)         // returns number -4.22
+   *    math.floor(-4.782, 2)         // returns number -4.79
    *
-   *    math.floor([3.2, 3.8, -4.7]) // returns Array [3, 3, -5]
+   *    const c = math.complex(3.24, -2.71)
+   *    math.floor(c)                 // returns Complex 3 - 3i
+   *    math.floor(c, 1)              // returns Complex 3.2 - 2.8i
+   *
+   *    math.floor([3.2, 3.8, -4.7])       // returns Array [3, 3, -5]
+   *    math.floor([3.21, 3.82, -4.71], 1)  // returns Array [3.2, 3.8, -4.8]
    *
    * See also:
    *
    *    ceil, fix, round
    *
    * @param  {number | BigNumber | Fraction | Complex | Array | Matrix} x  Number to be rounded
+   * @param  {number | BigNumber | Array} [n=0]                            Number of decimals
    * @return {number | BigNumber | Fraction | Complex | Array | Matrix} Rounded value
    */
+
   return typed('floor', {
     number: function number(x) {
       if ((0, _number.nearlyEqual)(x, round(x), config.epsilon)) {
@@ -55,9 +91,32 @@ var createFloor = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
         return Math.floor(x);
       }
     },
+    'number, number': function numberNumber(x, n) {
+      if ((0, _number.nearlyEqual)(x, round(x, n), config.epsilon)) {
+        return round(x, n);
+      } else {
+        var _$split = "".concat(x, "e").split('e'),
+            _$split2 = _slicedToArray(_$split, 2),
+            number = _$split2[0],
+            exponent = _$split2[1];
+
+        var result = Math.floor(Number("".concat(number, "e").concat(Number(exponent) + n)));
+
+        var _$split3 = "".concat(result, "e").split('e');
+
+        var _$split4 = _slicedToArray(_$split3, 2);
+
+        number = _$split4[0];
+        exponent = _$split4[1];
+        return Number("".concat(number, "e").concat(Number(exponent) - n));
+      }
+    },
     Complex: function Complex(x) {
       return x.floor();
     },
+    'Complex, number': function ComplexNumber(x, n) {
+      return x.floor(n);
+    },
     BigNumber: function BigNumber(x) {
       if ((0, _nearlyEqual.nearlyEqual)(x, round(x), config.epsilon)) {
         return round(x);
@@ -65,12 +124,40 @@ var createFloor = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
         return x.floor();
       }
     },
+    'BigNumber, BigNumber': function BigNumberBigNumber(x, n) {
+      if ((0, _nearlyEqual.nearlyEqual)(x, round(x, n), config.epsilon)) {
+        return round(x, n);
+      } else {
+        return x.toDecimalPlaces(n.toNumber(), _decimal.Decimal.ROUND_FLOOR);
+      }
+    },
     Fraction: function Fraction(x) {
       return x.floor();
     },
+    'Fraction, number': function FractionNumber(x, n) {
+      return x.floor(n);
+    },
     'Array | Matrix': function ArrayMatrix(x) {
       // deep map collection, skip zeros since floor(0) = 0
       return (0, _collection.deepMap)(x, this, true);
+    },
+    'Array | Matrix, number': function ArrayMatrixNumber(x, n) {
+      var _this = this;
+
+      // deep map collection, skip zeros since ceil(0) = 0
+      return (0, _collection.deepMap)(x, function (i) {
+        return _this(i, n);
+      }, true);
+    },
+    'SparseMatrix, number | BigNumber': function SparseMatrixNumberBigNumber(x, y) {
+      return algorithm11(x, y, this, false);
+    },
+    'DenseMatrix, number | BigNumber': function DenseMatrixNumberBigNumber(x, y) {
+      return algorithm14(x, y, this, false);
+    },
+    'number | Complex | BigNumber, Array': function numberComplexBigNumberArray(x, y) {
+      // use matrix implementation
+      return algorithm14(matrix(y), x, this, true).valueOf();
     }
   });
 });

package/lib/function/arithmetic/round.js

@@ -57,10 +57,14 @@ var createRound = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
    *
    * Examples:
    *
-   *    math.round(3.2)              // returns number 3
-   *    math.round(3.8)              // returns number 4
+   *    math.round(3.22)             // returns number 3
+   *    math.round(3.82)             // returns number 4
    *    math.round(-4.2)             // returns number -4
    *    math.round(-4.7)             // returns number -5
+   *    math.round(3.22, 1)          // returns number 3.2
+   *    math.round(3.88, 1)          // returns number 3.8
+   *    math.round(-4.21, 1)         // returns number -4.2
+   *    math.round(-4.71, 1)         // returns number -4.7
    *    math.round(math.pi, 3)       // returns number 3.142
    *    math.round(123.45678, 2)     // returns number 123.46
    *

package/lib/function/matrix/rotate.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRotate = void 0;
+
+var _factory = require("../../utils/factory");
+
+var _array = require("../../utils/array");
+
+var name = 'rotate';
+var dependencies = ['typed', 'multiply', 'rotationMatrix'];
+var createRotate = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+      multiply = _ref.multiply,
+      rotationMatrix = _ref.rotationMatrix;
+
+  /**
+     * Rotate a vector of size 1x2 counter-clockwise by a given angle
+     * Rotate a vector of size 1x3 counter-clockwise by a given angle around the given axis
+     *
+     * Syntax:
+     *
+     *    math.rotate(w, theta)
+     *    math.rotate(w, theta, v)
+     *
+     * Examples:
+     *
+     *    math.rotate([11, 12], math.pi / 2)                           // returns matrix([-12, 11])
+     *    math.rotate(matrix([11, 12]), math.pi / 2)                   // returns matrix([-12, 11])
+     *
+     *    math.rotate([1, 0, 0], unit('90deg'), [0, 0, 1])             // returns matrix([0, 1, 0])
+     *    math.rotate(matrix([1, 0, 0]), unit('90deg'), [0, 0, 1])     // returns matrix([0, 1, 0])
+     *
+     *    math.rotate([1, 0], math.complex(1 + i))                     // returns matrix([cos(1 + i) - sin(1 + i), sin(1 + i) + cos(1 + i)])
+     *
+     * See also:
+     *
+     *    matrix, rotationMatrix
+     *
+     * @param {Array | Matrix} w                             Vector to rotate
+     * @param {number | BigNumber | Complex | Unit} theta    Rotation angle
+     * @param {Array | Matrix} [v]                           Rotation axis
+     * @return {Array | Matrix}                              Multiplication of the rotation matrix and w
+     */
+  return typed(name, {
+    'Array , number | BigNumber | Complex | Unit': function ArrayNumberBigNumberComplexUnit(w, theta) {
+      _validateSize(w, 2);
+
+      var matrixRes = multiply(rotationMatrix(theta), w);
+      return matrixRes.toArray();
+    },
+    'Matrix , number | BigNumber | Complex | Unit': function MatrixNumberBigNumberComplexUnit(w, theta) {
+      _validateSize(w, 2);
+
+      return multiply(rotationMatrix(theta), w);
+    },
+    'Array, number | BigNumber | Complex | Unit, Array | Matrix': function ArrayNumberBigNumberComplexUnitArrayMatrix(w, theta, v) {
+      _validateSize(w, 3);
+
+      var matrixRes = multiply(rotationMatrix(theta, v), w);
+      return matrixRes;
+    },
+    'Matrix, number | BigNumber | Complex | Unit, Array | Matrix': function MatrixNumberBigNumberComplexUnitArrayMatrix(w, theta, v) {
+      _validateSize(w, 3);
+
+      return multiply(rotationMatrix(theta, v), w);
+    }
+  });
+
+  function _validateSize(v, expectedSize) {
+    var actualSize = Array.isArray(v) ? (0, _array.arraySize)(v) : v.size();
+
+    if (actualSize.length > 2) {
+      throw new RangeError("Vector must be of dimensions 1x".concat(expectedSize));
+    }
+
+    if (actualSize.length === 2 && actualSize[1] !== 1) {
+      throw new RangeError("Vector must be of dimensions 1x".concat(expectedSize));
+    }
+
+    if (actualSize[0] !== expectedSize) {
+      throw new RangeError("Vector must be of dimensions 1x".concat(expectedSize));
+    }
+  }
+});
+exports.createRotate = createRotate;