mathjs 7.2.0 → 7.5.1

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/mod.js

@@ -94,10 +94,19 @@ var createMod = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
   return typed(name, {
     'number, number': _number.modNumber,
     'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+      if (y.isNeg()) {
+        throw new Error('Cannot calculate mod for a negative divisor');
+      }
+
       return y.isZero() ? x : x.mod(y);
     },
     'Fraction, Fraction': function FractionFraction(x, y) {
-      return x.mod(y);
+      if (y.compare(0) < 0) {
+        throw new Error('Cannot calculate mod for a negative divisor');
+      } // Workaround suggested in Fraction.js library to calculate correct modulo for negative dividend
+
+
+      return x.compare(0) >= 0 ? x.mod(y) : x.mod(y).add(y).mod(y);
     },
     'SparseMatrix, SparseMatrix': function SparseMatrixSparseMatrix(x, y) {
       return algorithm05(x, y, this, false);

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/rotationMatrix.js

@@ -0,0 +1,185 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRotationMatrix = void 0;
+
+var _is = require("../../utils/is");
+
+var _factory = require("../../utils/factory");
+
+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(45))               // returns [[ bignumber(1 / sqrt(2)), - bignumber(1 / sqrt(2))], [ bignumber(1 / sqrt(2)),  bignumber(1 / sqrt(2))]]
+   *    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, config.matrix === 'Matrix' ? 'dense' : undefined);
+    },
+    'number | BigNumber | Complex | Unit, Matrix': function numberBigNumberComplexUnitMatrix(theta, v) {
+      _validateVector(v);
+
+      return _rotationMatrix3x3(theta, v, config.matrix === 'Matrix' ? 'dense' : undefined);
+    },
+    '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) {
+      return _convertToFormat([], format);
+    }
+
+    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;

package/lib/function/matrix/sqrtm.js

@@ -105,6 +105,10 @@ var createSqrtm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
               throw new RangeError('Matrix must be square ' + '(size: ' + (0, _string.format)(size) + ')');
             }
           }
+
+        default:
+          // Multi dimensional array
+          throw new RangeError('Matrix must be at most two dimensional ' + '(size: ' + (0, _string.format)(size) + ')');
       }
     }
   });

package/lib/function/probability/pickRandom.js

@@ -9,10 +9,10 @@ var _factory = require("../../utils/factory");
 
 var _is = require("../../utils/is");
 
-var _array = require("../../utils/array");
-
 var _seededRNG = require("./util/seededRNG");
 
+var _array = require("../../utils/array");
+
 var name = 'pickRandom';
 var dependencies = ['typed', 'config', '?on'];
 var createPickRandom = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
@@ -86,16 +86,12 @@ var createPickRandom = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
       number = 1;
     }
 
-    possibles = possibles.valueOf(); // get Array
+    possibles = (0, _array.flatten)(possibles.valueOf()).valueOf(); // get Array
 
     if (weights) {
       weights = weights.valueOf(); // get Array
     }
 
-    if ((0, _array.arraySize)(possibles).length > 1) {
-      throw new Error('Only one dimensional vectors supported');
-    }
-
     var totalWeights = 0;
 
     if (typeof weights !== 'undefined') {

package/lib/function/statistics/variance.js

@@ -109,7 +109,7 @@ var createVariance = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
    */
 
   function _var(array, normalization) {
-    var sum = 0;
+    var sum;
     var num = 0;
 
     if (array.length === 0) {
@@ -119,7 +119,7 @@ var createVariance = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
 
     (0, _collection.deepForEach)(array, function (value) {
       try {
-        sum = add(sum, value);
+        sum = sum === undefined ? value : add(sum, value);
         num++;
       } catch (err) {
         throw (0, _improveErrorMessage.improveErrorMessage)(err, 'variance', value);
@@ -128,10 +128,10 @@ var createVariance = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
     if (num === 0) throw new Error('Cannot calculate variance of an empty array');
     var mean = divide(sum, num); // calculate the variance
 
-    sum = 0;
+    sum = undefined;
     (0, _collection.deepForEach)(array, function (value) {
       var diff = subtract(value, mean);
-      sum = add(sum, multiply(diff, diff));
+      sum = sum === undefined ? multiply(diff, diff) : add(sum, multiply(diff, diff));
     });
 
     if (isNaN(sum)) {

package/lib/function/string/baseUtils.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createBaseFormatterFactory = createBaseFormatterFactory;
+
+var _factory = require("../../utils/factory");
+
+var _number = require("../../utils/number");
+
+function baseFormatter(base) {
+  var prefixes = {
+    2: '0b',
+    8: '0o',
+    16: '0x'
+  };
+  var prefix = prefixes[base];
+  return function (n) {
+    if (n > Math.pow(2, 31) - 1 || n < -Math.pow(2, 31)) {
+      throw new Error('Value must be in range [-2^31, 2^31-1]');
+    }
+
+    if (!(0, _number.isInteger)(n)) {
+      throw new Error('Value must be an integer');
+    }
+
+    if (n < 0) {
+      n = n + Math.pow(2, 32);
+    }
+
+    return "".concat(prefix).concat(n.toString(base));
+  };
+}
+
+var dependencies = ['typed'];
+
+function createBaseFormatterFactory(name, base) {
+  return (0, _factory.factory)(name, dependencies, function (_ref) {
+    var typed = _ref.typed;
+    return typed(name, {
+      number: baseFormatter(base)
+    });
+  });
+}

package/lib/function/string/bin.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createBin = void 0;
+
+var _baseUtils = require("./baseUtils");
+
+/**
+ * Format a number as binary.
+ *
+ * Syntax:
+ *
+ *    math.bin(value)
+ *
+ * Examples:
+ *
+ *    //the following outputs "0b10"
+ *    math.bin(2)
+ *
+ * See also:
+ *
+ *    oct
+ *    hex
+ *
+ * @param {number} value    Value to be stringified
+ * @return {string}         The formatted value
+ */
+var createBin = (0, _baseUtils.createBaseFormatterFactory)('bin', 2);
+exports.createBin = createBin;

package/lib/function/string/hex.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createHex = void 0;
+
+var _baseUtils = require("./baseUtils");
+
+/**
+ * Format a number as hexadecimal.
+ *
+ * Syntax:
+ *
+ *    math.hex(value)
+ *
+ * Examples:
+ *
+ *    //the following outputs "0xF0"
+ *    math.hex(240)
+ *
+ * See also:
+ *
+ *    oct
+ *    bin
+ *
+ * @param {number} value    Value to be stringified
+ * @return {string}         The formatted value
+ */
+var createHex = (0, _baseUtils.createBaseFormatterFactory)('hex', 16);
+exports.createHex = createHex;