mathjs 15.1.0 → 15.2.0

package/lib/cjs/expression/embeddedDocs/embeddedDocs.js

@@ -94,6 +94,8 @@ var _subtract = require("./function/arithmetic/subtract.js");
 var _unaryMinus = require("./function/arithmetic/unaryMinus.js");
 var _unaryPlus = require("./function/arithmetic/unaryPlus.js");
 var _xgcd = require("./function/arithmetic/xgcd.js");
+var _num = require("./function/fraction/num.js");
+var _den = require("./function/fraction/den.js");
 var _bitAnd = require("./function/bitwise/bitAnd.js");
 var _bitNot = require("./function/bitwise/bitNot.js");
 var _bitOr = require("./function/bitwise/bitOr.js");
@@ -557,6 +559,8 @@ const embeddedDocs = exports.embeddedDocs = {
   unaryPlus: _unaryPlus.unaryPlusDocs,
   xgcd: _xgcd.xgcdDocs,
   invmod: _invmod.invmodDocs,
+  num: _num.numDocs,
+  den: _den.denDocs,
   // functions - bitwise
   bitAnd: _bitAnd.bitAndDocs,
   bitNot: _bitNot.bitNotDocs,

package/lib/cjs/expression/embeddedDocs/function/fraction/den.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.denDocs = void 0;
+const denDocs = exports.denDocs = {
+  name: 'den',
+  category: 'Fraction',
+  syntax: ['den(x)'],
+  description: 'Get the denominator of a fraction.',
+  examples: ['den(fraction(2, 3))', 'den(fraction(5, 8))'],
+  seealso: ['num', 'fraction']
+};

package/lib/cjs/expression/embeddedDocs/function/fraction/num.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.numDocs = void 0;
+const numDocs = exports.numDocs = {
+  name: 'num',
+  category: 'Fraction',
+  syntax: ['num(x)'],
+  description: 'Get the numerator of a fraction.',
+  examples: ['num(fraction(2, 3))', 'num(fraction(5, 8))'],
+  seealso: ['den', 'fraction']
+};

package/lib/cjs/expression/parse.js

@@ -68,6 +68,23 @@ const createParse = exports.createParse = /* #__PURE__ */(0, _factory.factory)(n
    *
    *     evaluate, compile
    *
+   * History:
+   *
+   *     v0.9   Created
+   *     v0.13  Switched to one-based indices
+   *     v0.14  Added `[1,2;3,4]` notation for matrices
+   *     v0.18  Dropped the `function` keyword
+   *     v0.20  Added ternary conditional
+   *     v0.27  Allow multi-line expressions; allow functions that receive
+   *            unevaluated parameters (`rawArgs`)
+   *     v3     Add object notation; allow assignments internal to other
+   *            expressions
+   *     v7.3   Supported binary, octal, and hexadecimal notation
+   *     v9.5   Support for calculations with percentages
+   *     v12.4  Allow trailing commas in matrices
+   *     v14.8  Add nullish coalescing operator
+   *     v15.1  Add optional chaining operator
+   *
    * @param {string | string[] | Matrix} expr          Expression to be parsed
    * @param {{nodes: Object<string, Node>}} [options]  Available options:
    *                                                   - `nodes` a set of custom nodes
@@ -897,8 +914,15 @@ const createParse = exports.createParse = /* #__PURE__ */(0, _factory.factory)(n
     let node;
     const params = [];
     if (state.token === ':') {
-      // implicit start=1 (one-based)
-      node = new ConstantNode(1);
+      if (state.conditionalLevel === state.nestingLevel) {
+        // we are in the midst of parsing a conditional operator, so not
+        // a range, but rather an empty true-expr, which is considered a
+        // syntax error
+        throw createSyntaxError(state, 'The true-expression of a conditional operator may not be empty');
+      } else {
+        // implicit start of range = 1 (one-based)
+        node = new ConstantNode(1);
+      }
     } else {
       // explicit start
       node = parseAddSubtract(state);

package/lib/cjs/factoriesAny.js

@@ -495,6 +495,12 @@ Object.defineProperty(exports, "createDeepEqual", {
     return _deepEqual.createDeepEqual;
   }
 });
+Object.defineProperty(exports, "createDen", {
+  enumerable: true,
+  get: function () {
+    return _den.createDen;
+  }
+});
 Object.defineProperty(exports, "createDenseMatrixClass", {
   enumerable: true,
   get: function () {
@@ -1371,6 +1377,12 @@ Object.defineProperty(exports, "createNullishTransform", {
     return _nullishTransform.createNullishTransform;
   }
 });
+Object.defineProperty(exports, "createNum", {
+  enumerable: true,
+  get: function () {
+    return _num.createNum;
+  }
+});
 Object.defineProperty(exports, "createNumber", {
   enumerable: true,
   get: function () {
@@ -2517,4 +2529,6 @@ var _andTransform = require("./expression/transform/and.transform.js");
 var _orTransform = require("./expression/transform/or.transform.js");
 var _nullishTransform = require("./expression/transform/nullish.transform.js");
 var _bitAndTransform = require("./expression/transform/bitAnd.transform.js");
-var _bitOrTransform = require("./expression/transform/bitOr.transform.js");
+var _bitOrTransform = require("./expression/transform/bitOr.transform.js");
+var _num = require("./function/fraction/num.js");
+var _den = require("./function/fraction/den.js");

package/lib/cjs/function/algebra/polynomialRoot.js

@@ -52,6 +52,10 @@ const createPolynomialRoot = exports.createPolynomialRoot = /* #__PURE__ */(0, _
    * See also:
    *     cbrt, sqrt
    *
+   * History:
+   *
+   *     v11.4  Created
+   *
    * @param {... number | Complex} coeffs
    *     The coefficients of the polynomial, starting with with the constant coefficent, followed
    *     by the linear coefficient and subsequent coefficients of increasing powers.

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

@@ -59,7 +59,7 @@ const createAdd = exports.createAdd = /* #__PURE__ */(0, _factory.factory)(name,
    *
    *    const c = math.unit('5 cm')
    *    const d = math.unit('2.1 mm')
-   *    math.add(c, d)               // returns Unit 52.1 mm
+   *    math.add(c, d)               // returns Unit 5.21 cm
    *
    *    math.add("2.3", "4")         // returns number 6.3
    *
@@ -67,6 +67,13 @@ const createAdd = exports.createAdd = /* #__PURE__ */(0, _factory.factory)(name,
    *
    *    subtract, sum
    *
+   * History:
+   *
+   *     v13     Handle bigint arguments
+   *     v11.6   Support matrix broadcasting
+   *     v3.8    Allow more than two arguments
+   *     v0.0.2  Created
+   *
    * @param  {number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix} x First value to add
    * @param  {number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix} y Second value to add
    * @return {number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix} Sum of `x` and `y`

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

@@ -41,17 +41,18 @@ const createCbrt = exports.createCbrt = /* #__PURE__ */(0, _factory.factory)(nam
    *    math.map([27, 64, 125], x => math.cbrt(x))       // returns [3, 4, 5]
    *
    *    const x = math.complex('8i')
-   *    math.cbrt(x)                   // returns Complex 1.7320508075689 + i
-   *    math.cbrt(x, true)             // returns Matrix [
-   *                                    //    1.7320508075689 + i
-   *                                    //   -1.7320508075689 + i
-   *                                    //   -2i
-   *                                    // ]
+   *    math.cbrt(x)                   // returns 1.7320508075689 + i ...
+   *    math.cbrt(x, true)
+   *    // Complex Matrix ["1.7320508075689+i", "-1.7320508075689+i", "-2i"]
    *
    * See also:
    *
    *    square, sqrt, cube
    *
+   * History:
+   *
+   *    v2.3  Created
+   *
    * @param {number | BigNumber | Complex | Unit} x
    *            Value for which to calculate the cubic root.
    * @param {boolean} [allRoots]  Optional, false by default. Only applicable

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

@@ -106,13 +106,13 @@ const createCeil = exports.createCeil = /* #__PURE__ */(0, _factory.factory)(nam
    *    math.ceil(-4.782, 2)         // returns number -4.78
    *
    *    const c = math.complex(3.24, -2.71)
-   *    math.ceil(c)                 // returns Complex 4 - 2i
+   *    math.ceil(c)                 // returns Complex 4 - 2i ...
    *    math.ceil(c, 1)              // returns Complex 3.3 - 2.7i
    *
    *    const unit = math.unit('3.241 cm')
    *    const cm = math.unit('cm')
    *    const mm = math.unit('mm')
-   *    math.ceil(unit, 1, cm)      // returns Unit 3.3 cm
+   *    math.ceil(unit, 1, cm)      // returns Unit 3.3 cm ...
    *    math.ceil(unit, 1, mm)      // returns Unit 32.5 mm
    *
    *    math.ceil([3.2, 3.8, -4.7])  // returns Array [4, 4, -4]
@@ -122,6 +122,14 @@ const createCeil = exports.createCeil = /* #__PURE__ */(0, _factory.factory)(nam
    *
    *    floor, fix, round
    *
+   * History:
+   *
+   *     v14    Handle Units
+   *     v7.4   Allow second "precision" argument
+   *     v5.7   Support tolerance for round-off errors
+   *     v2     Handle Fractions
+   *     v0.1   Created
+   *
    * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x  Value to be rounded
    * @param  {number | BigNumber | Array} [n=0]                            Number of decimals
    * @param  {Unit} [valuelessUnit]                                        A valueless unit

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

@@ -29,16 +29,18 @@ const createExp = exports.createExp = /* #__PURE__ */(0, _factory.factory)(name,
    *    math.log(math.exp(2))        // returns number 2
    *
    *    math.map([1, 2, 3], math.exp)
-   *    // returns Array [
-   *    //   2.718281828459045,
-   *    //   7.3890560989306495,
-   *    //   20.085536923187668
-   *    // ]
+   *    // returns [2.718281828459045, 7.3890560989306495, 20.085536923187668]
    *
    * See also:
    *
    *    expm1, expm, log, pow
    *
+   * History:
+   *
+   *    v11     Don't apply elementwise, avoid confusion with matrix exponential
+   *    v0.20   Handle BigNumbers
+   *    v0.0.2  Created
+   *
    * @param {number | BigNumber | Complex} x  A number to exponentiate
    * @return {number | BigNumber | Complex} Exponential of `x`
    */

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

@@ -33,16 +33,17 @@ const createExpm1 = exports.createExpm1 = /* #__PURE__ */(0, _factory.factory)(n
    *    math.log(math.expm1(2) + 1)        // returns number 2
    *
    *    math.map([1, 2, 3], math.expm1)
-   *    // returns Array [
-   *    //   1.718281828459045,
-   *    //   6.3890560989306495,
-   *    //   19.085536923187668
-   *    // ]
+   *    // returns [1.718281828459045, 6.3890560989306495, 19.085536923187668]
    *
    * See also:
    *
    *    exp, expm, log, pow
    *
+   * History:
+   *
+   *    v11    Don't apply elementwise, avoids confusion with matrix exponential
+   *    v4.2   Created
+   *
    * @param {number | BigNumber | Complex} x  The number to exponentiate
    * @return {number | BigNumber | Complex} Exponential of `x`, minus one
    */

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

@@ -72,13 +72,13 @@ const createFix = exports.createFix = /* #__PURE__ */(0, _factory.factory)(name,
    *    math.fix(-4.17, 1)               // returns number -4.1
    *
    *    const c = math.complex(3.22, -2.78)
-   *    math.fix(c)                  // returns Complex 3 - 2i
+   *    math.fix(c)                  // returns Complex 3 - 2i ...
    *    math.fix(c, 1)               // returns Complex 3.2 -2.7i
    *
    *    const unit = math.unit('3.241 cm')
    *    const cm = math.unit('cm')
    *    const mm = math.unit('mm')
-   *    math.fix(unit, 1, cm)      // returns Unit 3.2 cm
+   *    math.fix(unit, 1, cm)      // returns Unit 3.2 cm ...
    *    math.fix(unit, 1, mm)      // returns Unit 32.4 mm
    *
    *    math.fix([3.2, 3.8, -4.7])      // returns Array [3, 3, -4]
@@ -88,6 +88,14 @@ const createFix = exports.createFix = /* #__PURE__ */(0, _factory.factory)(name,
    *
    *    ceil, floor, round
    *
+   * History:
+   *
+   *     v14    Handle Units
+   *     v7.4   Allow second "precision" argument
+   *     v5.7   Support tolerance for round-off errors
+   *     v2     Handle Fractions
+   *     v0.1   Created
+   *
    * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x  Value to be rounded
    * @param  {number | BigNumber | Array} [n=0]                            Number of decimals
    * @param  {Unit} [valuelessUnit]                                        A valueless unit

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

@@ -112,13 +112,13 @@ const createFloor = exports.createFloor = /* #__PURE__ */(0, _factory.factory)(n
    *    math.floor(-4.782, 2)         // returns number -4.79
    *
    *    const c = math.complex(3.24, -2.71)
-   *    math.floor(c)                 // returns Complex 3 - 3i
+   *    math.floor(c)                 // returns Complex 3 - 3i ...
    *    math.floor(c, 1)              // returns Complex 3.2 -2.8i
    *
    *    const unit = math.unit('3.241 cm')
    *    const cm = math.unit('cm')
    *    const mm = math.unit('mm')
-   *    math.floor(unit, 1, cm)      // returns Unit 3.2 cm
+   *    math.floor(unit, 1, cm)      // returns Unit 3.2 cm ...
    *    math.floor(unit, 1, mm)      // returns Unit 32.4 mm
    *
    *    math.floor([3.2, 3.8, -4.7])       // returns Array [3, 3, -5]
@@ -132,6 +132,14 @@ const createFloor = exports.createFloor = /* #__PURE__ */(0, _factory.factory)(n
    *
    *    ceil, fix, round
    *
+   * History:
+   *
+   *     v14    Handle Units
+   *     v7.4   Allow second "precision" argument
+   *     v5.7   Support tolerance for round-off errors
+   *     v2     Handle Fractions
+   *     v0.1   Created
+   *
    * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x  Value to be rounded
    * @param  {number | BigNumber | Array} [n=0]                            Number of decimals
    * @param  {Unit} [valuelessUnit]                                        A valueless unit

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

@@ -45,6 +45,19 @@ const createLog = exports.createLog = /* #__PURE__ */(0, _factory.factory)(name,
    *
    *    exp, log2, log10, log1p
    *
+   * History:
+   *
+   *    v0.0.2  Created
+   *    v0.2    Add optional base argument
+   *    v0.3    Handle Array input
+   *    v0.5    Handle Matrix input
+   *    v0.16   Handle BigNumber input
+   *    v0.21   Support negative BigNumbers
+   *    v11     Drop Array/Matrix support in favor of explicit map of
+   *            the scalar log function, to avoid confusion with the log
+   *            of a matrix
+   *    v14     Allow value and base to be Fractions, when the log is rational
+   *
    * @param {number | BigNumber | Fraction | Complex} x
    *            Value for which to calculate the logarithm.
    * @param {number | BigNumber | Fraction | Complex} [base=e]

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

@@ -82,14 +82,20 @@ const createMod = exports.createMod = /* #__PURE__ */(0, _factory.factory)(name,
    *    function isOdd(x) {
    *      return math.mod(x, 2) != 0
    *    }
-   *
-   *    isOdd(2)                      // returns false
+   *    isOdd(2)                      // returns false...
    *    isOdd(3)                      // returns true
    *
    * See also:
    *
    *    divide
    *
+   * History:
+   *
+   *    v13    Handle bigints
+   *    v11.6  Support matrix broadcasting
+   *    v2     Handle Fractions
+   *    v0.2   Created
+   *
    * @param  {number | BigNumber | bigint | Fraction | Array | Matrix} x Dividend
    * @param  {number | BigNumber | bigint | Fraction | Array | Matrix} y Divisor
    * @return {number | BigNumber | bigint | Fraction | Array | Matrix} Returns the remainder of `x` divided by `y`.

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

@@ -58,14 +58,20 @@ const createNthRoot = exports.createNthRoot = /* #__PURE__ */(0, _factory.factor
    *
    * Examples:
    *
-   *     math.nthRoot(9, 2)    // returns 3 (since 3^2 == 9)
-   *     math.sqrt(9)          // returns 3 (since 3^2 == 9)
-   *     math.nthRoot(64, 3)   // returns 4 (since 4^3 == 64)
+   *     math.nthRoot(9, 2)    // returns 3
+   *     math.sqrt(9)          // returns 3
+   *     math.nthRoot(64, 3)   // returns 4
    *
    * See also:
    *
    *     sqrt, pow
    *
+   * History:
+   *
+   *     v11.6  Support matrix broadcasting
+   *     v2     Handle Complex
+   *     v1.1   Created
+   *
    * @param {number | BigNumber | Array | Matrix | Complex} a
    *              Value for which to calculate the nth root
    * @param {number | BigNumber} [root=2]    The root.

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

@@ -92,22 +92,19 @@ const createNthRoots = exports.createNthRoots = /* #__PURE__ */(0, _factory.fact
    *
    * Examples:
    *
-   *    math.nthRoots(1)
-   *    // returns [
-   *    //   {re: 1, im: 0},
-   *    //   {re: -1, im: 0}
-   *    // ]
+   *    math.nthRoots(1) // returns [ {re: 1, im: 0}, {re: -1, im: 0} ]
+   *
    *    math.nthRoots(1, 3)
-   *    // returns [
-   *    //   { re: 1, im: 0 },
-   *    //   { re: -0.4999999999999998, im: 0.8660254037844387 },
-   *    //   { re: -0.5000000000000004, im: -0.8660254037844385 }
-   *    // ]
+   *    // Complex [1, "-0.5+0.866025403784439i", "-0.5-0.866025403784439i"]
    *
    * See also:
    *
    *    nthRoot, pow, sqrt
    *
+   * History:
+   *
+   *    v1.1   Created
+   *
    * @param {number | BigNumber | Fraction | Complex} x Number to be rounded
    * @param {number} [root=2] Optional root, default value is 2
    * @return {number | BigNumber | Fraction | Complex} Returns the nth roots

package/lib/cjs/function/fraction/den.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDen = void 0;
+var _factory = require("../../utils/factory.js");
+var _collection = require("../../utils/collection.js");
+const name = 'den';
+const dependencies = ['typed', 'fraction'];
+const createDen = exports.createDen = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    fraction
+  } = _ref;
+  /**
+   * Get the denominator of a fraction.
+   * For a fraction `a/b`, the function returns `b`.
+   *
+   * The result is always in lowest terms. For example, `den(fraction(8, 6))`
+   * returns `3n` because 8/6 simplifies to 4/3.
+   *
+   * For negative fractions like `-a/b` or `a/-b`, the denominator is
+   * always returned as a positive bigint. The sign is stored in the
+   * numerator. So `den(fraction(-2, 3))` and `den(fraction(2, -3))`
+   * both return `3n`.
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.den(x)
+   *
+   * Examples:
+   *
+   *    math.den(math.fraction(2, 3))   // returns 3n
+   *    math.den(math.fraction(8, 6))   // returns 3n
+   *    math.den(math.fraction('5/8'))  // returns 8n
+   *    math.den(math.fraction(-2, 3))  // returns 3n
+   *    math.den(math.fraction(2, -3))  // returns 3n
+   *    math.den(math.bignumber('0.5'))  // returns 2n
+   *
+   * See also:
+   *
+   *    num, fraction
+   *
+   * History:
+   *
+   *    v15.2.0      Created
+   *
+   * @param {Fraction | BigNumber | Array | Matrix} x
+   *            A fraction, BigNumber, or array with fractions
+   * @return {bigint | Array | Matrix} The denominator of x (in lowest terms)
+   */
+  return typed(name, {
+    Fraction: x => x.d,
+    BigNumber: x => fraction(x).d,
+    'Array | Matrix': typed.referToSelf(self => x => (0, _collection.deepMap)(x, self))
+  });
+});

package/lib/cjs/function/fraction/num.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createNum = void 0;
+var _factory = require("../../utils/factory.js");
+var _collection = require("../../utils/collection.js");
+const name = 'num';
+const dependencies = ['typed', 'fraction'];
+const createNum = exports.createNum = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    fraction
+  } = _ref;
+  /**
+   * Get the numerator of a fraction.
+   * For a fraction `a/b`, the function returns `a`.
+   *
+   * The result is always in lowest terms. For example, `num(fraction(8, 6))`
+   * returns `4n` because 8/6 simplifies to 4/3.
+   *
+   * For negative fractions like `-a/b` or `a/-b`, the sign is always
+   * included in the numerator. Both forms are normalized internally, so
+   * `num(fraction(-2, 3))` and `num(fraction(2, -3))` both return `-2`.
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.num(x)
+   *
+   * Examples:
+   *
+   *    math.num(math.fraction(2, 3))   // returns 2n
+   *    math.num(math.fraction(8, 6))   // returns 4n
+   *    math.num(math.fraction('5/8'))  // returns 5n
+   *    math.num(math.fraction(-2, 3))  // returns -2n
+   *    math.num(math.fraction(2, -3))  // returns -2n
+   *    math.num(math.bignumber('0.5'))  // returns 1n
+   *
+   * See also:
+   *
+   *    den, fraction
+   *
+   * History:
+   *
+   *    v15.2.0      Created
+   *
+   * @param {Fraction | BigNumber | Array | Matrix} x
+   *            A fraction, BigNumber, or array with fractions
+   * @return {bigint | Array | Matrix} The numerator of x (in lowest terms)
+   */
+  return typed(name, {
+    Fraction: x => x.s * x.n,
+    BigNumber: x => {
+      const f = fraction(x);
+      return f.s * f.n;
+    },
+    'Array | Matrix': typed.referToSelf(self => x => (0, _collection.deepMap)(x, self))
+  });
+});

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

@@ -48,6 +48,12 @@ const createMap = exports.createMap = /* #__PURE__ */(0, _factory.factory)(name,
    *    // It can also be called with 2N + 1 arguments: for N arrays
    *    //    callback(value1, value2, index, BroadcastedArray1, BroadcastedArray2)
    *
+   * History:
+   *
+   *    v0.13  Created
+   *    v1.1   Clone the indices on each callback in case callback mutates
+   *    v13.1  Support multiple inputs to the callback
+   *
    * See also:
    *
    *    filter, forEach, sort

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

@@ -77,6 +77,12 @@ const createCompare = exports.createCompare = /* #__PURE__ */(0, _factory.factor
    *
    *    equal, unequal, smaller, smallerEq, larger, largerEq, compareNatural, compareText
    *
+   * History:
+   *
+   *    v0.19  Created
+   *    v4     Changed to compare strings by numerical value
+   *    v13    Change to use separate relative and absolute tolerances
+   *
    * @param  {number | BigNumber | bigint | Fraction | Unit | string | Array | Matrix} x First value to compare
    * @param  {number | BigNumber | bigint | Fraction | Unit | string | Array | Matrix} y Second value to compare
    * @return {number | BigNumber | bigint | Fraction | Array | Matrix} Returns the result of the comparison:

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

@@ -59,7 +59,7 @@ const createCompareNatural = exports.createCompareNatural = /* #__PURE__ */(0, _
    *    math.compareNatural('Answer: 10', 'Answer: 2') // returns 1
    *    math.compareText('Answer: 10', 'Answer: 2')    // returns -1
    *    math.compare('Answer: 10', 'Answer: 2')
-   *        // Error: Cannot convert "Answer: 10" to a number
+   *    // Error: Cannot convert "Answer: 10" to a number
    *
    *    const a = math.unit('5 cm')
    *    const b = math.unit('40 mm')
@@ -80,6 +80,12 @@ const createCompareNatural = exports.createCompareNatural = /* #__PURE__ */(0, _
    *
    *    compare, compareText
    *
+   * History:
+   *
+   *     v15.2   Handle bigints
+   *     v3.14   Created
+   *
+   *
    * @param  {*} x First value to compare
    * @param  {*} y Second value to compare
    * @return {number} Returns the result of the comparison:
@@ -95,7 +101,7 @@ const createCompareNatural = exports.createCompareNatural = /* #__PURE__ */(0, _
     let c;
 
     // numeric types
-    if ((typeX === 'number' || typeX === 'BigNumber' || typeX === 'Fraction') && (typeY === 'number' || typeY === 'BigNumber' || typeY === 'Fraction')) {
+    if ((typeX === 'number' || typeX === 'BigNumber' || typeX === 'Fraction' || typeX === 'bigint') && (typeY === 'number' || typeY === 'BigNumber' || typeY === 'Fraction' || typeY === 'bigint')) {
       c = compare(x, y);
       if (c.toString() !== '0') {
         // c can be number, BigNumber, or Fraction

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

@@ -26,16 +26,21 @@ const createDeepEqual = exports.createDeepEqual = /* #__PURE__ */(0, _factory.fa
    *
    *    math.deepEqual(2, 4)   // returns false
    *
-   *    a = [2, 5, 1]
-   *    b = [2, 7, 1]
+   *    const a = [2, 5, 1]
+   *    const b = [2, 7, 1]
    *
-   *    math.deepEqual(a, b)   // returns false
+   *    math.deepEqual(a, b)   // returns false...
    *    math.equal(a, b)       // returns [true, false, true]
    *
    * See also:
    *
    *    equal, unequal
    *
+   * History:
+   *
+   *    v2     Handle Fractions
+   *    v0.2   Created
+   *
    * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x First matrix to compare
    * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} y Second matrix to compare
    * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix}