mathjs 11.11.0 → 11.11.2

package/lib/esm/expression/transform/quantileSeq.transform.js

@@ -2,7 +2,7 @@ import { factory } from '../../utils/factory.js';
 import { createQuantileSeq } from '../../function/statistics/quantileSeq.js';
 import { lastDimToZeroBase } from './utils/lastDimToZeroBase.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'];
 
 /**
  * Attach a transform function to math.quantileSeq
@@ -14,23 +14,41 @@ var dependencies = ['typed', 'add', 'multiply', 'partitionSelect', 'compare', 'i
 export var createQuantileSeqTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
+    bignumber,
     add,
+    subtract,
+    divide,
     multiply,
     partitionSelect,
     compare,
-    isInteger
+    isInteger,
+    smaller,
+    smallerEq,
+    larger
   } = _ref;
   var quantileSeq = createQuantileSeq({
     typed,
+    bignumber,
     add,
+    subtract,
+    divide,
     multiply,
     partitionSelect,
     compare,
-    isInteger
+    isInteger,
+    smaller,
+    smallerEq,
+    larger
   });
   return typed('quantileSeq', {
-    'Array|Matrix, number|BigNumber|Array, number': (arr, prob, dim) => quantileSeq(arr, prob, dimToZeroBase(dim)),
-    'Array|Matrix, number|BigNumber|Array, boolean, number': (arr, prob, sorted, dim) => quantileSeq(arr, prob, sorted, dimToZeroBase(dim))
+    'Array | Matrix, number | BigNumber': quantileSeq,
+    'Array | Matrix, number | BigNumber, number': (arr, prob, dim) => quantileSeq(arr, prob, dimToZeroBase(dim)),
+    'Array | Matrix, number | BigNumber, boolean': quantileSeq,
+    'Array | Matrix, number | BigNumber, boolean, number': (arr, prob, sorted, dim) => quantileSeq(arr, prob, sorted, dimToZeroBase(dim)),
+    'Array | Matrix, Array | Matrix': quantileSeq,
+    'Array | Matrix, Array | Matrix, number': (data, prob, dim) => quantileSeq(data, prob, dimToZeroBase(dim)),
+    'Array | Matrix, Array | Matrix, boolean': quantileSeq,
+    'Array | Matrix, Array | Matrix, boolean, number': (data, prob, sorted, dim) => quantileSeq(data, prob, sorted, dimToZeroBase(dim))
   });
   function dimToZeroBase(dim) {
     // TODO: find a better way, maybe lastDimToZeroBase could apply to more cases.

package/lib/esm/factoriesAny.js

@@ -287,4 +287,5 @@ export { createStdTransform } from './expression/transform/std.transform.js';
 export { createSumTransform } from './expression/transform/sum.transform.js';
 export { createQuantileSeqTransform } from './expression/transform/quantileSeq.transform.js';
 export { createCumSumTransform } from './expression/transform/cumsum.transform.js';
-export { createVarianceTransform } from './expression/transform/variance.transform.js';
+export { createVarianceTransform } from './expression/transform/variance.transform.js';
+export { createPrintTransform } from './expression/transform/print.transform.js';

package/lib/esm/function/algebra/derivative.js

@@ -526,7 +526,7 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
       node.args[i] = createConstantNode(0);
     }
     node.compile().evaluate();
-    throw new Error('Expected TypeError, but none found');
+    throw new Error('Function "' + node.name + '" is not supported by derivative, or a wrong number of arguments is passed');
   }
 
   /**

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

@@ -1,6 +1,6 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-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) { _defineProperty(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) { _defineProperty(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; }
 import { isFunctionNode, isOperatorNode, isParenthesisNode } from '../../../utils/is.js';
 import { factory } from '../../../utils/factory.js';
 import { hasOwnProperty } from '../../../utils/object.js';

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

@@ -1,12 +1,13 @@
+import { isInteger } from '../../utils/number.js';
 import { factory } from '../../utils/factory.js';
+import { createMod } from './mod.js';
 import { createMatAlgo01xDSid } from '../../type/matrix/utils/matAlgo01xDSid.js';
 import { createMatAlgo04xSidSid } from '../../type/matrix/utils/matAlgo04xSidSid.js';
 import { createMatAlgo10xSids } from '../../type/matrix/utils/matAlgo10xSids.js';
 import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
-import { gcdNumber } from '../../plain/number/index.js';
 import { ArgumentsError } from '../../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) {
@@ -16,11 +17,24 @@ export var createGcd = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     matrix,
+    config,
+    round,
     equalScalar,
+    zeros,
     BigNumber,
     DenseMatrix,
     concat
   } = _ref;
+  var mod = createMod({
+    typed,
+    config,
+    round,
+    matrix,
+    equalScalar,
+    zeros,
+    DenseMatrix,
+    concat
+  });
   var matAlgo01xDSid = createMatAlgo01xDSid({
     typed
   });
@@ -64,7 +78,7 @@ export var createGcd = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {number | BigNumber | Fraction | Array | Matrix}                           The greatest common divisor
    */
   return typed(name, {
-    'number, number': gcdNumber,
+    'number, number': _gcdNumber,
     'BigNumber, BigNumber': _gcdBigNumber,
     'Fraction, Fraction': (x, y) => x.gcd(y)
   }, matrixAlgorithmSuite({
@@ -93,6 +107,28 @@ export var createGcd = /* #__PURE__ */factory(name, dependencies, _ref => {
     })
   });
 
+  /**
+  * 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 (!isInteger(a) || !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
@@ -108,7 +144,7 @@ export var createGcd = /* #__PURE__ */factory(name, dependencies, _ref => {
     // 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/esm/function/arithmetic/mod.js

@@ -1,21 +1,33 @@
 import { factory } from '../../utils/factory.js';
+import { createFloor } from './floor.js';
 import { createMatAlgo02xDS0 } from '../../type/matrix/utils/matAlgo02xDS0.js';
 import { createMatAlgo03xDSf } from '../../type/matrix/utils/matAlgo03xDSf.js';
 import { createMatAlgo05xSfSf } from '../../type/matrix/utils/matAlgo05xSfSf.js';
 import { createMatAlgo11xS0s } from '../../type/matrix/utils/matAlgo11xS0s.js';
 import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
-import { modNumber } from '../../plain/number/index.js';
 import { createMatrixAlgorithmSuite } from '../../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'];
 export var createMod = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
+    config,
+    round,
     matrix,
     equalScalar,
+    zeros,
     DenseMatrix,
     concat
   } = _ref;
+  var floor = createFloor({
+    typed,
+    config,
+    round,
+    matrix,
+    equalScalar,
+    zeros,
+    DenseMatrix
+  });
   var matAlgo02xDS0 = createMatAlgo02xDS0({
     typed,
     equalScalar
@@ -77,7 +89,7 @@ export var createMod = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {number | BigNumber | Fraction | Array | Matrix} Returns the remainder of `x` divided by `y`.
    */
   return typed(name, {
-    'number, number': modNumber,
+    'number, number': _modNumber,
     'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
       if (y.isNeg()) {
         throw new Error('Cannot calculate mod for a negative divisor');
@@ -98,4 +110,21 @@ export var createMod = /* #__PURE__ */factory(name, dependencies, _ref => {
     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);
+  }
 });

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

@@ -1,6 +1,6 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-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) { _defineProperty(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) { _defineProperty(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; }
 import { isUnit, isNumber, isBigNumber } from '../../utils/is.js';
 import { factory } from '../../utils/factory.js';
 var name = 'solveODE';

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

@@ -23,8 +23,8 @@ export var createCorr = /* #__PURE__ */factory(name, dependencies, _ref => {
    * 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]
+   *     math.corr([1, 2.2, 3, 4.8, 5], [4, 5.3, 6.6, 7, 8])     //returns 0.9569941688503644
+   *     math.corr([[1, 2.2, 3, 4.8, 5], [4, 5.3, 6.6, 7, 8]],[[1, 2.2, 3, 4.8, 5], [4, 5.3, 6.6, 7, 8]])   // returns [1,1]
    *
    * See also:
    *
@@ -38,8 +38,9 @@ export var createCorr = /* #__PURE__ */factory(name, dependencies, _ref => {
     'Array, Array': function ArrayArray(A, B) {
       return _corr(A, B);
     },
-    'Matrix, Matrix': function MatrixMatrix(xMatrix, yMatrix) {
-      return matrix(_corr(xMatrix.toArray(), yMatrix.toArray()));
+    'Matrix, Matrix': function MatrixMatrix(A, B) {
+      var res = _corr(A.toArray(), B.toArray());
+      return Array.isArray(res) ? matrix(res) : res;
     }
   });
   /**
@@ -50,13 +51,22 @@ export var createCorr = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @private
    */
   function _corr(A, B) {
+    var correlations = [];
     if (Array.isArray(A[0]) && Array.isArray(B[0])) {
-      var correlations = [];
+      if (A.length !== B.length) {
+        throw new SyntaxError('Dimension mismatch. Array A and B must have the same length.');
+      }
       for (var i = 0; i < A.length; i++) {
+        if (A[i].length !== B[i].length) {
+          throw new SyntaxError('Dimension mismatch. Array A and B must have the same number of elements.');
+        }
         correlations.push(correlation(A[i], B[i]));
       }
       return correlations;
     } else {
+      if (A.length !== B.length) {
+        throw new SyntaxError('Dimension mismatch. Array A and B must have the same number of elements.');
+      }
       return correlation(A, B);
     }
   }

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

@@ -1,18 +1,29 @@
-import { isBigNumber, isCollection, isNumber } from '../../utils/is.js';
+import { isNumber } from '../../utils/is.js';
 import { flatten } from '../../utils/array.js';
 import { factory } from '../../utils/factory.js';
 import { createApply } from '../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'];
 export var createQuantileSeq = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
+    bignumber,
     add,
+    subtract,
+    divide,
     multiply,
     partitionSelect,
     compare,
-    isInteger
+    isInteger,
+    smaller,
+    smallerEq,
+    larger
   } = _ref;
+  var 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.
@@ -47,122 +58,69 @@ export var createQuantileSeq = /* #__PURE__ */factory(name, dependencies, _ref =
    * @param {Boolean} sorted=false              is data sorted in ascending order
    * @return {Number, BigNumber, Unit, Array}   Quantile(s)
    */
-
-  var apply = createApply({
-    typed,
-    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': (data, prob) => quantileSeq(data, prob, false),
-    'Array|Matrix, number|BigNumber|Array, boolean': quantileSeq,
-    'Array|Matrix, number|BigNumber|Array, number': (data, prob, dim) => _quantileSeqDim(data, prob, false, dim),
-    'Array|Matrix, number|BigNumber|Array, boolean, number': (data, prob, sorted, dim) => _quantileSeqDim(data, prob, sorted, dim)
+    'Array | Matrix, number | BigNumber': (data, p) => _quantileSeqProbNumber(data, p, false),
+    'Array | Matrix, number | BigNumber, number': (data, prob, dim) => _quantileSeqDim(data, prob, false, dim, _quantileSeqProbNumber),
+    'Array | Matrix, number | BigNumber, boolean': _quantileSeqProbNumber,
+    'Array | Matrix, number | BigNumber, boolean, number': (data, prob, sorted, dim) => _quantileSeqDim(data, prob, sorted, dim, _quantileSeqProbNumber),
+    'Array | Matrix, Array | Matrix': (data, p) => _quantileSeqProbCollection(data, p, false),
+    'Array | Matrix, Array | Matrix, number': (data, prob, dim) => _quantileSeqDim(data, prob, false, dim, _quantileSeqProbCollection),
+    'Array | Matrix, Array | Matrix, boolean': _quantileSeqProbCollection,
+    'Array | Matrix, Array | Matrix, boolean, number': (data, prob, sorted, dim) => _quantileSeqDim(data, prob, sorted, dim, _quantileSeqProbCollection)
   });
-  function _quantileSeqDim(data, prob, sorted, dim) {
-    // return [1.3, 1.2]
-    return apply(data, dim, x => quantileSeq(x, prob, sorted));
+  function _quantileSeqDim(data, prob, sorted, dim, fn) {
+    return apply(data, dim, x => 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 (isCollection(data)) {
-      sorted = sorted || false;
-      if (typeof sorted === 'boolean') {
-        dataArr = data.valueOf();
-        if (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 (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 (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 (isNumber(currProb)) {
-              if (currProb < 0 || currProb > 1) {
-                throw new Error('Probability must be between 0 and 1, inclusive');
-              }
-            } else if (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 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 isNumber(probOrN) ? probArr : bignumber(probArr);
     }
+  }
 
-    throw new TypeError('Unexpected type of argument in function quantileSeq'); // FIXME: becomes redundant when converted to typed-function
+  /**
+   * 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
+   */
+
+  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;
   }
 
   /**
@@ -180,70 +138,29 @@ export var createQuantileSeq = /* #__PURE__ */factory(name, dependencies, _ref =
     if (len === 0) {
       throw new Error('Cannot calculate quantile of an empty sequence');
     }
-    if (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));
-    }
-
-    // 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 index = isNumber(prob) ? prob * (len - 1) : prob.times(len - 1);
+    var integerPart = isNumber(prob) ? Math.floor(index) : index.floor().toNumber();
+    var fracPart = isNumber(prob) ? index % 1 : index.minus(integerPart);
+    if (isInteger(index)) {
+      return sorted ? flat[index] : partitionSelect(flat, isNumber(prob) ? index : index.valueOf());
     }
-    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));
   }
 });

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

@@ -1,6 +1,7 @@
 import { format } from '../../utils/string.js';
 import { isString } from '../../utils/is.js';
 import { factory } from '../../utils/factory.js';
+import { printTemplate } from '../../utils/print.js';
 var name = 'print';
 var dependencies = ['typed'];
 export var createPrint = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -67,9 +68,12 @@ export var createPrint = /* #__PURE__ */factory(name, dependencies, _ref => {
  * @private
  */
 function _print(template, values, options) {
-  return template.replace(/\$([\w.]+)/g, function (original, key) {
+  return template.replace(printTemplate, function (original, key) {
     var keys = key.split('.');
     var value = values[keys.shift()];
+    if (value !== undefined && value.isMatrix) {
+      value = value.toArray();
+    }
     while (keys.length && value !== undefined) {
       var k = keys.shift();
       value = k ? value[k] : value + '.';

package/lib/esm/plain/number/arithmetic.js

@@ -146,18 +146,10 @@ log1pNumber.signature = n1;
  * @private
  */
 export function modNumber(x, y) {
-  if (y > 0) {
-    // 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
-    return x - y * Math.floor(x / y);
-  } else if (y === 0) {
-    return x;
-  } else {
-    // y < 0
-    // TODO: implement mod for a negative divisor
-    throw new Error('Cannot calculate mod for a negative divisor');
-  }
+  // 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
+  return y === 0 ? x : x - y * Math.floor(x / y);
 }
 modNumber.signature = n2;
 

package/lib/esm/type/unit/Unit.js

@@ -1,7 +1,7 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import _extends from "@babel/runtime/helpers/extends";
-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) { _defineProperty(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) { _defineProperty(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; }
 import { isComplex, isUnit, typeOf } from '../../utils/is.js';
 import { factory } from '../../utils/factory.js';
 import { memoize } from '../../utils/function.js';