mathjs 14.0.1 → 14.2.0

package/lib/cjs/function/arithmetic/log10.js

@@ -4,11 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createLog10 = void 0;
-var _factory = require("../../utils/factory.js");
-var _collection = require("../../utils/collection.js");
 var _index = require("../../plain/number/index.js");
+var _bigint = require("../../utils/bigint.js");
+var _collection = require("../../utils/collection.js");
+var _factory = require("../../utils/factory.js");
 const name = 'log10';
 const dependencies = ['typed', 'config', 'Complex'];
+const log16 = (0, _index.log10Number)(16);
 const createLog10 = exports.createLog10 = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
     typed,
@@ -40,24 +42,30 @@ const createLog10 = exports.createLog10 = /* #__PURE__ */(0, _factory.factory)(n
    * @return {number | BigNumber | Complex | Array | Matrix}
    *            Returns the 10-base logarithm of `x`
    */
+
+  function complexLog(c) {
+    return c.log().div(Math.LN10);
+  }
+  function complexLogNumber(x) {
+    return complexLog(new Complex(x, 0));
+  }
   return typed(name, {
     number: function (x) {
       if (x >= 0 || config.predictable) {
         return (0, _index.log10Number)(x);
       } else {
         // negative value -> complex value computation
-        return new Complex(x, 0).log().div(Math.LN10);
+        return complexLogNumber(x);
       }
     },
-    Complex: function (x) {
-      return new Complex(x).log().div(Math.LN10);
-    },
+    bigint: (0, _bigint.promoteLogarithm)(log16, _index.log10Number, config, complexLogNumber),
+    Complex: complexLog,
     BigNumber: function (x) {
       if (!x.isNegative() || config.predictable) {
         return x.log();
       } else {
         // downgrade to number, return Complex valued result
-        return new Complex(x.toNumber(), 0).log().div(Math.LN10);
+        return complexLogNumber(x.toNumber());
       }
     },
     'Array | Matrix': typed.referToSelf(self => x => (0, _collection.deepMap)(x, self))

package/lib/cjs/function/arithmetic/log2.js

@@ -4,9 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createLog2 = void 0;
-var _factory = require("../../utils/factory.js");
-var _collection = require("../../utils/collection.js");
 var _index = require("../../plain/number/index.js");
+var _bigint = require("../../utils/bigint.js");
+var _collection = require("../../utils/collection.js");
+var _factory = require("../../utils/factory.js");
 const name = 'log2';
 const dependencies = ['typed', 'config', 'Complex'];
 const createLog2 = exports.createLog2 = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
@@ -40,22 +41,26 @@ const createLog2 = exports.createLog2 = /* #__PURE__ */(0, _factory.factory)(nam
    * @return {number | BigNumber | Complex | Array | Matrix}
    *            Returns the 2-base logarithm of `x`
    */
+  function complexLog2Number(x) {
+    return _log2Complex(new Complex(x, 0));
+  }
   return typed(name, {
     number: function (x) {
       if (x >= 0 || config.predictable) {
         return (0, _index.log2Number)(x);
       } else {
         // negative value -> complex value computation
-        return _log2Complex(new Complex(x, 0));
+        return complexLog2Number(x);
       }
     },
+    bigint: (0, _bigint.promoteLogarithm)(4, _index.log2Number, config, complexLog2Number),
     Complex: _log2Complex,
     BigNumber: function (x) {
       if (!x.isNegative() || config.predictable) {
         return x.log(2);
       } else {
         // downgrade to number, return Complex valued result
-        return _log2Complex(new Complex(x.toNumber(), 0));
+        return complexLog2Number(x.toNumber());
       }
     },
     'Array | Matrix': typed.referToSelf(self => x => (0, _collection.deepMap)(x, self))

package/lib/cjs/function/arithmetic/round.js

@@ -143,6 +143,10 @@ const createRound = exports.createRound = /* #__PURE__ */(0, _factory.factory)(n
       const xSelected = (0, _nearlyEqual.nearlyEqual)(x, xEpsilon, config.relTol, config.absTol) ? xEpsilon : x;
       return xSelected.toDecimalPlaces(n.toNumber());
     },
+    // bigints can't be rounded
+    bigint: b => b,
+    'bigint, number': (b, _dummy) => b,
+    'bigint, BigNumber': (b, _dummy) => b,
     Fraction: function (x) {
       return x.round();
     },

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

@@ -26,7 +26,7 @@ const createCtranspose = exports.createCtranspose = /* #__PURE__ */(0, _factory.
    * Examples:
    *
    *     const A = [[1, 2, 3], [4, 5, math.complex(6,7)]]
-   *     math.ctranspose(A)               // returns [[1, 4], [2, 5], [3, {re:6,im:7}]]
+   *     math.ctranspose(A)      // returns [[1, 4], [2, 5], [3, {re:6,im:-7}]]
    *
    * See also:
    *

package/lib/cjs/function/matrix/{apply.js → mapSlices.js}

@@ -3,14 +3,14 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.createApply = void 0;
+exports.createMapSlices = void 0;
 var _factory = require("../../utils/factory.js");
 var _array = require("../../utils/array.js");
 var _is = require("../../utils/is.js");
 var _IndexError = require("../../error/IndexError.js");
-const name = 'apply';
+const name = 'mapSlices';
 const dependencies = ['typed', 'isInteger'];
-const createApply = exports.createApply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+const createMapSlices = exports.createMapSlices = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
     typed,
     isInteger
@@ -22,7 +22,7 @@ const createApply = exports.createApply = /* #__PURE__ */(0, _factory.factory)(n
    *
    * Syntax:
    *
-   *     math.apply(A, dim, callback)
+   *     math.mapSlices(A, dim, callback)
    *
    * Where:
    *
@@ -33,19 +33,24 @@ const createApply = exports.createApply = /* #__PURE__ */(0, _factory.factory)(n
    *    const A = [[1, 2], [3, 4]]
    *    const sum = math.sum
    *
-   *    math.apply(A, 0, sum)             // returns [4, 6]
-   *    math.apply(A, 1, sum)             // returns [3, 7]
+   *    math.mapSlices(A, 0, sum)             // returns [4, 6]
+   *    math.mapSlices(A, 1, sum)             // returns [3, 7]
    *
    * See also:
    *
    *    map, filter, forEach
    *
+   * Note:
+   *
+   *    `mapSlices()` is also currently available via its deprecated
+   *    synonym `apply()`.
+   *
    * @param {Array | Matrix} array   The input Matrix
    * @param {number} dim             The dimension along which the callback is applied
    * @param {Function} callback      The callback function that is applied. This Function
    *                                 should take an array or 1-d matrix as an input and
    *                                 return a number.
-   * @return {Array | Matrix} res    The residual matrix with the function applied over some dimension.
+   * @return {Array | Matrix} res    The residual matrix with the function mapped on the slices over some dimension.
    */
   return typed(name, {
     'Array | Matrix, number | BigNumber, function': function (mat, dim, callback) {
@@ -57,12 +62,14 @@ const createApply = exports.createApply = /* #__PURE__ */(0, _factory.factory)(n
         throw new _IndexError.IndexError(dim, size.length);
       }
       if ((0, _is.isMatrix)(mat)) {
-        return mat.create(_apply(mat.valueOf(), dim, callback), mat.datatype());
+        return mat.create(_mapSlices(mat.valueOf(), dim, callback), mat.datatype());
       } else {
-        return _apply(mat, dim, callback);
+        return _mapSlices(mat, dim, callback);
       }
     }
   });
+}, {
+  formerly: 'apply'
 });
 
 /**
@@ -73,7 +80,7 @@ const createApply = exports.createApply = /* #__PURE__ */(0, _factory.factory)(n
  * @returns {Array} ret
  * @private
  */
-function _apply(mat, dim, callback) {
+function _mapSlices(mat, dim, callback) {
   let i, ret, tran;
   if (dim <= 0) {
     if (!Array.isArray(mat[0])) {
@@ -82,14 +89,14 @@ function _apply(mat, dim, callback) {
       tran = _switch(mat);
       ret = [];
       for (i = 0; i < tran.length; i++) {
-        ret[i] = _apply(tran[i], dim - 1, callback);
+        ret[i] = _mapSlices(tran[i], dim - 1, callback);
       }
       return ret;
     }
   } else {
     ret = [];
     for (i = 0; i < mat.length; i++) {
-      ret[i] = _apply(mat[i], dim - 1, callback);
+      ret[i] = _mapSlices(mat[i], dim - 1, callback);
     }
     return ret;
   }

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

@@ -15,8 +15,10 @@ const createMatrixFromFunction = exports.createMatrixFromFunction = /* #__PURE__
   } = _ref;
   /**
    * Create a matrix by evaluating a generating function at each index.
-   * The simplest overload returns a multi-dimensional array as long as `size` is an array.
-   * Passing `size` as a Matrix or specifying a `format` will result in returning a Matrix.
+   * The simplest overload returns a multi-dimensional array as long as `size`
+   * is an array.
+   * Passing `size` as a Matrix or specifying a `format` will result in
+   * returning a Matrix.
    *
    * Syntax:
    *
@@ -26,6 +28,37 @@ const createMatrixFromFunction = exports.createMatrixFromFunction = /* #__PURE__
    *    math.matrixFromFunction(size, format, fn)
    *    math.matrixFromFunction(size, format, datatype, fn)
    *
+   * Where:
+   *
+   *    - `size: (number[] | Matrix)`
+   *      A vector giving the extent of the array to be created in each
+   *      dimension. If size has one entry, a vector is created; if it
+   *      has two, a rectangular array/Matrix is created; if three, a
+   *      three-dimensional array/Matrix is created; and so on.
+   *    - `fn: (index: number[]) => MathType`
+   *      The callback function that will generate the entries of the
+   *      matrix. It is called in turn with the index of each entry of
+   *      the matrix. The index is always an ordinary array of numbers
+   *      with the same length as _size_. So for vectors, you will get
+   *      indices like `[0]` or `[1]`, whereas for matrices, you will
+   *      get indices like `[2, 0]` or `[1,3]`. The return value may
+   *      be any type that can go in an array or Matrix entry, although
+   *      if you supply the _datatype_ argument, you must yourself ensure
+   *      the type of the return value matches. Note that currently,
+   *      your callback _fn_ will receive 0-based indices for the matrix
+   *      entries, regardless of whether matrixFromFunction is invoked
+   *      directly from JavaScript or via the mathjs expression language.
+   *    - `format: 'dense'|'sparse'`
+   *      Specifies the storage format for the resulting Matrix. Note that
+   *      if this argument is given, the return value will always be a
+   *      Matrix (rather than possibly an Array).
+   *    - `datatype: string`
+   *      Specifies the data type of entries of the new matrix. If given,
+   *      it should be the name of a data type that mathjs supports, as
+   *      returned by the math.typeOf function. It is up to the caller
+   *      to make certain that all values returned by _fn_ are consistent
+   *      with this datatype if specified.
+   *
    * Examples:
    *
    *    math.matrixFromFunction([3,3], i => i[0] - i[1]) // an antisymmetric matrix
@@ -34,7 +67,7 @@ const createMatrixFromFunction = exports.createMatrixFromFunction = /* #__PURE__
    *
    * See also:
    *
-   *    matrix, zeros
+   *    matrix, typeOf, zeros
    *
    * @param {Array | Matrix} size   The size of the matrix to be created
    * @param {function} fn           Callback function invoked for every entry in the matrix

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

@@ -41,36 +41,48 @@ const createRange = exports.createRange = /* #__PURE__ */(0, _factory.factory)(n
    *
    * - `str: string`
    *   A string 'start:end' or 'start:step:end'
-   * - `start: {number | BigNumber | Unit}`
+   * - `start: {number | bigint | BigNumber | Fraction | Unit}`
    *   Start of the range
-   * - `end: number | BigNumber | Unit`
+   * - `end: number | bigint | BigNumber | Fraction | Unit`
    *   End of the range, excluded by default, included when parameter includeEnd=true
-   * - `step: number | BigNumber | Unit`
+   * - `step: number | bigint | BigNumber | Fraction | Unit`
    *   Step size. Default value is 1.
    * - `includeEnd: boolean`
    *   Option to specify whether to include the end or not. False by default.
    *
+   * Note that the return type of the range is taken from the type of
+   * the start/end. If only one these is a built-in `number` type, it will
+   * be promoted to the type of the other endpoint. However, in the case of
+   * Unit values, both endpoints must have compatible units, and the return
+   * value will have compatible units as well.
+   *
    * 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]
+   *     math.range(2, math.fraction(8,3), math.fraction(1,3)) // [fraction(2), fraction(7,3)]
    *     math.range(math.unit(2, 'm'), math.unit(-3, 'm'), math.unit(-1, 'm')) // [2 m, 1 m, 0 m , -1 m, -2 m]
    *
    * See also:
    *
    *     ones, zeros, size, subset
    *
-   * @param {*} args   Parameters describing the ranges `start`, `end`, and optional `step`.
+   * @param {*} args   Parameters describing the range's `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: function (oops) {
+      throw new TypeError(`Too few arguments to function range(): ${oops}`);
+    },
+    boolean: function (oops) {
+      throw new TypeError(`Unexpected type of argument 1 to function range(): ${oops}, number|bigint|BigNumber|Fraction`);
+    },
     'number, number': function (start, end) {
       return _out(_range(start, end, 1, false));
     },
@@ -83,6 +95,31 @@ const createRange = exports.createRange = /* #__PURE__ */(0, _factory.factory)(n
     'number, number, number, boolean': function (start, end, step, includeEnd) {
       return _out(_range(start, end, step, includeEnd));
     },
+    // Handle bigints; if either limit is bigint, range should be too
+    'bigint, bigint|number': function (start, end) {
+      return _out(_range(start, end, 1n, false));
+    },
+    'number, bigint': function (start, end) {
+      return _out(_range(BigInt(start), end, 1n, false));
+    },
+    'bigint, bigint|number, bigint|number': function (start, end, step) {
+      return _out(_range(start, end, BigInt(step), false));
+    },
+    'number, bigint, bigint|number': function (start, end, step) {
+      return _out(_range(BigInt(start), end, BigInt(step), false));
+    },
+    'bigint, bigint|number, boolean': function (start, end, includeEnd) {
+      return _out(_range(start, end, 1n, includeEnd));
+    },
+    'number, bigint, boolean': function (start, end, includeEnd) {
+      return _out(_range(BigInt(start), end, 1n, includeEnd));
+    },
+    'bigint, bigint|number, bigint|number, boolean': function (start, end, step, includeEnd) {
+      return _out(_range(start, end, BigInt(step), includeEnd));
+    },
+    'number, bigint, bigint|number, boolean': function (start, end, step, includeEnd) {
+      return _out(_range(BigInt(start), end, BigInt(step), includeEnd));
+    },
     'BigNumber, BigNumber': function (start, end) {
       const BigNumber = start.constructor;
       return _out(_range(start, end, new BigNumber(1), false));
@@ -97,6 +134,18 @@ const createRange = exports.createRange = /* #__PURE__ */(0, _factory.factory)(n
     'BigNumber, BigNumber, BigNumber, boolean': function (start, end, step, includeEnd) {
       return _out(_range(start, end, step, includeEnd));
     },
+    'Fraction, Fraction': function (start, end) {
+      return _out(_range(start, end, 1, false));
+    },
+    'Fraction, Fraction, Fraction': function (start, end, step) {
+      return _out(_range(start, end, step, false));
+    },
+    'Fraction, Fraction, boolean': function (start, end, includeEnd) {
+      return _out(_range(start, end, 1, includeEnd));
+    },
+    'Fraction, Fraction, Fraction, boolean': function (start, end, step, includeEnd) {
+      return _out(_range(start, end, step, includeEnd));
+    },
     'Unit, Unit, Unit': function (start, end, step) {
       return _out(_range(start, end, step, false));
     },

package/lib/cjs/function/probability/randomInt.js

@@ -9,11 +9,13 @@ var _randomMatrix = require("./util/randomMatrix.js");
 var _seededRNG = require("./util/seededRNG.js");
 var _is = require("../../utils/is.js");
 const name = 'randomInt';
-const dependencies = ['typed', 'config', '?on'];
+const dependencies = ['typed', 'config', 'log2', '?on'];
+const simpleCutoff = 2n ** 30n;
 const createRandomInt = exports.createRandomInt = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
     typed,
     config,
+    log2,
     on
   } = _ref;
   // seeded pseudo random number generator
@@ -32,7 +34,7 @@ const createRandomInt = exports.createRandomInt = /* #__PURE__ */(0, _factory.fa
    *
    * Syntax:
    *
-   *     math.randomInt()                // generate a random integer between 0 and 1
+   *     math.randomInt()                // generate either 0 or 1, randomly
    *     math.randomInt(max)             // generate a random integer between 0 and max
    *     math.randomInt(min, max)        // generate a random integer between min and max
    *     math.randomInt(size)            // generate a matrix with random integer between 0 and 1
@@ -56,9 +58,11 @@ const createRandomInt = exports.createRandomInt = /* #__PURE__ */(0, _factory.fa
    * @return {number | Array | Matrix} A random integer value
    */
   return typed(name, {
-    '': () => _randomInt(0, 1),
+    '': () => _randomInt(0, 2),
     number: max => _randomInt(0, max),
     'number, number': (min, max) => _randomInt(min, max),
+    bigint: max => _randomBigint(0n, max),
+    'bigint, bigint': _randomBigint,
     'Array | Matrix': size => _randomIntMatrix(size, 0, 1),
     'Array | Matrix, number': (size, max) => _randomIntMatrix(size, 0, max),
     'Array | Matrix, number, number': (size, min, max) => _randomIntMatrix(size, min, max)
@@ -70,4 +74,23 @@ const createRandomInt = exports.createRandomInt = /* #__PURE__ */(0, _factory.fa
   function _randomInt(min, max) {
     return Math.floor(min + rng() * (max - min));
   }
+  function _randomBigint(min, max) {
+    const width = max - min; // number of choices
+    if (width <= simpleCutoff) {
+      // do it with number type
+      return min + BigInt(_randomInt(0, Number(width)));
+    }
+    // Too big to choose accurately that way. Instead, choose the correct
+    // number of random bits to cover the width, and repeat until the
+    // resulting number falls within the width
+    const bits = log2(width);
+    let picked = width;
+    while (picked >= width) {
+      picked = 0n;
+      for (let i = 0; i < bits; ++i) {
+        picked = 2n * picked + (rng() < 0.5 ? 0n : 1n);
+      }
+    }
+    return min + picked;
+  }
 });

package/lib/cjs/function/relational/larger.js

@@ -13,11 +13,12 @@ var _matAlgo12xSfs = require("../../type/matrix/utils/matAlgo12xSfs.js");
 var _matrixAlgorithmSuite = require("../../type/matrix/utils/matrixAlgorithmSuite.js");
 var _compareUnits = require("./compareUnits.js");
 const name = 'larger';
-const dependencies = ['typed', 'config', 'matrix', 'DenseMatrix', 'concat', 'SparseMatrix'];
+const dependencies = ['typed', 'config', 'bignumber', 'matrix', 'DenseMatrix', 'concat', 'SparseMatrix'];
 const createLarger = exports.createLarger = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
     typed,
     config,
+    bignumber,
     matrix,
     DenseMatrix,
     concat,
@@ -74,16 +75,23 @@ const createLarger = exports.createLarger = /* #__PURE__ */(0, _factory.factory)
    * @param  {number | BigNumber | bigint | Fraction | boolean | Unit | string | Array | Matrix} y Second value to compare
    * @return {boolean | Array | Matrix} Returns true when the x is larger than y, else returns false
    */
+  function bignumLarger(x, y) {
+    return x.gt(y) && !(0, _nearlyEqual.nearlyEqual)(x, y, config.relTol, config.absTol);
+  }
   return typed(name, createLargerNumber({
     typed,
     config
   }), {
     'boolean, boolean': (x, y) => x > y,
-    'BigNumber, BigNumber': function (x, y) {
-      return x.gt(y) && !(0, _nearlyEqual.nearlyEqual)(x, y, config.relTol, config.absTol);
-    },
+    'BigNumber, BigNumber': bignumLarger,
     'bigint, bigint': (x, y) => x > y,
     'Fraction, Fraction': (x, y) => x.compare(y) === 1,
+    'Fraction, BigNumber': function (x, y) {
+      return bignumLarger(bignumber(x), y);
+    },
+    'BigNumber, Fraction': function (x, y) {
+      return bignumLarger(x, bignumber(y));
+    },
     'Complex, Complex': function () {
       throw new TypeError('No ordering relation is defined for complex numbers');
     }

package/lib/cjs/function/relational/smaller.js

@@ -13,11 +13,12 @@ var _matAlgo12xSfs = require("../../type/matrix/utils/matAlgo12xSfs.js");
 var _matrixAlgorithmSuite = require("../../type/matrix/utils/matrixAlgorithmSuite.js");
 var _compareUnits = require("./compareUnits.js");
 const name = 'smaller';
-const dependencies = ['typed', 'config', 'matrix', 'DenseMatrix', 'concat', 'SparseMatrix'];
+const dependencies = ['typed', 'config', 'bignumber', 'matrix', 'DenseMatrix', 'concat', 'SparseMatrix'];
 const createSmaller = exports.createSmaller = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
     typed,
     config,
+    bignumber,
     matrix,
     DenseMatrix,
     concat,
@@ -74,16 +75,23 @@ const createSmaller = exports.createSmaller = /* #__PURE__ */(0, _factory.factor
    * @param  {number | BigNumber | bigint | Fraction | boolean | Unit | string | Array | Matrix} y Second value to compare
    * @return {boolean | Array | Matrix} Returns true when the x is smaller than y, else returns false
    */
+  function bignumSmaller(x, y) {
+    return x.lt(y) && !(0, _nearlyEqual.nearlyEqual)(x, y, config.relTol, config.absTol);
+  }
   return typed(name, createSmallerNumber({
     typed,
     config
   }), {
     'boolean, boolean': (x, y) => x < y,
-    'BigNumber, BigNumber': function (x, y) {
-      return x.lt(y) && !(0, _nearlyEqual.nearlyEqual)(x, y, config.relTol, config.absTol);
-    },
+    'BigNumber, BigNumber': bignumSmaller,
     'bigint, bigint': (x, y) => x < y,
     'Fraction, Fraction': (x, y) => x.compare(y) === -1,
+    'Fraction, BigNumber': function (x, y) {
+      return bignumSmaller(bignumber(x), y);
+    },
+    'BigNumber, Fraction': function (x, y) {
+      return bignumSmaller(x, bignumber(y));
+    },
     'Complex, Complex': function (x, y) {
       throw new TypeError('No ordering relation is defined for complex numbers');
     }

package/lib/cjs/function/statistics/max.js

@@ -89,7 +89,7 @@ const createMax = exports.createMax = /* #__PURE__ */(0, _factory.factory)(name,
     let res;
     (0, _collection.deepForEach)(array, function (value) {
       try {
-        if (isNaN(value) && typeof value === 'number') {
+        if (typeof value === 'number' && isNaN(value)) {
           res = NaN;
         } else if (res === undefined || larger(value, res)) {
           res = value;

package/lib/cjs/function/statistics/min.js

@@ -89,7 +89,7 @@ const createMin = exports.createMin = /* #__PURE__ */(0, _factory.factory)(name,
     let min;
     (0, _collection.deepForEach)(array, function (value) {
       try {
-        if (isNaN(value) && typeof value === 'number') {
+        if (typeof value === 'number' && isNaN(value)) {
           min = NaN;
         } else if (min === undefined || smaller(value, min)) {
           min = value;

package/lib/cjs/function/statistics/quantileSeq.js

@@ -7,9 +7,8 @@ exports.createQuantileSeq = void 0;
 var _is = require("../../utils/is.js");
 var _array = require("../../utils/array.js");
 var _factory = require("../../utils/factory.js");
-var _apply = require("../matrix/apply.js");
 const name = 'quantileSeq';
-const dependencies = ['typed', '?bignumber', 'add', 'subtract', 'divide', 'multiply', 'partitionSelect', 'compare', 'isInteger', 'smaller', 'smallerEq', 'larger'];
+const dependencies = ['typed', '?bignumber', 'add', 'subtract', 'divide', 'multiply', 'partitionSelect', 'compare', 'isInteger', 'smaller', 'smallerEq', 'larger', 'mapSlices'];
 const createQuantileSeq = exports.createQuantileSeq = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
     typed,
@@ -23,13 +22,9 @@ const createQuantileSeq = exports.createQuantileSeq = /* #__PURE__ */(0, _factor
     isInteger,
     smaller,
     smallerEq,
-    larger
+    larger,
+    mapSlices
   } = _ref;
-  const apply = (0, _apply.createApply)({
-    typed,
-    isInteger
-  });
-
   /**
    * Compute the prob order quantile of a matrix or a list with values.
    * The sequence is sorted and the middle value is returned.
@@ -75,7 +70,7 @@ const createQuantileSeq = exports.createQuantileSeq = /* #__PURE__ */(0, _factor
     'Array | Matrix, Array | Matrix, boolean, number': (data, prob, sorted, dim) => _quantileSeqDim(data, prob, sorted, dim, _quantileSeqProbCollection)
   });
   function _quantileSeqDim(data, prob, sorted, dim, fn) {
-    return apply(data, dim, x => fn(x, prob, sorted));
+    return mapSlices(data, dim, x => fn(x, prob, sorted));
   }
   function _quantileSeqProbNumber(data, probOrN, sorted) {
     let probArr;

package/lib/cjs/function/statistics/variance.js

@@ -10,7 +10,7 @@ var _factory = require("../../utils/factory.js");
 var _improveErrorMessage = require("./utils/improveErrorMessage.js");
 const DEFAULT_NORMALIZATION = 'unbiased';
 const name = 'variance';
-const dependencies = ['typed', 'add', 'subtract', 'multiply', 'divide', 'apply', 'isNaN'];
+const dependencies = ['typed', 'add', 'subtract', 'multiply', 'divide', 'mapSlices', 'isNaN'];
 const createVariance = exports.createVariance = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
     typed,
@@ -18,7 +18,7 @@ const createVariance = exports.createVariance = /* #__PURE__ */(0, _factory.fact
     subtract,
     multiply,
     divide,
-    apply,
+    mapSlices,
     isNaN
   } = _ref;
   /**
@@ -151,7 +151,7 @@ const createVariance = exports.createVariance = /* #__PURE__ */(0, _factory.fact
       if (array.length === 0) {
         throw new SyntaxError('Function variance requires one or more parameters (0 provided)');
       }
-      return apply(array, dim, x => _var(x, normalization));
+      return mapSlices(array, dim, x => _var(x, normalization));
     } catch (err) {
       throw (0, _improveErrorMessage.improveErrorMessage)(err, 'variance');
     }

package/lib/cjs/function/string/hex.js

@@ -17,7 +17,7 @@ const dependencies = ['typed', 'format'];
  *
  * Examples:
  *
- *    math.hex(240) // returns "0xF0"
+ *    math.hex(240) // returns "0xf0"
  *
  * See also:
  *

package/lib/cjs/function/string/print.js

@@ -31,12 +31,12 @@ const createPrint = exports.createPrint = /* #__PURE__ */(0, _factory.factory)(n
    *     // the following outputs: 'The value of pi is 3.141592654'
    *     math.print('The value of pi is $pi', {pi: math.pi}, 10)
    *
-   *     // the following outputs: 'hello Mary! The date is 2013-03-23'
+   *     // the following outputs: 'Hello Mary! The date is 2013-03-23'
    *     math.print('Hello $user.name! The date is $date', {
    *       user: {
    *         name: 'Mary',
    *       },
-   *       date: new Date(2013, 2, 23).toISOString().substring(0, 10)
+   *       date: '2013-03-23'
    *     })
    *
    *     // the following outputs: 'My favorite fruits are apples and bananas !'

package/lib/cjs/function/trigonometry/acoth.js

@@ -28,7 +28,7 @@ const createAcoth = exports.createAcoth = /* #__PURE__ */(0, _factory.factory)(n
    *
    * Examples:
    *
-   *    math.acoth(0.5)       // returns 0.8047189562170503
+   *    math.acoth(0.5)     // returns 0.5493061443340548 - 1.5707963267948966i
    *
    * See also:
    *

package/lib/cjs/function/trigonometry/acsc.js

@@ -29,7 +29,7 @@ const createAcsc = exports.createAcsc = /* #__PURE__ */(0, _factory.factory)(nam
    *
    *    math.acsc(2)             // returns 0.5235987755982989
    *    math.acsc(0.5)           // returns Complex 1.5707963267948966 -1.3169578969248166i
-   *    math.acsc(math.csc(1.5)) // returns number ~1.5
+   *    math.acsc(math.csc(1.5)) // returns number 1.5
    *
    * See also:
    *