mathjs 11.11.0 → 11.11.1

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';

package/lib/esm/utils/print.js

@@ -0,0 +1 @@
+export var printTemplate = /\$([\w.]+)/g;

package/lib/esm/utils/snapshot.js

@@ -1,7 +1,7 @@
 import _extends from "@babel/runtime/helpers/extends";
 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; }
 /**
  * This file contains helper methods to create expected snapshot structures
  * of both instance and ES6 exports.

package/lib/esm/version.js

@@ -1,3 +1,3 @@
-export var version = '11.11.0';
+export var version = '11.11.1';
 // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mathjs",
-  "version": "11.11.0",
+  "version": "11.11.1",
   "description": "Math.js is an extensive math library for JavaScript and Node.js. It features a flexible expression parser with support for symbolic computation, comes with a large set of built-in functions and constants, and offers an integrated solution to work with different data types like numbers, big numbers, complex numbers, fractions, units, and matrices.",
   "author": "Jos de Jong <wjosdejong@gmail.com> (https://github.com/josdejong)",
   "homepage": "https://mathjs.org",
@@ -25,7 +25,7 @@
     "unit"
   ],
   "dependencies": {
-    "@babel/runtime": "^7.22.6",
+    "@babel/runtime": "^7.22.15",
     "complex.js": "^2.1.1",
     "decimal.js": "^10.4.3",
     "escape-latex": "^1.2.0",
@@ -33,33 +33,33 @@
     "javascript-natural-sort": "^0.7.1",
     "seedrandom": "^3.0.5",
     "tiny-emitter": "^2.1.0",
-    "typed-function": "^4.1.0"
+    "typed-function": "^4.1.1"
   },
   "devDependencies": {
-    "@babel/core": "7.22.9",
+    "@babel/core": "7.22.20",
     "@babel/plugin-transform-object-assign": "7.22.5",
-    "@babel/plugin-transform-runtime": "7.22.9",
-    "@babel/preset-env": "7.22.9",
-    "@babel/register": "7.22.5",
+    "@babel/plugin-transform-runtime": "7.22.15",
+    "@babel/preset-env": "7.22.20",
+    "@babel/register": "7.22.15",
     "@types/assert": "1.5.6",
     "@types/mocha": "10.0.1",
-    "@typescript-eslint/eslint-plugin": "6.1.0",
-    "@typescript-eslint/parser": "6.1.0",
-    "assert": "2.0.0",
+    "@typescript-eslint/eslint-plugin": "6.7.2",
+    "@typescript-eslint/parser": "6.7.2",
+    "assert": "2.1.0",
     "babel-loader": "9.1.3",
     "benchmark": "2.1.4",
-    "c8": "8.0.0",
+    "c8": "8.0.1",
     "codecov": "3.8.3",
-    "core-js": "3.31.1",
+    "core-js": "3.32.2",
     "del": "6.1.1",
     "dtslint": "4.2.1",
-    "eslint": "8.45.0",
-    "eslint-config-prettier": "8.8.0",
+    "eslint": "8.49.0",
+    "eslint-config-prettier": "9.0.0",
     "eslint-config-standard": "17.1.0",
-    "eslint-plugin-import": "2.27.5",
+    "eslint-plugin-import": "2.28.1",
     "eslint-plugin-mocha": "10.1.0",
-    "eslint-plugin-n": "16.0.1",
-    "eslint-plugin-prettier": "4.2.1",
+    "eslint-plugin-n": "16.1.0",
+    "eslint-plugin-prettier": "5.0.0",
     "eslint-plugin-promise": "6.1.1",
     "expect-type": "0.16.0",
     "expr-eval": "2.0.2",
@@ -67,7 +67,7 @@
     "glob": "8.1.0",
     "gulp": "4.0.2",
     "gulp-babel": "8.0.0",
-    "handlebars": "4.7.7",
+    "handlebars": "4.7.8",
     "jsep": "1.3.8",
     "karma": "6.4.2",
     "karma-browserstack-launcher": "1.6.0",
@@ -85,11 +85,11 @@
     "ndarray-pack": "1.2.1",
     "numericjs": "1.2.6",
     "pad-right": "0.2.2",
-    "prettier": "2.8.8",
+    "prettier": "3.0.3",
     "process": "0.11.10",
     "sylvester": "0.0.21",
     "ts-node": "10.9.1",
-    "typescript": "5.1.6",
+    "typescript": "5.2.2",
     "webpack": "5.88.2",
     "zeros": "1.0.0"
   },