mathjs 11.10.1 → 11.11.1

package/lib/cjs/factoriesAny.js

@@ -375,6 +375,12 @@ Object.defineProperty(exports, "createConstantNode", {
     return _ConstantNode.createConstantNode;
   }
 });
+Object.defineProperty(exports, "createCorr", {
+  enumerable: true,
+  get: function get() {
+    return _corr.createCorr;
+  }
+});
 Object.defineProperty(exports, "createCos", {
   enumerable: true,
   get: function get() {
@@ -1461,6 +1467,12 @@ Object.defineProperty(exports, "createPrint", {
     return _print.createPrint;
   }
 });
+Object.defineProperty(exports, "createPrintTransform", {
+  enumerable: true,
+  get: function get() {
+    return _printTransform.createPrintTransform;
+  }
+});
 Object.defineProperty(exports, "createProd", {
   enumerable: true,
   get: function get() {
@@ -2366,6 +2378,7 @@ var _mad = require("./function/statistics/mad.js");
 var _variance = require("./function/statistics/variance.js");
 var _quantileSeq = require("./function/statistics/quantileSeq.js");
 var _std = require("./function/statistics/std.js");
+var _corr = require("./function/statistics/corr.js");
 var _combinations = require("./function/probability/combinations.js");
 var _combinationsWithRep = require("./function/probability/combinationsWithRep.js");
 var _gamma = require("./function/probability/gamma.js");
@@ -2413,4 +2426,5 @@ var _stdTransform = require("./expression/transform/std.transform.js");
 var _sumTransform = require("./expression/transform/sum.transform.js");
 var _quantileSeqTransform = require("./expression/transform/quantileSeq.transform.js");
 var _cumsumTransform = require("./expression/transform/cumsum.transform.js");
-var _varianceTransform = require("./expression/transform/variance.transform.js");
+var _varianceTransform = require("./expression/transform/variance.transform.js");
+var _printTransform = require("./expression/transform/print.transform.js");

package/lib/cjs/factoriesNumber.js

@@ -136,6 +136,12 @@ Object.defineProperty(exports, "createConstantNode", {
     return _ConstantNode.createConstantNode;
   }
 });
+Object.defineProperty(exports, "createCorr", {
+  enumerable: true,
+  get: function get() {
+    return _corr.createCorr;
+  }
+});
 exports.createCube = exports.createCsch = exports.createCsc = exports.createCoth = exports.createCot = exports.createCosh = exports.createCos = void 0;
 Object.defineProperty(exports, "createCumSum", {
   enumerable: true,
@@ -354,8 +360,8 @@ Object.defineProperty(exports, "createLargerEq", {
     return _largerEq.createLargerEqNumber;
   }
 });
-exports.createLeftShift = exports.createLcm = void 0;
-exports.createLog2 = exports.createLog1p = exports.createLog10 = exports.createLog = exports.createLgamma = void 0;
+exports.createLcm = void 0;
+exports.createLog2 = exports.createLog1p = exports.createLog10 = exports.createLog = exports.createLgamma = exports.createLeftShift = void 0;
 Object.defineProperty(exports, "createMad", {
   enumerable: true,
   get: function get() {
@@ -777,8 +783,7 @@ Object.defineProperty(exports, "createVersion", {
     return _constants.createVersion;
   }
 });
-exports.createXgcd = void 0;
-exports.createXor = void 0;
+exports.createXor = exports.createXgcd = void 0;
 Object.defineProperty(exports, "createZeta", {
   enumerable: true,
   get: function get() {
@@ -874,6 +879,7 @@ var _mad = require("./function/statistics/mad.js");
 var _variance = require("./function/statistics/variance.js");
 var _quantileSeq = require("./function/statistics/quantileSeq.js");
 var _std = require("./function/statistics/std.js");
+var _corr = require("./function/statistics/corr.js");
 var _format = require("./function/string/format.js");
 var _print = require("./function/string/print.js");
 var _applyTransform = require("./expression/transform/apply.transform.js");

package/lib/cjs/function/algebra/simplify/util.js

@@ -9,8 +9,8 @@ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/de
 var _is = require("../../../utils/is.js");
 var _factory = require("../../../utils/factory.js");
 var _object = require("../../../utils/object.js");
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 var name = 'simplifyUtil';
 var dependencies = ['FunctionNode', 'OperatorNode', 'SymbolNode'];
 var createUtil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {

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

@@ -7,15 +7,16 @@ Object.defineProperty(exports, "__esModule", {
 exports.createGcd = void 0;
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _number = require("../../utils/number.js");
 var _factory = require("../../utils/factory.js");
+var _mod = require("./mod.js");
 var _matAlgo01xDSid = require("../../type/matrix/utils/matAlgo01xDSid.js");
 var _matAlgo04xSidSid = require("../../type/matrix/utils/matAlgo04xSidSid.js");
 var _matAlgo10xSids = require("../../type/matrix/utils/matAlgo10xSids.js");
 var _matrixAlgorithmSuite = require("../../type/matrix/utils/matrixAlgorithmSuite.js");
-var _index = require("../../plain/number/index.js");
 var _ArgumentsError = require("../../error/ArgumentsError.js");
 var name = 'gcd';
-var dependencies = ['typed', 'matrix', 'equalScalar', 'BigNumber', 'DenseMatrix', 'concat'];
+var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar', 'zeros', 'BigNumber', 'DenseMatrix', 'concat'];
 var gcdTypes = 'number | BigNumber | Fraction | Matrix | Array';
 var gcdManyTypesSignature = "".concat(gcdTypes, ", ").concat(gcdTypes, ", ...").concat(gcdTypes);
 function is1d(array) {
@@ -27,10 +28,23 @@ var createGcd = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
   var _typed;
   var typed = _ref.typed,
     matrix = _ref.matrix,
+    config = _ref.config,
+    round = _ref.round,
     equalScalar = _ref.equalScalar,
+    zeros = _ref.zeros,
     BigNumber = _ref.BigNumber,
     DenseMatrix = _ref.DenseMatrix,
     concat = _ref.concat;
+  var mod = (0, _mod.createMod)({
+    typed: typed,
+    config: config,
+    round: round,
+    matrix: matrix,
+    equalScalar: equalScalar,
+    zeros: zeros,
+    DenseMatrix: DenseMatrix,
+    concat: concat
+  });
   var matAlgo01xDSid = (0, _matAlgo01xDSid.createMatAlgo01xDSid)({
     typed: typed
   });
@@ -74,7 +88,7 @@ var createGcd = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
    * @return {number | BigNumber | Fraction | Array | Matrix}                           The greatest common divisor
    */
   return typed(name, {
-    'number, number': _index.gcdNumber,
+    'number, number': _gcdNumber,
     'BigNumber, BigNumber': _gcdBigNumber,
     'Fraction, Fraction': function FractionFraction(x, y) {
       return x.gcd(y);
@@ -107,6 +121,28 @@ var createGcd = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
     };
   })), _typed));
 
+  /**
+  * Calculate gcd for numbers
+  * @param {number} a
+  * @param {number} b
+  * @returns {number} Returns the greatest common denominator of a and b
+  * @private
+  */
+  function _gcdNumber(a, b) {
+    if (!(0, _number.isInteger)(a) || !(0, _number.isInteger)(b)) {
+      throw new Error('Parameters in function gcd must be integer numbers');
+    }
+
+    // https://en.wikipedia.org/wiki/Euclidean_algorithm
+    var r;
+    while (b !== 0) {
+      r = mod(a, b);
+      a = b;
+      b = r;
+    }
+    return a < 0 ? -a : a;
+  }
+
   /**
    * Calculate gcd for BigNumbers
    * @param {BigNumber} a
@@ -122,7 +158,7 @@ var createGcd = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
     // https://en.wikipedia.org/wiki/Euclidean_algorithm
     var zero = new BigNumber(0);
     while (!b.isZero()) {
-      var r = a.mod(b);
+      var r = mod(a, b);
       a = b;
       b = r;
     }

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

@@ -5,21 +5,33 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createMod = void 0;
 var _factory = require("../../utils/factory.js");
+var _floor = require("./floor.js");
 var _matAlgo02xDS = require("../../type/matrix/utils/matAlgo02xDS0.js");
 var _matAlgo03xDSf = require("../../type/matrix/utils/matAlgo03xDSf.js");
 var _matAlgo05xSfSf = require("../../type/matrix/utils/matAlgo05xSfSf.js");
 var _matAlgo11xS0s = require("../../type/matrix/utils/matAlgo11xS0s.js");
 var _matAlgo12xSfs = require("../../type/matrix/utils/matAlgo12xSfs.js");
-var _index = require("../../plain/number/index.js");
 var _matrixAlgorithmSuite = require("../../type/matrix/utils/matrixAlgorithmSuite.js");
 var name = 'mod';
-var dependencies = ['typed', 'matrix', 'equalScalar', 'DenseMatrix', 'concat'];
+var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar', 'zeros', 'DenseMatrix', 'concat'];
 var createMod = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
+    config = _ref.config,
+    round = _ref.round,
     matrix = _ref.matrix,
     equalScalar = _ref.equalScalar,
+    zeros = _ref.zeros,
     DenseMatrix = _ref.DenseMatrix,
     concat = _ref.concat;
+  var floor = (0, _floor.createFloor)({
+    typed: typed,
+    config: config,
+    round: round,
+    matrix: matrix,
+    equalScalar: equalScalar,
+    zeros: zeros,
+    DenseMatrix: DenseMatrix
+  });
   var matAlgo02xDS0 = (0, _matAlgo02xDS.createMatAlgo02xDS0)({
     typed: typed,
     equalScalar: equalScalar
@@ -81,7 +93,7 @@ var createMod = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
    * @return {number | BigNumber | Fraction | Array | Matrix} Returns the remainder of `x` divided by `y`.
    */
   return typed(name, {
-    'number, number': _index.modNumber,
+    'number, number': _modNumber,
     'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
       if (y.isNeg()) {
         throw new Error('Cannot calculate mod for a negative divisor');
@@ -102,5 +114,22 @@ var createMod = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
     Ss: matAlgo11xS0s,
     sS: matAlgo12xSfs
   }));
+
+  /**
+  * Calculate the modulus of two numbers
+  * @param {number} x
+  * @param {number} y
+  * @returns {number} res
+  * @private
+  */
+  function _modNumber(x, y) {
+    // We don't use JavaScript's % operator here as this doesn't work
+    // correctly for x < 0 and x === 0
+    // see https://en.wikipedia.org/wiki/Modulo_operation
+
+    // We use mathjs floor to handle errors associated with
+    // precision float approximation
+    return y === 0 ? x : x - y * floor(x / y);
+  }
 });
 exports.createMod = createMod;

package/lib/cjs/function/numeric/solveODE.js

@@ -10,8 +10,8 @@ var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/sli
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _is = require("../../utils/is.js");
 var _factory = require("../../utils/factory.js");
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 var name = 'solveODE';
 var dependencies = ['typed', 'add', 'subtract', 'multiply', 'divide', 'max', 'map', 'abs', 'isPositive', 'isNegative', 'larger', 'smaller', 'matrix', 'bignumber', 'unaryMinus'];
 var createSolveODE = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {

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

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCorr = void 0;
+var _factory = require("../../utils/factory.js");
+var name = 'corr';
+var dependencies = ['typed', 'matrix', 'mean', 'sqrt', 'sum', 'add', 'subtract', 'multiply', 'pow', 'divide'];
+var createCorr = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    matrix = _ref.matrix,
+    sqrt = _ref.sqrt,
+    sum = _ref.sum,
+    add = _ref.add,
+    subtract = _ref.subtract,
+    multiply = _ref.multiply,
+    pow = _ref.pow,
+    divide = _ref.divide;
+  /**
+   * Compute the correlation coefficient of a two list with values, For matrices, the matrix correlation coefficient is calculated.
+   *
+   * Syntax:
+   *
+   *     math.corr(A, B)
+   *
+   * Examples:
+   *
+   *     math.corr([1, 2, 3, 4, 5], [4, 5, 6, 7, 8])     // returns 1
+   *     math.corr([1, 2.2, 3, 4.8, 5], [4, 5.3, 6.6, 7, 8])     // returns 0.9569941688503644
+   *     math.corr(math.matrix([[1, 2.2, 3, 4.8, 5], [1, 2, 3, 4, 5]]), math.matrix([[4, 5.3, 6.6, 7, 8], [1, 2, 3, 4, 5]])) // returns DenseMatrix [0.9569941688503644, 1]
+   *
+   * See also:
+   *
+   *     median, mean, min, max, sum, prod, std, variance
+   *
+   * @param {Array | Matrix} A The first array or matrix to compute correlation coefficient
+   * @param {Array | Matrix} B The second array or matrix to compute correlation coefficient
+   * @return {*} The correlation coefficient
+   */
+  return typed(name, {
+    'Array, Array': function ArrayArray(A, B) {
+      return _corr(A, B);
+    },
+    'Matrix, Matrix': function MatrixMatrix(xMatrix, yMatrix) {
+      return matrix(_corr(xMatrix.toArray(), yMatrix.toArray()));
+    }
+  });
+  /**
+   * Calculate the correlation coefficient between two arrays or matrices.
+   * @param {Array | Matrix} A
+   * @param {Array | Matrix} B
+   * @return {*} correlation coefficient
+   * @private
+   */
+  function _corr(A, B) {
+    if (Array.isArray(A[0]) && Array.isArray(B[0])) {
+      var correlations = [];
+      for (var i = 0; i < A.length; i++) {
+        correlations.push(correlation(A[i], B[i]));
+      }
+      return correlations;
+    } else {
+      return correlation(A, B);
+    }
+  }
+  function correlation(A, B) {
+    var n = A.length;
+    var sumX = sum(A);
+    var sumY = sum(B);
+    var sumXY = A.reduce(function (acc, x, index) {
+      return add(acc, multiply(x, B[index]));
+    }, 0);
+    var sumXSquare = sum(A.map(function (x) {
+      return pow(x, 2);
+    }));
+    var sumYSquare = sum(B.map(function (y) {
+      return pow(y, 2);
+    }));
+    var numerator = subtract(multiply(n, sumXY), multiply(sumX, sumY));
+    var denominator = sqrt(multiply(subtract(multiply(n, sumXSquare), pow(sumX, 2)), subtract(multiply(n, sumYSquare), pow(sumY, 2))));
+    return divide(numerator, denominator);
+  }
+});
+exports.createCorr = createCorr;

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

@@ -9,14 +9,25 @@ var _array = require("../../utils/array.js");
 var _factory = require("../../utils/factory.js");
 var _apply = require("../matrix/apply.js");
 var name = 'quantileSeq';
-var dependencies = ['typed', 'add', 'multiply', 'partitionSelect', 'compare', 'isInteger'];
+var dependencies = ['typed', '?bignumber', 'add', 'subtract', 'divide', 'multiply', 'partitionSelect', 'compare', 'isInteger', 'smaller', 'smallerEq', 'larger'];
 var createQuantileSeq = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
+    bignumber = _ref.bignumber,
     add = _ref.add,
+    subtract = _ref.subtract,
+    divide = _ref.divide,
     multiply = _ref.multiply,
     partitionSelect = _ref.partitionSelect,
     compare = _ref.compare,
-    isInteger = _ref.isInteger;
+    isInteger = _ref.isInteger,
+    smaller = _ref.smaller,
+    smallerEq = _ref.smallerEq,
+    larger = _ref.larger;
+  var apply = (0, _apply.createApply)({
+    typed: typed,
+    isInteger: isInteger
+  });
+
   /**
    * Compute the prob order quantile of a matrix or a list with values.
    * The sequence is sorted and the middle value is returned.
@@ -51,130 +62,83 @@ var createQuantileSeq = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
    * @param {Boolean} sorted=false              is data sorted in ascending order
    * @return {Number, BigNumber, Unit, Array}   Quantile(s)
    */
-
-  var apply = (0, _apply.createApply)({
-    typed: typed,
-    isInteger: isInteger
-  });
-  /**
-   * Check if array value types are valid, throw error otherwise.
-   * @param {number | BigNumber | Unit} x
-   * @param {number | BigNumber | Unit} x
-   * @private
-   */
-  var validate = typed({
-    'number | BigNumber | Unit': function numberBigNumberUnit(x) {
-      return x;
-    }
-  });
   return typed(name, {
-    'Array|Matrix, number|BigNumber|Array': function ArrayMatrixNumberBigNumberArray(data, prob) {
-      return quantileSeq(data, prob, false);
+    'Array | Matrix, number | BigNumber': function ArrayMatrixNumberBigNumber(data, p) {
+      return _quantileSeqProbNumber(data, p, false);
+    },
+    'Array | Matrix, number | BigNumber, number': function ArrayMatrixNumberBigNumberNumber(data, prob, dim) {
+      return _quantileSeqDim(data, prob, false, dim, _quantileSeqProbNumber);
+    },
+    'Array | Matrix, number | BigNumber, boolean': _quantileSeqProbNumber,
+    'Array | Matrix, number | BigNumber, boolean, number': function ArrayMatrixNumberBigNumberBooleanNumber(data, prob, sorted, dim) {
+      return _quantileSeqDim(data, prob, sorted, dim, _quantileSeqProbNumber);
     },
-    'Array|Matrix, number|BigNumber|Array, boolean': quantileSeq,
-    'Array|Matrix, number|BigNumber|Array, number': function ArrayMatrixNumberBigNumberArrayNumber(data, prob, dim) {
-      return _quantileSeqDim(data, prob, false, dim);
+    'Array | Matrix, Array | Matrix': function ArrayMatrixArrayMatrix(data, p) {
+      return _quantileSeqProbCollection(data, p, false);
     },
-    'Array|Matrix, number|BigNumber|Array, boolean, number': function ArrayMatrixNumberBigNumberArrayBooleanNumber(data, prob, sorted, dim) {
-      return _quantileSeqDim(data, prob, sorted, dim);
+    'Array | Matrix, Array | Matrix, number': function ArrayMatrixArrayMatrixNumber(data, prob, dim) {
+      return _quantileSeqDim(data, prob, false, dim, _quantileSeqProbCollection);
+    },
+    'Array | Matrix, Array | Matrix, boolean': _quantileSeqProbCollection,
+    'Array | Matrix, Array | Matrix, boolean, number': function ArrayMatrixArrayMatrixBooleanNumber(data, prob, sorted, dim) {
+      return _quantileSeqDim(data, prob, sorted, dim, _quantileSeqProbCollection);
     }
   });
-  function _quantileSeqDim(data, prob, sorted, dim) {
-    // return [1.3, 1.2]
+  function _quantileSeqDim(data, prob, sorted, dim, fn) {
     return apply(data, dim, function (x) {
-      return quantileSeq(x, prob, sorted);
+      return fn(x, prob, sorted);
     });
   }
-  function quantileSeq(data, probOrN, sorted) {
-    var probArr, dataArr, one;
-    if (arguments.length < 2 || arguments.length > 3) {
-      throw new SyntaxError('Function quantileSeq requires two or three parameters');
+  function _quantileSeqProbNumber(data, probOrN, sorted) {
+    var probArr;
+    var dataArr = data.valueOf();
+    if (smaller(probOrN, 0)) {
+      throw new Error('N/prob must be non-negative');
     }
-    if ((0, _is.isCollection)(data)) {
-      sorted = sorted || false;
-      if (typeof sorted === 'boolean') {
-        dataArr = data.valueOf();
-        if ((0, _is.isNumber)(probOrN)) {
-          if (probOrN < 0) {
-            throw new Error('N/prob must be non-negative');
-          }
-          if (probOrN <= 1) {
-            // quantileSeq([a, b, c, d, ...], prob[,sorted])
-            return _quantileSeq(dataArr, probOrN, sorted);
-          }
-          if (probOrN > 1) {
-            // quantileSeq([a, b, c, d, ...], N[,sorted])
-            if (!isInteger(probOrN)) {
-              throw new Error('N must be a positive integer');
-            }
-            var nPlusOne = probOrN + 1;
-            probArr = new Array(probOrN);
-            for (var i = 0; i < probOrN;) {
-              probArr[i] = _quantileSeq(dataArr, ++i / nPlusOne, sorted);
-            }
-            return probArr;
-          }
-        }
-        if ((0, _is.isBigNumber)(probOrN)) {
-          var BigNumber = probOrN.constructor;
-          if (probOrN.isNegative()) {
-            throw new Error('N/prob must be non-negative');
-          }
-          one = new BigNumber(1);
-          if (probOrN.lte(one)) {
-            // quantileSeq([a, b, c, d, ...], prob[,sorted])
-            return new BigNumber(_quantileSeq(dataArr, probOrN, sorted));
-          }
-          if (probOrN.gt(one)) {
-            // quantileSeq([a, b, c, d, ...], N[,sorted])
-            if (!probOrN.isInteger()) {
-              throw new Error('N must be a positive integer');
-            }
-
-            // largest possible Array length is 2^32-1
-            // 2^32 < 10^15, thus safe conversion guaranteed
-            var intN = probOrN.toNumber();
-            if (intN > 4294967295) {
-              throw new Error('N must be less than or equal to 2^32-1, as that is the maximum length of an Array');
-            }
-            var _nPlusOne = new BigNumber(intN + 1);
-            probArr = new Array(intN);
-            for (var _i = 0; _i < intN;) {
-              probArr[_i] = new BigNumber(_quantileSeq(dataArr, new BigNumber(++_i).div(_nPlusOne), sorted));
-            }
-            return probArr;
-          }
-        }
-        if ((0, _is.isCollection)(probOrN)) {
-          // quantileSeq([a, b, c, d, ...], [prob1, prob2, ...][,sorted])
-          var probOrNArr = probOrN.valueOf();
-          probArr = new Array(probOrNArr.length);
-          for (var _i2 = 0; _i2 < probArr.length; ++_i2) {
-            var currProb = probOrNArr[_i2];
-            if ((0, _is.isNumber)(currProb)) {
-              if (currProb < 0 || currProb > 1) {
-                throw new Error('Probability must be between 0 and 1, inclusive');
-              }
-            } else if ((0, _is.isBigNumber)(currProb)) {
-              one = new currProb.constructor(1);
-              if (currProb.isNegative() || currProb.gt(one)) {
-                throw new Error('Probability must be between 0 and 1, inclusive');
-              }
-            } else {
-              throw new TypeError('Unexpected type of argument in function quantileSeq'); // FIXME: becomes redundant when converted to typed-function
-            }
-
-            probArr[_i2] = _quantileSeq(dataArr, currProb, sorted);
-          }
-          return probArr;
-        }
-        throw new TypeError('Unexpected type of argument in function quantileSeq'); // FIXME: becomes redundant when converted to typed-function
+    if (smallerEq(probOrN, 1)) {
+      // quantileSeq([a, b, c, d, ...], prob[,sorted])
+      return (0, _is.isNumber)(probOrN) ? _quantileSeq(dataArr, probOrN, sorted) : bignumber(_quantileSeq(dataArr, probOrN, sorted));
+    }
+    if (larger(probOrN, 1)) {
+      // quantileSeq([a, b, c, d, ...], N[,sorted])
+      if (!isInteger(probOrN)) {
+        throw new Error('N must be a positive integer');
       }
 
-      throw new TypeError('Unexpected type of argument in function quantileSeq'); // FIXME: becomes redundant when converted to typed-function
+      // largest possible Array length is 2^32-1
+      // 2^32 < 10^15, thus safe conversion guaranteed
+      if (larger(probOrN, 4294967295)) {
+        throw new Error('N must be less than or equal to 2^32-1, as that is the maximum length of an Array');
+      }
+      var nPlusOne = add(probOrN, 1);
+      probArr = [];
+      for (var i = 0; smaller(i, probOrN); i++) {
+        var prob = divide(i + 1, nPlusOne);
+        probArr.push(_quantileSeq(dataArr, prob, sorted));
+      }
+      return (0, _is.isNumber)(probOrN) ? probArr : bignumber(probArr);
     }
+  }
+
+  /**
+   * Calculate the prob order quantile of an n-dimensional array.
+   *
+   * @param {Array, Matrix} array
+   * @param {Array, Matrix} prob
+   * @param {Boolean} sorted
+   * @return {Number, BigNumber, Unit} prob order quantile
+   * @private
+   */
 
-    throw new TypeError('Unexpected type of argument in function quantileSeq'); // FIXME: becomes redundant when converted to typed-function
+  function _quantileSeqProbCollection(data, probOrN, sorted) {
+    var dataArr = data.valueOf();
+    // quantileSeq([a, b, c, d, ...], [prob1, prob2, ...][,sorted])
+    var probOrNArr = probOrN.valueOf();
+    var probArr = [];
+    for (var i = 0; i < probOrNArr.length; ++i) {
+      probArr.push(_quantileSeq(dataArr, probOrNArr[i], sorted));
+    }
+    return probArr;
   }
 
   /**
@@ -192,71 +156,30 @@ var createQuantileSeq = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
     if (len === 0) {
       throw new Error('Cannot calculate quantile of an empty sequence');
     }
-    if ((0, _is.isNumber)(prob)) {
-      var _index = prob * (len - 1);
-      var _fracPart = _index % 1;
-      if (_fracPart === 0) {
-        var value = sorted ? flat[_index] : partitionSelect(flat, _index);
-        validate(value);
-        return value;
-      }
-      var _integerPart = Math.floor(_index);
-      var _left;
-      var _right;
-      if (sorted) {
-        _left = flat[_integerPart];
-        _right = flat[_integerPart + 1];
-      } else {
-        _right = partitionSelect(flat, _integerPart + 1);
-
-        // max of partition is kth largest
-        _left = flat[_integerPart];
-        for (var i = 0; i < _integerPart; ++i) {
-          if (compare(flat[i], _left) > 0) {
-            _left = flat[i];
-          }
-        }
-      }
-      validate(_left);
-      validate(_right);
-
-      // Q(prob) = (1-f)*A[floor(index)] + f*A[floor(index)+1]
-      return add(multiply(_left, 1 - _fracPart), multiply(_right, _fracPart));
+    var index = (0, _is.isNumber)(prob) ? prob * (len - 1) : prob.times(len - 1);
+    var integerPart = (0, _is.isNumber)(prob) ? Math.floor(index) : index.floor().toNumber();
+    var fracPart = (0, _is.isNumber)(prob) ? index % 1 : index.minus(integerPart);
+    if (isInteger(index)) {
+      return sorted ? flat[index] : partitionSelect(flat, (0, _is.isNumber)(prob) ? index : index.valueOf());
     }
-
-    // If prob is a BigNumber
-    var index = prob.times(len - 1);
-    if (index.isInteger()) {
-      index = index.toNumber();
-      var _value = sorted ? flat[index] : partitionSelect(flat, index);
-      validate(_value);
-      return _value;
-    }
-    var integerPart = index.floor();
-    var fracPart = index.minus(integerPart);
-    var integerPartNumber = integerPart.toNumber();
     var left;
     var right;
     if (sorted) {
-      left = flat[integerPartNumber];
-      right = flat[integerPartNumber + 1];
+      left = flat[integerPart];
+      right = flat[integerPart + 1];
     } else {
-      right = partitionSelect(flat, integerPartNumber + 1);
+      right = partitionSelect(flat, integerPart + 1);
 
       // max of partition is kth largest
-      left = flat[integerPartNumber];
-      for (var _i3 = 0; _i3 < integerPartNumber; ++_i3) {
-        if (compare(flat[_i3], left) > 0) {
-          left = flat[_i3];
+      left = flat[integerPart];
+      for (var i = 0; i < integerPart; ++i) {
+        if (compare(flat[i], left) > 0) {
+          left = flat[i];
         }
       }
     }
-    validate(left);
-    validate(right);
-
     // Q(prob) = (1-f)*A[floor(index)] + f*A[floor(index)+1]
-    var one = new fracPart.constructor(1);
-    return add(multiply(left, one.minus(fracPart)), multiply(right, fracPart));
+    return add(multiply(left, subtract(1, fracPart)), multiply(right, fracPart));
   }
 });
 exports.createQuantileSeq = createQuantileSeq;