mathjs 11.11.0 → 11.11.1

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

@@ -8,7 +8,7 @@ var _factory = require("../../utils/factory.js");
 var _quantileSeq = require("../../function/statistics/quantileSeq.js");
 var _lastDimToZeroBase = require("./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
@@ -19,25 +19,47 @@ var dependencies = ['typed', 'add', 'multiply', 'partitionSelect', 'compare', 'i
  */
 var createQuantileSeqTransform = /* #__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 quantileSeq = (0, _quantileSeq.createQuantileSeq)({
     typed: typed,
+    bignumber: bignumber,
     add: add,
+    subtract: subtract,
+    divide: divide,
     multiply: multiply,
     partitionSelect: partitionSelect,
     compare: compare,
-    isInteger: isInteger
+    isInteger: isInteger,
+    smaller: smaller,
+    smallerEq: smallerEq,
+    larger: larger
   });
   return typed('quantileSeq', {
-    'Array|Matrix, number|BigNumber|Array, number': function ArrayMatrixNumberBigNumberArrayNumber(arr, prob, dim) {
+    'Array | Matrix, number | BigNumber': quantileSeq,
+    'Array | Matrix, number | BigNumber, number': function ArrayMatrixNumberBigNumberNumber(arr, prob, dim) {
       return quantileSeq(arr, prob, dimToZeroBase(dim));
     },
-    'Array|Matrix, number|BigNumber|Array, boolean, number': function ArrayMatrixNumberBigNumberArrayBooleanNumber(arr, prob, sorted, dim) {
+    'Array | Matrix, number | BigNumber, boolean': quantileSeq,
+    'Array | Matrix, number | BigNumber, boolean, number': function ArrayMatrixNumberBigNumberBooleanNumber(arr, prob, sorted, dim) {
       return quantileSeq(arr, prob, sorted, dimToZeroBase(dim));
+    },
+    'Array | Matrix, Array | Matrix': quantileSeq,
+    'Array | Matrix, Array | Matrix, number': function ArrayMatrixArrayMatrixNumber(data, prob, dim) {
+      return quantileSeq(data, prob, dimToZeroBase(dim));
+    },
+    'Array | Matrix, Array | Matrix, boolean': quantileSeq,
+    'Array | Matrix, Array | Matrix, boolean, number': function ArrayMatrixArrayMatrixBooleanNumber(data, prob, sorted, dim) {
+      return quantileSeq(data, prob, sorted, dimToZeroBase(dim));
     }
   });
   function dimToZeroBase(dim) {

package/lib/cjs/factoriesAny.js

@@ -1467,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() {
@@ -2420,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/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/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;

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

@@ -7,6 +7,7 @@ exports.createPrint = void 0;
 var _string = require("../../utils/string.js");
 var _is = require("../../utils/is.js");
 var _factory = require("../../utils/factory.js");
+var _print2 = require("../../utils/print.js");
 var name = 'print';
 var dependencies = ['typed'];
 var createPrint = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
@@ -72,9 +73,12 @@ var createPrint = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
  */
 exports.createPrint = createPrint;
 function _print(template, values, options) {
-  return template.replace(/\$([\w.]+)/g, function (original, key) {
+  return template.replace(_print2.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/cjs/header.js

@@ -6,8 +6,8 @@
  * It features real and complex numbers, units, matrices, a large set of
  * mathematical functions, and a flexible expression parser.
  *
- * @version 11.11.0
- * @date    2023-09-05
+ * @version 11.11.1
+ * @date    2023-09-20
  *
  * @license
  * Copyright (C) 2013-2023 Jos de Jong <wjosdejong@gmail.com>

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

@@ -177,18 +177,10 @@ log1pNumber.signature = n1;
  * @private
  */
 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/cjs/type/unit/Unit.js

@@ -14,8 +14,8 @@ var _function = require("../../utils/function.js");
 var _string = require("../../utils/string.js");
 var _object = require("../../utils/object.js");
 var _constants = require("../../utils/bignumber/constants.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 = 'Unit';
 var dependencies = ['?on', 'config', 'addScalar', 'subtract', 'multiplyScalar', 'divideScalar', 'pow', 'abs', 'fix', 'round', 'equal', 'isNumeric', 'format', 'number', 'Complex', 'BigNumber', 'Fraction'];
 var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {