mathjs-min 11.7.2

package/lib/cjs/function/matrix/range.js

@@ -0,0 +1,263 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRange = void 0;
+var _factory = require("../../utils/factory.js");
+var _noop = require("../../utils/noop.js");
+var name = 'range';
+var dependencies = ['typed', 'config', '?matrix', '?bignumber', 'smaller', 'smallerEq', 'larger', 'largerEq'];
+var createRange = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    config = _ref.config,
+    matrix = _ref.matrix,
+    bignumber = _ref.bignumber,
+    smaller = _ref.smaller,
+    smallerEq = _ref.smallerEq,
+    larger = _ref.larger,
+    largerEq = _ref.largerEq;
+  /**
+   * Create an array from a range.
+   * By default, the range end is excluded. This can be customized by providing
+   * an extra parameter `includeEnd`.
+   *
+   * Syntax:
+   *
+   *     math.range(str [, includeEnd])               // Create a range from a string,
+   *                                                  // where the string contains the
+   *                                                  // start, optional step, and end,
+   *                                                  // separated by a colon.
+   *     math.range(start, end [, includeEnd])        // Create a range with start and
+   *                                                  // end and a step size of 1.
+   *     math.range(start, end, step [, includeEnd])  // Create a range with start, step,
+   *                                                  // and end.
+   *
+   * Where:
+   *
+   * - `str: string`
+   *   A string 'start:end' or 'start:step:end'
+   * - `start: {number | BigNumber}`
+   *   Start of the range
+   * - `end: number | BigNumber`
+   *   End of the range, excluded by default, included when parameter includeEnd=true
+   * - `step: number | BigNumber`
+   *   Step size. Default value is 1.
+   * - `includeEnd: boolean`
+   *   Option to specify whether to include the end or not. False by default.
+   *
+   * Examples:
+   *
+   *     math.range(2, 6)        // [2, 3, 4, 5]
+   *     math.range(2, -3, -1)   // [2, 1, 0, -1, -2]
+   *     math.range('2:1:6')     // [2, 3, 4, 5]
+   *     math.range(2, 6, true)  // [2, 3, 4, 5, 6]
+   *
+   * See also:
+   *
+   *     ones, zeros, size, subset
+   *
+   * @param {*} args   Parameters describing the ranges `start`, `end`, and optional `step`.
+   * @return {Array | Matrix} range
+   */
+  return typed(name, {
+    // TODO: simplify signatures when typed-function supports default values and optional arguments
+
+    // TODO: a number or boolean should not be converted to string here
+    string: _strRange,
+    'string, boolean': _strRange,
+    'number, number': function numberNumber(start, end) {
+      return _out(_rangeEx(start, end, 1));
+    },
+    'number, number, number': function numberNumberNumber(start, end, step) {
+      return _out(_rangeEx(start, end, step));
+    },
+    'number, number, boolean': function numberNumberBoolean(start, end, includeEnd) {
+      return includeEnd ? _out(_rangeInc(start, end, 1)) : _out(_rangeEx(start, end, 1));
+    },
+    'number, number, number, boolean': function numberNumberNumberBoolean(start, end, step, includeEnd) {
+      return includeEnd ? _out(_rangeInc(start, end, step)) : _out(_rangeEx(start, end, step));
+    },
+    'BigNumber, BigNumber': function BigNumberBigNumber(start, end) {
+      var BigNumber = start.constructor;
+      return _out(_bigRangeEx(start, end, new BigNumber(1)));
+    },
+    'BigNumber, BigNumber, BigNumber': function BigNumberBigNumberBigNumber(start, end, step) {
+      return _out(_bigRangeEx(start, end, step));
+    },
+    'BigNumber, BigNumber, boolean': function BigNumberBigNumberBoolean(start, end, includeEnd) {
+      var BigNumber = start.constructor;
+      return includeEnd ? _out(_bigRangeInc(start, end, new BigNumber(1))) : _out(_bigRangeEx(start, end, new BigNumber(1)));
+    },
+    'BigNumber, BigNumber, BigNumber, boolean': function BigNumberBigNumberBigNumberBoolean(start, end, step, includeEnd) {
+      return includeEnd ? _out(_bigRangeInc(start, end, step)) : _out(_bigRangeEx(start, end, step));
+    }
+  });
+  function _out(arr) {
+    if (config.matrix === 'Matrix') {
+      return matrix ? matrix(arr) : (0, _noop.noMatrix)();
+    }
+    return arr;
+  }
+  function _strRange(str, includeEnd) {
+    var r = _parse(str);
+    if (!r) {
+      throw new SyntaxError('String "' + str + '" is no valid range');
+    }
+    var fn;
+    if (config.number === 'BigNumber') {
+      if (bignumber === undefined) {
+        (0, _noop.noBignumber)();
+      }
+      fn = includeEnd ? _bigRangeInc : _bigRangeEx;
+      return _out(fn(bignumber(r.start), bignumber(r.end), bignumber(r.step)));
+    } else {
+      fn = includeEnd ? _rangeInc : _rangeEx;
+      return _out(fn(r.start, r.end, r.step));
+    }
+  }
+
+  /**
+   * Create a range with numbers. End is excluded
+   * @param {number} start
+   * @param {number} end
+   * @param {number} step
+   * @returns {Array} range
+   * @private
+   */
+  function _rangeEx(start, end, step) {
+    var array = [];
+    var x = start;
+    if (step > 0) {
+      while (smaller(x, end)) {
+        array.push(x);
+        x += step;
+      }
+    } else if (step < 0) {
+      while (larger(x, end)) {
+        array.push(x);
+        x += step;
+      }
+    }
+    return array;
+  }
+
+  /**
+   * Create a range with numbers. End is included
+   * @param {number} start
+   * @param {number} end
+   * @param {number} step
+   * @returns {Array} range
+   * @private
+   */
+  function _rangeInc(start, end, step) {
+    var array = [];
+    var x = start;
+    if (step > 0) {
+      while (smallerEq(x, end)) {
+        array.push(x);
+        x += step;
+      }
+    } else if (step < 0) {
+      while (largerEq(x, end)) {
+        array.push(x);
+        x += step;
+      }
+    }
+    return array;
+  }
+
+  /**
+   * Create a range with big numbers. End is excluded
+   * @param {BigNumber} start
+   * @param {BigNumber} end
+   * @param {BigNumber} step
+   * @returns {Array} range
+   * @private
+   */
+  function _bigRangeEx(start, end, step) {
+    var zero = bignumber(0);
+    var array = [];
+    var x = start;
+    if (step.gt(zero)) {
+      while (smaller(x, end)) {
+        array.push(x);
+        x = x.plus(step);
+      }
+    } else if (step.lt(zero)) {
+      while (larger(x, end)) {
+        array.push(x);
+        x = x.plus(step);
+      }
+    }
+    return array;
+  }
+
+  /**
+   * Create a range with big numbers. End is included
+   * @param {BigNumber} start
+   * @param {BigNumber} end
+   * @param {BigNumber} step
+   * @returns {Array} range
+   * @private
+   */
+  function _bigRangeInc(start, end, step) {
+    var zero = bignumber(0);
+    var array = [];
+    var x = start;
+    if (step.gt(zero)) {
+      while (smallerEq(x, end)) {
+        array.push(x);
+        x = x.plus(step);
+      }
+    } else if (step.lt(zero)) {
+      while (largerEq(x, end)) {
+        array.push(x);
+        x = x.plus(step);
+      }
+    }
+    return array;
+  }
+
+  /**
+   * Parse a string into a range,
+   * The string contains the start, optional step, and end, separated by a colon.
+   * If the string does not contain a valid range, null is returned.
+   * For example str='0:2:11'.
+   * @param {string} str
+   * @return {{start: number, end: number, step: number} | null} range Object containing properties start, end, step
+   * @private
+   */
+  function _parse(str) {
+    var args = str.split(':');
+
+    // number
+    var nums = args.map(function (arg) {
+      // use Number and not parseFloat as Number returns NaN on invalid garbage in the string
+      return Number(arg);
+    });
+    var invalid = nums.some(function (num) {
+      return isNaN(num);
+    });
+    if (invalid) {
+      return null;
+    }
+    switch (nums.length) {
+      case 2:
+        return {
+          start: nums[0],
+          end: nums[1],
+          step: 1
+        };
+      case 3:
+        return {
+          start: nums[0],
+          end: nums[2],
+          step: nums[1]
+        };
+      default:
+        return null;
+    }
+  }
+});
+exports.createRange = createRange;

package/lib/cjs/function/matrix/reshape.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createReshape = void 0;
+var _array = require("../../utils/array.js");
+var _factory = require("../../utils/factory.js");
+var name = 'reshape';
+var dependencies = ['typed', 'isInteger', 'matrix'];
+var createReshape = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    isInteger = _ref.isInteger;
+  /**
+   * Reshape a multi dimensional array to fit the specified dimensions
+   *
+   * Syntax:
+   *
+   *     math.reshape(x, sizes)
+   *
+   * Examples:
+   *
+   *     math.reshape([1, 2, 3, 4, 5, 6], [2, 3])
+   *     // returns Array  [[1, 2, 3], [4, 5, 6]]
+   *
+   *     math.reshape([[1, 2], [3, 4]], [1, 4])
+   *     // returns Array  [[1, 2, 3, 4]]
+   *
+   *     math.reshape([[1, 2], [3, 4]], [4])
+   *     // returns Array [1, 2, 3, 4]
+   *
+   *     const x = math.matrix([1, 2, 3, 4, 5, 6, 7, 8])
+   *     math.reshape(x, [2, 2, 2])
+   *     // returns Matrix [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
+   *
+   *    math.reshape([1, 2, 3, 4], [-1, 2])
+   *    // returns Matrix [[1, 2], [3, 4]]
+   *
+   * See also:
+   *
+   *     size, squeeze, resize
+   *
+   * @param {Array | Matrix | *} x  Matrix to be reshaped
+   * @param {number[]} sizes        One dimensional array with integral sizes for
+   *                                each dimension. One -1 is allowed as wildcard,
+   *                                which calculates this dimension automatically.
+   *
+   * @return {* | Array | Matrix}   A reshaped clone of matrix `x`
+   *
+   * @throws {TypeError}            If `sizes` does not contain solely integers
+   * @throws {DimensionError}       If the product of the new dimension sizes does
+   *                                not equal that of the old ones
+   */
+  return typed(name, {
+    'Matrix, Array': function MatrixArray(x, sizes) {
+      return x.reshape(sizes, true);
+    },
+    'Array, Array': function ArrayArray(x, sizes) {
+      sizes.forEach(function (size) {
+        if (!isInteger(size)) {
+          throw new TypeError('Invalid size for dimension: ' + size);
+        }
+      });
+      return (0, _array.reshape)(x, sizes);
+    }
+  });
+});
+exports.createReshape = createReshape;

package/lib/cjs/function/matrix/resize.js

@@ -0,0 +1,126 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createResize = void 0;
+var _is = require("../../utils/is.js");
+var _DimensionError = require("../../error/DimensionError.js");
+var _ArgumentsError = require("../../error/ArgumentsError.js");
+var _number = require("../../utils/number.js");
+var _string = require("../../utils/string.js");
+var _object = require("../../utils/object.js");
+var _array = require("../../utils/array.js");
+var _factory = require("../../utils/factory.js");
+var name = 'resize';
+var dependencies = ['config', 'matrix'];
+var createResize = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var config = _ref.config,
+    matrix = _ref.matrix;
+  /**
+   * Resize a matrix
+   *
+   * Syntax:
+   *
+   *     math.resize(x, size)
+   *     math.resize(x, size, defaultValue)
+   *
+   * Examples:
+   *
+   *     math.resize([1, 2, 3, 4, 5], [3]) // returns Array  [1, 2, 3]
+   *     math.resize([1, 2, 3], [5], 0)    // returns Array  [1, 2, 3, 0, 0]
+   *     math.resize(2, [2, 3], 0)         // returns Matrix [[2, 0, 0], [0, 0, 0]]
+   *     math.resize("hello", [8], "!")    // returns string 'hello!!!'
+   *
+   * See also:
+   *
+   *     size, squeeze, subset, reshape
+   *
+   * @param {Array | Matrix | *} x             Matrix to be resized
+   * @param {Array | Matrix} size              One dimensional array with numbers
+   * @param {number | string} [defaultValue=0] Zero by default, except in
+   *                                           case of a string, in that case
+   *                                           defaultValue = ' '
+   * @return {* | Array | Matrix} A resized clone of matrix `x`
+   */
+  // TODO: rework resize to a typed-function
+  return function resize(x, size, defaultValue) {
+    if (arguments.length !== 2 && arguments.length !== 3) {
+      throw new _ArgumentsError.ArgumentsError('resize', arguments.length, 2, 3);
+    }
+    if ((0, _is.isMatrix)(size)) {
+      size = size.valueOf(); // get Array
+    }
+
+    if ((0, _is.isBigNumber)(size[0])) {
+      // convert bignumbers to numbers
+      size = size.map(function (value) {
+        return !(0, _is.isBigNumber)(value) ? value : value.toNumber();
+      });
+    }
+
+    // check x is a Matrix
+    if ((0, _is.isMatrix)(x)) {
+      // use optimized matrix implementation, return copy
+      return x.resize(size, defaultValue, true);
+    }
+    if (typeof x === 'string') {
+      // resize string
+      return _resizeString(x, size, defaultValue);
+    }
+
+    // check result should be a matrix
+    var asMatrix = Array.isArray(x) ? false : config.matrix !== 'Array';
+    if (size.length === 0) {
+      // output a scalar
+      while (Array.isArray(x)) {
+        x = x[0];
+      }
+      return (0, _object.clone)(x);
+    } else {
+      // output an array/matrix
+      if (!Array.isArray(x)) {
+        x = [x];
+      }
+      x = (0, _object.clone)(x);
+      var res = (0, _array.resize)(x, size, defaultValue);
+      return asMatrix ? matrix(res) : res;
+    }
+  };
+
+  /**
+   * Resize a string
+   * @param {string} str
+   * @param {number[]} size
+   * @param {string} [defaultChar=' ']
+   * @private
+   */
+  function _resizeString(str, size, defaultChar) {
+    if (defaultChar !== undefined) {
+      if (typeof defaultChar !== 'string' || defaultChar.length !== 1) {
+        throw new TypeError('Single character expected as defaultValue');
+      }
+    } else {
+      defaultChar = ' ';
+    }
+    if (size.length !== 1) {
+      throw new _DimensionError.DimensionError(size.length, 1);
+    }
+    var len = size[0];
+    if (typeof len !== 'number' || !(0, _number.isInteger)(len)) {
+      throw new TypeError('Invalid size, must contain positive integers ' + '(size: ' + (0, _string.format)(size) + ')');
+    }
+    if (str.length > len) {
+      return str.substring(0, len);
+    } else if (str.length < len) {
+      var res = str;
+      for (var i = 0, ii = len - str.length; i < ii; i++) {
+        res += defaultChar;
+      }
+      return res;
+    } else {
+      return str;
+    }
+  }
+});
+exports.createResize = createResize;

package/lib/cjs/function/matrix/rotate.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRotate = void 0;
+var _factory = require("../../utils/factory.js");
+var _array = require("../../utils/array.js");
+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 [-12, 11]
+     *    math.rotate(matrix([11, 12]), math.pi / 2)                   // returns [-12, 11]
+     *
+     *    math.rotate([1, 0, 0], unit('90deg'), [0, 0, 1])             // returns [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 [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;

package/lib/cjs/function/matrix/rotationMatrix.js

@@ -0,0 +1,167 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRotationMatrix = void 0;
+var _is = require("../../utils/is.js");
+var _factory = require("../../utils/factory.js");
+var name = 'rotationMatrix';
+var dependencies = ['typed', 'config', 'multiplyScalar', 'addScalar', 'unaryMinus', 'norm', 'matrix', 'BigNumber', 'DenseMatrix', 'SparseMatrix', 'cos', 'sin'];
+var createRotationMatrix = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    config = _ref.config,
+    multiplyScalar = _ref.multiplyScalar,
+    addScalar = _ref.addScalar,
+    unaryMinus = _ref.unaryMinus,
+    norm = _ref.norm,
+    BigNumber = _ref.BigNumber,
+    matrix = _ref.matrix,
+    DenseMatrix = _ref.DenseMatrix,
+    SparseMatrix = _ref.SparseMatrix,
+    cos = _ref.cos,
+    sin = _ref.sin;
+  /**
+   * Create a 2-dimensional counter-clockwise rotation matrix (2x2) for a given angle (expressed in radians).
+   * Create a 2-dimensional counter-clockwise rotation matrix (3x3) by a given angle (expressed in radians) around a given axis (1x3).
+   *
+   * Syntax:
+   *
+   *    math.rotationMatrix(theta)
+   *    math.rotationMatrix(theta, format)
+   *    math.rotationMatrix(theta, [v])
+   *    math.rotationMatrix(theta, [v], format)
+   *
+   * Examples:
+   *
+   *    math.rotationMatrix(math.pi / 2)                      // returns [[0, -1], [1, 0]]
+   *    math.rotationMatrix(math.bignumber(1))                // returns [[bignumber(cos(1)), bignumber(-sin(1))], [bignumber(sin(1)), bignumber(cos(1))]]
+   *    math.rotationMatrix(math.complex(1 + i))              // returns [[cos(1 + i), -sin(1 + i)], [sin(1 + i), cos(1 + i)]]
+   *    math.rotationMatrix(math.unit('1rad'))                // returns [[cos(1), -sin(1)], [sin(1), cos(1)]]
+   *
+   *    math.rotationMatrix(math.pi / 2, [0, 1, 0])           // returns [[0, 0, 1], [0, 1, 0], [-1, 0, 0]]
+   *    math.rotationMatrix(math.pi / 2, matrix([0, 1, 0]))   // returns matrix([[0, 0, 1], [0, 1, 0], [-1, 0, 0]])
+   *
+   *
+   * See also:
+   *
+   *    matrix, cos, sin
+   *
+   *
+   * @param {number | BigNumber | Complex | Unit} theta    Rotation angle
+   * @param {Array | Matrix} [v]                           Rotation axis
+   * @param {string} [format]                              Result Matrix storage format
+   * @return {Array | Matrix}                              Rotation matrix
+   */
+
+  return typed(name, {
+    '': function _() {
+      return config.matrix === 'Matrix' ? matrix([]) : [];
+    },
+    string: function string(format) {
+      return matrix(format);
+    },
+    'number | BigNumber | Complex | Unit': function numberBigNumberComplexUnit(theta) {
+      return _rotationMatrix2x2(theta, config.matrix === 'Matrix' ? 'dense' : undefined);
+    },
+    'number | BigNumber | Complex | Unit, string': function numberBigNumberComplexUnitString(theta, format) {
+      return _rotationMatrix2x2(theta, format);
+    },
+    'number | BigNumber | Complex | Unit, Array': function numberBigNumberComplexUnitArray(theta, v) {
+      var matrixV = matrix(v);
+      _validateVector(matrixV);
+      return _rotationMatrix3x3(theta, matrixV, undefined);
+    },
+    'number | BigNumber | Complex | Unit, Matrix': function numberBigNumberComplexUnitMatrix(theta, v) {
+      _validateVector(v);
+      var storageType = v.storage() || (config.matrix === 'Matrix' ? 'dense' : undefined);
+      return _rotationMatrix3x3(theta, v, storageType);
+    },
+    'number | BigNumber | Complex | Unit, Array, string': function numberBigNumberComplexUnitArrayString(theta, v, format) {
+      var matrixV = matrix(v);
+      _validateVector(matrixV);
+      return _rotationMatrix3x3(theta, matrixV, format);
+    },
+    'number | BigNumber | Complex | Unit, Matrix, string': function numberBigNumberComplexUnitMatrixString(theta, v, format) {
+      _validateVector(v);
+      return _rotationMatrix3x3(theta, v, format);
+    }
+  });
+
+  /**
+   * Returns 2x2 matrix of 2D rotation of angle theta
+   *
+   * @param {number | BigNumber | Complex | Unit} theta  The rotation angle
+   * @param {string} format                              The result Matrix storage format
+   * @returns {Matrix}
+   * @private
+   */
+  function _rotationMatrix2x2(theta, format) {
+    var Big = (0, _is.isBigNumber)(theta);
+    var minusOne = Big ? new BigNumber(-1) : -1;
+    var cosTheta = cos(theta);
+    var sinTheta = sin(theta);
+    var data = [[cosTheta, multiplyScalar(minusOne, sinTheta)], [sinTheta, cosTheta]];
+    return _convertToFormat(data, format);
+  }
+  function _validateVector(v) {
+    var size = v.size();
+    if (size.length < 1 || size[0] !== 3) {
+      throw new RangeError('Vector must be of dimensions 1x3');
+    }
+  }
+  function _mul(array) {
+    return array.reduce(function (p, curr) {
+      return multiplyScalar(p, curr);
+    });
+  }
+  function _convertToFormat(data, format) {
+    if (format) {
+      if (format === 'sparse') {
+        return new SparseMatrix(data);
+      }
+      if (format === 'dense') {
+        return new DenseMatrix(data);
+      }
+      throw new TypeError("Unknown matrix type \"".concat(format, "\""));
+    }
+    return data;
+  }
+
+  /**
+   * Returns a 3x3 matrix of rotation of angle theta around vector v
+   *
+   * @param {number | BigNumber | Complex | Unit} theta The rotation angle
+   * @param {Matrix} v                                  The rotation axis vector
+   * @param {string} format                             The storage format of the resulting matrix
+   * @returns {Matrix}
+   * @private
+   */
+  function _rotationMatrix3x3(theta, v, format) {
+    var normV = norm(v);
+    if (normV === 0) {
+      throw new RangeError('Rotation around zero vector');
+    }
+    var Big = (0, _is.isBigNumber)(theta) ? BigNumber : null;
+    var one = Big ? new Big(1) : 1;
+    var minusOne = Big ? new Big(-1) : -1;
+    var vx = Big ? new Big(v.get([0]) / normV) : v.get([0]) / normV;
+    var vy = Big ? new Big(v.get([1]) / normV) : v.get([1]) / normV;
+    var vz = Big ? new Big(v.get([2]) / normV) : v.get([2]) / normV;
+    var c = cos(theta);
+    var oneMinusC = addScalar(one, unaryMinus(c));
+    var s = sin(theta);
+    var r11 = addScalar(c, _mul([vx, vx, oneMinusC]));
+    var r12 = addScalar(_mul([vx, vy, oneMinusC]), _mul([minusOne, vz, s]));
+    var r13 = addScalar(_mul([vx, vz, oneMinusC]), _mul([vy, s]));
+    var r21 = addScalar(_mul([vx, vy, oneMinusC]), _mul([vz, s]));
+    var r22 = addScalar(c, _mul([vy, vy, oneMinusC]));
+    var r23 = addScalar(_mul([vy, vz, oneMinusC]), _mul([minusOne, vx, s]));
+    var r31 = addScalar(_mul([vx, vz, oneMinusC]), _mul([minusOne, vy, s]));
+    var r32 = addScalar(_mul([vy, vz, oneMinusC]), _mul([vx, s]));
+    var r33 = addScalar(c, _mul([vz, vz, oneMinusC]));
+    var data = [[r11, r12, r13], [r21, r22, r23], [r31, r32, r33]];
+    return _convertToFormat(data, format);
+  }
+});
+exports.createRotationMatrix = createRotationMatrix;