mathjs 12.4.3 → 13.0.0

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

@@ -1,13 +1,14 @@
 import { factory } from '../../utils/factory.js';
 import { deepMap } from '../../utils/collection.js';
 import { unaryPlusNumber } from '../../plain/number/index.js';
+import { safeNumberType } from '../../utils/number.js';
 var name = 'unaryPlus';
-var dependencies = ['typed', 'config', 'BigNumber'];
+var dependencies = ['typed', 'config', 'numeric'];
 export var createUnaryPlus = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     config,
-    BigNumber
+    numeric
   } = _ref;
   /**
    * Unary plus operation.
@@ -28,9 +29,9 @@ export var createUnaryPlus = /* #__PURE__ */factory(name, dependencies, _ref =>
    *
    *    unaryMinus, add, subtract
    *
-   * @param  {number | BigNumber | Fraction | string | Complex | Unit | Array | Matrix} x
+   * @param  {number | BigNumber | bigint | Fraction | string | Complex | Unit | Array | Matrix} x
    *            Input value
-   * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix}
+   * @return {number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix}
    *            Returns the input value when numeric, converts to a number when input is non-numeric.
    */
   return typed(name, {
@@ -41,6 +42,9 @@ export var createUnaryPlus = /* #__PURE__ */factory(name, dependencies, _ref =>
     BigNumber: function BigNumber(x) {
       return x; // bignumbers are immutable
     },
+    bigint: function bigint(x) {
+      return x;
+    },
     Fraction: function Fraction(x) {
       return x; // fractions are immutable
     },
@@ -49,9 +53,11 @@ export var createUnaryPlus = /* #__PURE__ */factory(name, dependencies, _ref =>
     },
     // deep map collection, skip zeros since unaryPlus(0) = 0
     'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self, true)),
-    'boolean | string': function booleanString(x) {
-      // convert to a number or bignumber
-      return config.number === 'BigNumber' ? new BigNumber(+x) : +x;
+    boolean: function boolean(x) {
+      return numeric(x ? 1 : 0, config.number);
+    },
+    string: function string(x) {
+      return numeric(x, safeNumberType(x, config));
     }
   });
 });

package/lib/esm/function/bitwise/bitAnd.js

@@ -50,13 +50,14 @@ export var createBitAnd = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    bitNot, bitOr, bitXor, leftShift, rightArithShift, rightLogShift
    *
-   * @param  {number | BigNumber | Array | Matrix} x First value to and
-   * @param  {number | BigNumber | Array | Matrix} y Second value to and
-   * @return {number | BigNumber | Array | Matrix} AND of `x` and `y`
+   * @param  {number | BigNumber | bigint | Array | Matrix} x First value to and
+   * @param  {number | BigNumber | bigint | Array | Matrix} y Second value to and
+   * @return {number | BigNumber | bigint | Array | Matrix} AND of `x` and `y`
    */
   return typed(name, {
     'number, number': bitAndNumber,
-    'BigNumber, BigNumber': bitAndBigNumber
+    'BigNumber, BigNumber': bitAndBigNumber,
+    'bigint, bigint': (x, y) => x & y
   }, matrixAlgorithmSuite({
     SS: matAlgo06xS0S0,
     DS: matAlgo02xDS0,

package/lib/esm/function/bitwise/bitNot.js

@@ -27,12 +27,13 @@ export var createBitNot = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    bitAnd, bitOr, bitXor, leftShift, rightArithShift, rightLogShift
    *
-   * @param  {number | BigNumber | Array | Matrix} x Value to not
-   * @return {number | BigNumber | Array | Matrix} NOT of `x`
+   * @param  {number | BigNumber | bigint | Array | Matrix} x Value to not
+   * @return {number | BigNumber | bigint | Array | Matrix} NOT of `x`
    */
   return typed(name, {
     number: bitNotNumber,
     BigNumber: bitNotBigNumber,
+    bigint: x => ~x,
     'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });

package/lib/esm/function/bitwise/bitOr.js

@@ -51,13 +51,14 @@ export var createBitOr = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    bitAnd, bitNot, bitXor, leftShift, rightArithShift, rightLogShift
    *
-   * @param  {number | BigNumber | Array | Matrix} x First value to or
-   * @param  {number | BigNumber | Array | Matrix} y Second value to or
-   * @return {number | BigNumber | Array | Matrix} OR of `x` and `y`
+   * @param  {number | BigNumber | bigint | Array | Matrix} x First value to or
+   * @param  {number | BigNumber | bigint | Array | Matrix} y Second value to or
+   * @return {number | BigNumber | bigint | Array | Matrix} OR of `x` and `y`
    */
   return typed(name, {
     'number, number': bitOrNumber,
-    'BigNumber, BigNumber': bitOrBigNumber
+    'BigNumber, BigNumber': bitOrBigNumber,
+    'bigint, bigint': (x, y) => x | y
   }, matrixAlgorithmSuite({
     SS: matAlgo04xSidSid,
     DS: matAlgo01xDSid,

package/lib/esm/function/bitwise/bitXor.js

@@ -49,13 +49,14 @@ export var createBitXor = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    bitAnd, bitNot, bitOr, leftShift, rightArithShift, rightLogShift
    *
-   * @param  {number | BigNumber | Array | Matrix} x First value to xor
-   * @param  {number | BigNumber | Array | Matrix} y Second value to xor
-   * @return {number | BigNumber | Array | Matrix} XOR of `x` and `y`
+   * @param  {number | BigNumber | bigint | Array | Matrix} x First value to xor
+   * @param  {number | BigNumber | bigint | Array | Matrix} y Second value to xor
+   * @return {number | BigNumber | bigint | Array | Matrix} XOR of `x` and `y`
    */
   return typed(name, {
     'number, number': bitXorNumber,
-    'BigNumber, BigNumber': bigBitXor
+    'BigNumber, BigNumber': bigBitXor,
+    'bigint, bigint': (x, y) => x ^ y
   }, matrixAlgorithmSuite({
     SS: matAlgo07xSSf,
     DS: matAlgo03xDSf,

package/lib/esm/function/bitwise/leftShift.js

@@ -71,13 +71,14 @@ export var createLeftShift = /* #__PURE__ */factory(name, dependencies, _ref =>
    *
    *    leftShift, bitNot, bitOr, bitXor, rightArithShift, rightLogShift
    *
-   * @param  {number | BigNumber | Array | Matrix} x Value to be shifted
-   * @param  {number | BigNumber} y Amount of shifts
-   * @return {number | BigNumber | Array | Matrix} `x` shifted left `y` times
+   * @param  {number | BigNumber | bigint | Array | Matrix} x Value to be shifted
+   * @param  {number | BigNumber | bigint} y Amount of shifts
+   * @return {number | BigNumber | bigint | Array | Matrix} `x` shifted left `y` times
    */
   return typed(name, {
     'number, number': leftShiftNumber,
     'BigNumber, BigNumber': leftShiftBigNumber,
+    'bigint, bigint': (x, y) => x << y,
     'SparseMatrix, number | BigNumber': typed.referToSelf(self => (x, y) => {
       // check scalar
       if (equalScalar(y, 0)) {

package/lib/esm/function/bitwise/rightArithShift.js

@@ -71,13 +71,14 @@ export var createRightArithShift = /* #__PURE__ */factory(name, dependencies, _r
    *
    *    bitAnd, bitNot, bitOr, bitXor, rightArithShift, rightLogShift
    *
-   * @param  {number | BigNumber | Array | Matrix} x Value to be shifted
-   * @param  {number | BigNumber} y Amount of shifts
-   * @return {number | BigNumber | Array | Matrix} `x` zero-filled shifted right `y` times
+   * @param  {number | BigNumber | bigint | Array | Matrix} x Value to be shifted
+   * @param  {number | BigNumber | bigint} y Amount of shifts
+   * @return {number | BigNumber | bigint | Array | Matrix} `x` zero-filled shifted right `y` times
    */
   return typed(name, {
     'number, number': rightArithShiftNumber,
     'BigNumber, BigNumber': rightArithShiftBigNumber,
+    'bigint, bigint': (x, y) => x >> y,
     'SparseMatrix, number | BigNumber': typed.referToSelf(self => (x, y) => {
       // check scalar
       if (equalScalar(y, 0)) {

package/lib/esm/function/geometry/intersect.js

@@ -139,7 +139,7 @@ export var createIntersect = /* #__PURE__ */factory(name, dependencies, _ref =>
     var d2 = subtract(o2, p2b);
     var det = subtract(multiplyScalar(d1[0], d2[1]), multiplyScalar(d2[0], d1[1]));
     if (isZero(det)) return null;
-    if (smaller(abs(det), config.epsilon)) {
+    if (smaller(abs(det), config.relTol)) {
       return null;
     }
     var d20o11 = multiplyScalar(d2[0], o1[1]);

package/lib/esm/function/logical/and.js

@@ -60,8 +60,8 @@ export var createAnd = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    not, or, xor
    *
-   * @param  {number | BigNumber | Complex | Unit | Array | Matrix} x First value to check
-   * @param  {number | BigNumber | Complex | Unit | Array | Matrix} y Second value to check
+   * @param  {number | BigNumber | bigint | Complex | Unit | Array | Matrix} x First value to check
+   * @param  {number | BigNumber | bigint | Complex | Unit | Array | Matrix} y Second value to check
    * @return {boolean | Array | Matrix}
    *            Returns true when both inputs are defined with a nonzero/nonempty value.
    */
@@ -73,6 +73,7 @@ export var createAnd = /* #__PURE__ */factory(name, dependencies, _ref => {
     'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
       return !x.isZero() && !y.isZero() && !x.isNaN() && !y.isNaN();
     },
+    'bigint, bigint': andNumber,
     'Unit, Unit': typed.referToSelf(self => (x, y) => self(x.value || 0, y.value || 0)),
     'SparseMatrix, any': typed.referToSelf(self => (x, y) => {
       // check scalar

package/lib/esm/function/logical/not.js

@@ -28,7 +28,7 @@ export var createNot = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    and, or, xor
    *
-   * @param  {number | BigNumber | Complex | Unit | Array | Matrix} x First value to check
+   * @param  {number | BigNumber | bigint | Complex | Unit | Array | Matrix} x First value to check
    * @return {boolean | Array | Matrix}
    *            Returns true when input is a zero or empty value.
    */
@@ -41,6 +41,7 @@ export var createNot = /* #__PURE__ */factory(name, dependencies, _ref => {
     BigNumber: function BigNumber(x) {
       return x.isZero() || x.isNaN();
     },
+    bigint: x => !x,
     Unit: typed.referToSelf(self => x => typed.find(self, x.valueType())(x.value)),
     'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });

package/lib/esm/function/logical/or.js

@@ -54,8 +54,8 @@ export var createOr = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    and, not, xor
    *
-   * @param  {number | BigNumber | Complex | Unit | Array | Matrix} x First value to check
-   * @param  {number | BigNumber | Complex | Unit | Array | Matrix} y Second value to check
+   * @param  {number | BigNumber | bigint | Complex | Unit | Array | Matrix} x First value to check
+   * @param  {number | BigNumber | bigint | Complex | Unit | Array | Matrix} y Second value to check
    * @return {boolean | Array | Matrix}
    *            Returns true when one of the inputs is defined with a nonzero/nonempty value.
    */
@@ -67,6 +67,7 @@ export var createOr = /* #__PURE__ */factory(name, dependencies, _ref => {
     'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
       return !x.isZero() && !x.isNaN() || !y.isZero() && !y.isNaN();
     },
+    'bigint, bigint': orNumber,
     'Unit, Unit': typed.referToSelf(self => (x, y) => self(x.value || 0, y.value || 0))
   }, matrixAlgorithmSuite({
     SS: matAlgo05xSfSf,

package/lib/esm/function/logical/xor.js

@@ -53,8 +53,8 @@ export var createXor = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    and, not, or
    *
-   * @param  {number | BigNumber | Complex | Unit | Array | Matrix} x First value to check
-   * @param  {number | BigNumber | Complex | Unit | Array | Matrix} y Second value to check
+   * @param  {number | BigNumber | bigint | Complex | Unit | Array | Matrix} x First value to check
+   * @param  {number | BigNumber | bigint | Complex | Unit | Array | Matrix} y Second value to check
    * @return {boolean | Array | Matrix}
    *            Returns true when one and only one input is defined with a nonzero/nonempty value.
    */
@@ -63,6 +63,7 @@ export var createXor = /* #__PURE__ */factory(name, dependencies, _ref => {
     'Complex, Complex': function ComplexComplex(x, y) {
       return (x.re !== 0 || x.im !== 0) !== (y.re !== 0 || y.im !== 0);
     },
+    'bigint, bigint': xorNumber,
     'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
       return (!x.isZero() && !x.isNaN()) !== (!y.isZero() && !y.isNaN());
     },

package/lib/esm/function/matrix/eigs/realSymmetric.js

@@ -21,7 +21,7 @@ export function createRealSymmetric(_ref) {
    * @param {'number' | 'BigNumber'} type
    */
   function main(arr, N) {
-    var prec = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : config.epsilon;
+    var prec = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : config.relTol;
     var type = arguments.length > 3 ? arguments[3] : undefined;
     var computeVectors = arguments.length > 4 ? arguments[4] : undefined;
     if (type === 'number') {
@@ -99,7 +99,7 @@ export function createRealSymmetric(_ref) {
   // get angle
   function getTheta(aii, ajj, aij) {
     var denom = ajj - aii;
-    if (Math.abs(denom) <= config.epsilon) {
+    if (Math.abs(denom) <= config.relTol) {
       return Math.PI / 4.0;
     } else {
       return 0.5 * Math.atan(2.0 * aij / (ajj - aii));
@@ -109,7 +109,7 @@ export function createRealSymmetric(_ref) {
   // get angle
   function getThetaBig(aii, ajj, aij) {
     var denom = subtract(ajj, aii);
-    if (abs(denom) <= config.epsilon) {
+    if (abs(denom) <= config.relTol) {
       return bignumber(-1).acos().div(4);
     } else {
       return multiplyScalar(0.5, atan(multiply(2.0, aij, inv(denom))));

package/lib/esm/function/matrix/eigs.js

@@ -144,7 +144,7 @@ export var createEigs = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * @param {Array | Matrix} x  Matrix to be diagonalized
    *
-   * @param {number | BigNumber | OptsObject} [opts] Object with keys `precision`, defaulting to config.epsilon, and `eigenvectors`, defaulting to true and specifying whether to compute eigenvectors. If just a number, specifies precision.
+   * @param {number | BigNumber | OptsObject} [opts] Object with keys `precision`, defaulting to config.relTol, and `eigenvectors`, defaulting to true and specifying whether to compute eigenvectors. If just a number, specifies precision.
    * @return {{values: Array|Matrix, eigenvectors?: Array<EVobj>}} Object containing an array of eigenvalues and an array of {value: number|BigNumber, vector: Array|Matrix} objects. The eigenvectors property is undefined if eigenvectors were not requested.
    *
    */
@@ -189,7 +189,7 @@ export var createEigs = /* #__PURE__ */factory(name, dependencies, _ref => {
     var _opts$precision;
     var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     var computeVectors = 'eigenvectors' in opts ? opts.eigenvectors : true;
-    var prec = (_opts$precision = opts.precision) !== null && _opts$precision !== void 0 ? _opts$precision : config.epsilon;
+    var prec = (_opts$precision = opts.precision) !== null && _opts$precision !== void 0 ? _opts$precision : config.relTol;
     var result = computeValuesAndVectors(mat, prec, computeVectors);
     if (opts.matricize) {
       result.values = matrix(result.values);

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

@@ -43,7 +43,7 @@ export var createCompare = /* #__PURE__ */factory(name, dependencies, _ref => {
    * Compare two values. Returns 1 when x > y, -1 when x < y, and 0 when x == y.
    *
    * x and y are considered equal when the relative difference between x and y
-   * is smaller than the configured epsilon. The function cannot be used to
+   * is smaller than the configured absTol and relTol. The function cannot be used to
    * compare values smaller than approximately 2.22e-16.
    *
    * For matrices, the function is evaluated element wise.
@@ -71,9 +71,9 @@ export var createCompare = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    equal, unequal, smaller, smallerEq, larger, largerEq, compareNatural, compareText
    *
-   * @param  {number | BigNumber | Fraction | Unit | string | Array | Matrix} x First value to compare
-   * @param  {number | BigNumber | Fraction | Unit | string | Array | Matrix} y Second value to compare
-   * @return {number | BigNumber | Fraction | Array | Matrix} Returns the result of the comparison:
+   * @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:
    *                                                          1 when x > y, -1 when x < y, and 0 when x == y.
    */
   return typed(name, createCompareNumber({
@@ -84,7 +84,10 @@ export var createCompare = /* #__PURE__ */factory(name, dependencies, _ref => {
       return x === y ? 0 : x > y ? 1 : -1;
     },
     'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
-      return bigNearlyEqual(x, y, config.epsilon) ? new BigNumber(0) : new BigNumber(x.cmp(y));
+      return bigNearlyEqual(x, y, config.relTol, config.absTol) ? new BigNumber(0) : new BigNumber(x.cmp(y));
+    },
+    'bigint, bigint': function bigintBigint(x, y) {
+      return x === y ? 0n : x > y ? 1n : -1n;
     },
     'Fraction, Fraction': function FractionFraction(x, y) {
       return new Fraction(x.compare(y));
@@ -105,7 +108,7 @@ export var createCompareNumber = /* #__PURE__ */factory(name, ['typed', 'config'
   } = _ref2;
   return typed(name, {
     'number, number': function numberNumber(x, y) {
-      return nearlyEqual(x, y, config.epsilon) ? 0 : x > y ? 1 : -1;
+      return nearlyEqual(x, y, config.relTol, config.absTol) ? 0 : x > y ? 1 : -1;
     }
   });
 });

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

@@ -18,7 +18,7 @@ export var createCompareNatural = /* #__PURE__ */factory(name, dependencies, _re
    * the function compares in a natural way.
    *
    * For numeric values, x and y are considered equal when the relative
-   * difference between x and y is smaller than the configured epsilon.
+   * difference between x and y is smaller than the configured relTol and absTol.
    * The function cannot be used to compare values smaller than
    * approximately 2.22e-16.
    *

package/lib/esm/function/relational/equal.js

@@ -34,7 +34,7 @@ export var createEqual = /* #__PURE__ */factory(name, dependencies, _ref => {
    * Test whether two values are equal.
    *
    * The function tests whether the relative difference between x and y is
-   * smaller than the configured epsilon. The function cannot be used to
+   * smaller than the configured relTol and absTol. The function cannot be used to
    * compare values smaller than approximately 2.22e-16.
    *
    * For matrices, the function is evaluated element wise.
@@ -70,8 +70,8 @@ export var createEqual = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    unequal, smaller, smallerEq, larger, largerEq, compare, deepEqual, equalText
    *
-   * @param  {number | BigNumber | boolean | Complex | Unit | string | Array | Matrix} x First value to compare
-   * @param  {number | BigNumber | boolean | Complex | Unit | string | Array | Matrix} y Second value to compare
+   * @param  {number | BigNumber | bigint | boolean | Complex | Unit | string | Array | Matrix} x First value to compare
+   * @param  {number | BigNumber | bigint | boolean | Complex | Unit | string | Array | Matrix} y Second value to compare
    * @return {boolean | Array | Matrix} Returns true when the compared values are equal, else returns false
    */
   return typed(name, createEqualNumber({

package/lib/esm/function/relational/equalScalar.js

@@ -17,8 +17,8 @@ export var createEqualScalar = /* #__PURE__ */factory(name, dependencies, _ref =
   /**
    * Test whether two scalar values are nearly equal.
    *
-   * @param  {number | BigNumber | Fraction | boolean | Complex | Unit} x   First value to compare
-   * @param  {number | BigNumber | Fraction | boolean | Complex} y          Second value to compare
+   * @param  {number | BigNumber | bigint | Fraction | boolean | Complex | Unit} x   First value to compare
+   * @param  {number | BigNumber | bigint | Fraction | boolean | Complex} y          Second value to compare
    * @return {boolean}                                                  Returns true when the compared values are equal, else returns false
    * @private
    */
@@ -27,16 +27,19 @@ export var createEqualScalar = /* #__PURE__ */factory(name, dependencies, _ref =
       return x === y;
     },
     'number, number': function numberNumber(x, y) {
-      return nearlyEqual(x, y, config.epsilon);
+      return nearlyEqual(x, y, config.relTol, config.absTol);
     },
     'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
-      return x.eq(y) || bigNearlyEqual(x, y, config.epsilon);
+      return x.eq(y) || bigNearlyEqual(x, y, config.relTol, config.absTol);
+    },
+    'bigint, bigint': function bigintBigint(x, y) {
+      return x === y;
     },
     'Fraction, Fraction': function FractionFraction(x, y) {
       return x.equals(y);
     },
     'Complex, Complex': function ComplexComplex(x, y) {
-      return complexEquals(x, y, config.epsilon);
+      return complexEquals(x, y, config.relTol, config.absTol);
     }
   }, compareUnits);
 });
@@ -47,7 +50,7 @@ export var createEqualScalarNumber = factory(name, ['typed', 'config'], _ref2 =>
   } = _ref2;
   return typed(name, {
     'number, number': function numberNumber(x, y) {
-      return nearlyEqual(x, y, config.epsilon);
+      return nearlyEqual(x, y, config.relTol, config.absTol);
     }
   });
 });

package/lib/esm/function/relational/larger.js

@@ -40,7 +40,7 @@ export var createLarger = /* #__PURE__ */factory(name, dependencies, _ref => {
    * Test whether value x is larger than y.
    *
    * The function returns true when x is larger than y and the relative
-   * difference between x and y is larger than the configured epsilon. The
+   * difference between x and y is larger than the configured relTol and absTol. The
    * function cannot be used to compare values smaller than approximately 2.22e-16.
    *
    * For matrices, the function is evaluated element wise.
@@ -63,8 +63,8 @@ export var createLarger = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    equal, unequal, smaller, smallerEq, largerEq, compare
    *
-   * @param  {number | BigNumber | Fraction | boolean | Unit | string | Array | Matrix} x First value to compare
-   * @param  {number | BigNumber | Fraction | boolean | Unit | string | Array | Matrix} y Second value to compare
+   * @param  {number | BigNumber | bigint | Fraction | boolean | Unit | string | Array | Matrix} x First value to compare
+   * @param  {number | BigNumber | bigint | Fraction | boolean | Unit | string | Array | Matrix} y Second value to compare
    * @return {boolean | Array | Matrix} Returns true when the x is larger than y, else returns false
    */
   return typed(name, createLargerNumber({
@@ -73,8 +73,9 @@ export var createLarger = /* #__PURE__ */factory(name, dependencies, _ref => {
   }), {
     'boolean, boolean': (x, y) => x > y,
     'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
-      return x.gt(y) && !bigNearlyEqual(x, y, config.epsilon);
+      return x.gt(y) && !bigNearlyEqual(x, y, config.relTol, config.absTol);
     },
+    'bigint, bigint': (x, y) => x > y,
     'Fraction, Fraction': (x, y) => x.compare(y) === 1,
     'Complex, Complex': function ComplexComplex() {
       throw new TypeError('No ordering relation is defined for complex numbers');
@@ -92,7 +93,7 @@ export var createLargerNumber = /* #__PURE__ */factory(name, ['typed', 'config']
   } = _ref2;
   return typed(name, {
     'number, number': function numberNumber(x, y) {
-      return x > y && !nearlyEqual(x, y, config.epsilon);
+      return x > y && !nearlyEqual(x, y, config.relTol, config.absTol);
     }
   });
 });

package/lib/esm/function/relational/largerEq.js

@@ -40,7 +40,7 @@ export var createLargerEq = /* #__PURE__ */factory(name, dependencies, _ref => {
    * Test whether value x is larger or equal to y.
    *
    * The function returns true when x is larger than y or the relative
-   * difference between x and y is smaller than the configured epsilon. The
+   * difference between x and y is smaller than the configured relTol and absTol. The
    * function cannot be used to compare values smaller than approximately 2.22e-16.
    *
    * For matrices, the function is evaluated element wise.
@@ -59,8 +59,8 @@ export var createLargerEq = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    equal, unequal, smaller, smallerEq, larger, compare
    *
-   * @param  {number | BigNumber | Fraction | boolean | Unit | string | Array | Matrix} x First value to compare
-   * @param  {number | BigNumber | Fraction | boolean | Unit | string | Array | Matrix} y Second value to compare
+   * @param  {number | BigNumber | bigint | Fraction | boolean | Unit | string | Array | Matrix} x First value to compare
+   * @param  {number | BigNumber | bigint | Fraction | boolean | Unit | string | Array | Matrix} y Second value to compare
    * @return {boolean | Array | Matrix} Returns true when the x is larger or equal to y, else returns false
    */
   return typed(name, createLargerEqNumber({
@@ -69,7 +69,10 @@ export var createLargerEq = /* #__PURE__ */factory(name, dependencies, _ref => {
   }), {
     'boolean, boolean': (x, y) => x >= y,
     'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
-      return x.gte(y) || bigNearlyEqual(x, y, config.epsilon);
+      return x.gte(y) || bigNearlyEqual(x, y, config.relTol, config.absTol);
+    },
+    'bigint, bigint': function bigintBigint(x, y) {
+      return x >= y;
     },
     'Fraction, Fraction': (x, y) => x.compare(y) !== -1,
     'Complex, Complex': function ComplexComplex() {
@@ -88,7 +91,7 @@ export var createLargerEqNumber = /* #__PURE__ */factory(name, ['typed', 'config
   } = _ref2;
   return typed(name, {
     'number, number': function numberNumber(x, y) {
-      return x >= y || nearlyEqual(x, y, config.epsilon);
+      return x >= y || nearlyEqual(x, y, config.relTol, config.absTol);
     }
   });
 });

package/lib/esm/function/relational/smaller.js

@@ -40,7 +40,7 @@ export var createSmaller = /* #__PURE__ */factory(name, dependencies, _ref => {
    * Test whether value x is smaller than y.
    *
    * The function returns true when x is smaller than y and the relative
-   * difference between x and y is smaller than the configured epsilon. The
+   * difference between x and y is smaller than the configured relTol and absTol. The
    * function cannot be used to compare values smaller than approximately 2.22e-16.
    *
    * For matrices, the function is evaluated element wise.
@@ -63,8 +63,8 @@ export var createSmaller = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    equal, unequal, smallerEq, smaller, smallerEq, compare
    *
-   * @param  {number | BigNumber | Fraction | boolean | Unit | string | Array | Matrix} x First value to compare
-   * @param  {number | BigNumber | Fraction | boolean | Unit | string | Array | Matrix} y Second value to compare
+   * @param  {number | BigNumber | bigint | Fraction | boolean | Unit | string | Array | Matrix} x First value to compare
+   * @param  {number | BigNumber | bigint | Fraction | boolean | Unit | string | Array | Matrix} y Second value to compare
    * @return {boolean | Array | Matrix} Returns true when the x is smaller than y, else returns false
    */
   return typed(name, createSmallerNumber({
@@ -73,8 +73,9 @@ export var createSmaller = /* #__PURE__ */factory(name, dependencies, _ref => {
   }), {
     'boolean, boolean': (x, y) => x < y,
     'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
-      return x.lt(y) && !bigNearlyEqual(x, y, config.epsilon);
+      return x.lt(y) && !bigNearlyEqual(x, y, config.relTol, config.absTol);
     },
+    'bigint, bigint': (x, y) => x < y,
     'Fraction, Fraction': (x, y) => x.compare(y) === -1,
     'Complex, Complex': function ComplexComplex(x, y) {
       throw new TypeError('No ordering relation is defined for complex numbers');
@@ -92,7 +93,7 @@ export var createSmallerNumber = /* #__PURE__ */factory(name, ['typed', 'config'
   } = _ref2;
   return typed(name, {
     'number, number': function numberNumber(x, y) {
-      return x < y && !nearlyEqual(x, y, config.epsilon);
+      return x < y && !nearlyEqual(x, y, config.relTol, config.absTol);
     }
   });
 });

package/lib/esm/function/relational/smallerEq.js

@@ -40,7 +40,7 @@ export var createSmallerEq = /* #__PURE__ */factory(name, dependencies, _ref =>
    * Test whether value x is smaller or equal to y.
    *
    * The function returns true when x is smaller than y or the relative
-   * difference between x and y is smaller than the configured epsilon. The
+   * difference between x and y is smaller than the configured relTol and absTol. The
    * function cannot be used to compare values smaller than approximately 2.22e-16.
    *
    * For matrices, the function is evaluated element wise.
@@ -59,8 +59,8 @@ export var createSmallerEq = /* #__PURE__ */factory(name, dependencies, _ref =>
    *
    *    equal, unequal, smaller, larger, largerEq, compare
    *
-   * @param  {number | BigNumber | Fraction | boolean | Unit | string | Array | Matrix} x First value to compare
-   * @param  {number | BigNumber | Fraction | boolean | Unit | string | Array | Matrix} y Second value to compare
+   * @param  {number | BigNumber | bigint | Fraction | boolean | Unit | string | Array | Matrix} x First value to compare
+   * @param  {number | BigNumber | bigint | Fraction | boolean | Unit | string | Array | Matrix} y Second value to compare
    * @return {boolean | Array | Matrix} Returns true when the x is smaller than y, else returns false
    */
   return typed(name, createSmallerEqNumber({
@@ -69,8 +69,9 @@ export var createSmallerEq = /* #__PURE__ */factory(name, dependencies, _ref =>
   }), {
     'boolean, boolean': (x, y) => x <= y,
     'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
-      return x.lte(y) || bigNearlyEqual(x, y, config.epsilon);
+      return x.lte(y) || bigNearlyEqual(x, y, config.relTol, config.absTol);
     },
+    'bigint, bigint': (x, y) => x <= y,
     'Fraction, Fraction': (x, y) => x.compare(y) !== 1,
     'Complex, Complex': function ComplexComplex() {
       throw new TypeError('No ordering relation is defined for complex numbers');
@@ -88,7 +89,7 @@ export var createSmallerEqNumber = /* #__PURE__ */factory(name, ['typed', 'confi
   } = _ref2;
   return typed(name, {
     'number, number': function numberNumber(x, y) {
-      return x <= y || nearlyEqual(x, y, config.epsilon);
+      return x <= y || nearlyEqual(x, y, config.relTol, config.absTol);
     }
   });
 });

package/lib/esm/function/relational/unequal.js

@@ -35,7 +35,7 @@ export var createUnequal = /* #__PURE__ */factory(name, dependencies, _ref => {
    * Test whether two values are unequal.
    *
    * The function tests whether the relative difference between x and y is
-   * larger than the configured epsilon. The function cannot be used to compare
+   * larger than the configured relTol and absTol. The function cannot be used to compare
    * values smaller than approximately 2.22e-16.
    *
    * For matrices, the function is evaluated element wise.

package/lib/esm/function/special/zeta.js

@@ -50,8 +50,8 @@ export var createZeta = /* #__PURE__ */factory(name, dependencies, _ref => {
   return typed(name, {
     number: s => zetaNumeric(s, value => value, () => 20),
     BigNumber: s => zetaNumeric(s, value => new _BigNumber(value), () => {
-      // epsilon is for example 1e-12. Extract the positive exponent 12 from that
-      return Math.abs(Math.log10(config.epsilon));
+      // relTol is for example 1e-12. Extract the positive exponent 12 from that
+      return Math.abs(Math.log10(config.relTol));
     }),
     Complex: zetaComplex
   });

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

@@ -1,5 +1,6 @@
 import { deepForEach, reduce, containsCollections } from '../../utils/collection.js';
 import { factory } from '../../utils/factory.js';
+import { safeNumberType } from '../../utils/number.js';
 import { improveErrorMessage } from './utils/improveErrorMessage.js';
 var name = 'max';
 var dependencies = ['typed', 'config', 'numeric', 'larger'];
@@ -97,7 +98,7 @@ export var createMax = /* #__PURE__ */factory(name, dependencies, _ref => {
 
     // make sure returning numeric value: parse a string into a numeric value
     if (typeof res === 'string') {
-      res = numeric(res, config.number);
+      res = numeric(res, safeNumberType(res, config));
     }
     return res;
   }

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

@@ -1,5 +1,6 @@
 import { containsCollections, deepForEach, reduce } from '../../utils/collection.js';
 import { factory } from '../../utils/factory.js';
+import { safeNumberType } from '../../utils/number.js';
 import { improveErrorMessage } from './utils/improveErrorMessage.js';
 var name = 'min';
 var dependencies = ['typed', 'config', 'numeric', 'smaller'];
@@ -97,7 +98,7 @@ export var createMin = /* #__PURE__ */factory(name, dependencies, _ref => {
 
     // make sure returning numeric value: parse a string into a numeric value
     if (typeof min === 'string') {
-      min = numeric(min, config.number);
+      min = numeric(min, safeNumberType(min, config));
     }
     return min;
   }