mathjs 12.4.2 → 13.0.0

package/lib/esm/entry/pureFunctionsNumber.generated.js

@@ -5,7 +5,7 @@
 import { config } from './configReadonly.js';
 import { createE, createFalse, createIndex, createInfinity, createLN10, createLOG10E, createMatrix, createNaN, createNull, createPhi, createRangeClass, createReplacer, createResultSet, createSQRT1_2,
 // eslint-disable-line camelcase
-createSubset, createTau, createTyped, createUnaryPlus, createVersion, createXor, createAbs, createAcos, createAcot, createAcsc, createAdd, createAnd, createAsec, createAsin, createAtan, createAtanh, createBitAnd, createBitOr, createBoolean, createCbrt, createCombinations, createCompare, createCompareText, createCos, createCot, createCsc, createCube, createDivide, createEqualScalar, createErf, createExp, createFilter, createForEach, createFormat, createGamma, createIsInteger, createIsNegative, createIsPositive, createIsZero, createLOG2E, createLargerEq, createLeftShift, createLog, createLog1p, createMap, createMean, createMod, createMultiply, createNot, createNumber, createOr, createPi, createPow, createRandom, createRightLogShift, createSQRT2, createSech, createSin, createSize, createSmallerEq, createSquare, createString, createSubtract, createTanh, createTypeOf, createUnequal, createXgcd, createAcoth, createAddScalar, createAsech, createBitNot, createCombinationsWithRep, createCosh, createCsch, createDivideScalar, createEqualText, createExpm1, createIsNumeric, createLN2, createLcm, createLog10, createMultiplyScalar, createNthRoot, createPickRandom, createRandomInt, createRightArithShift, createSec, createSinh, createSqrt, createTan, createUnaryMinus, createAcosh, createApply, createAsinh, createBitXor, createClone, createCoth, createEqual, createFactorial, createHasNumericValue, createIsNaN, createLarger, createLog2, createMode, createNorm, createPartitionSelect, createPrint, createRound, createSmaller, createSubtractScalar, createTrue, createVariance, createZeta, createAcsch, createAtan2, createCatalan, createCompareNatural, createComposition, createCumSum, createFloor, createHypot, createLgamma, createMedian, createMultinomial, createPermutations, createQuantileSeq, createSign, createStd, createStirlingS2, createCeil, createDeepEqual, createFix, createIsPrime, createNumeric, createProd, createBellNumbers, createGcd, createMad, createRange, createSum, createCorr, createMax, createMin } from '../factoriesNumber.js';
+createSubset, createTau, createTyped, createUnaryPlus, createVersion, createXor, createAbs, createAcos, createAcot, createAcsc, createAdd, createAnd, createAsec, createAsin, createAtan, createAtanh, createBigint, createBitNot, createBitXor, createBoolean, createCbrt, createCombinations, createCompare, createCompareText, createCos, createCot, createCsc, createCube, createDivide, createEqualScalar, createErf, createExp, createFilter, createForEach, createFormat, createGamma, createIsInteger, createIsNegative, createIsPositive, createIsZero, createLOG2E, createLargerEq, createLeftShift, createLog, createLog1p, createMap, createMean, createMod, createMultiply, createNot, createNumber, createOr, createPi, createPow, createRandom, createRightLogShift, createSQRT2, createSech, createSin, createSize, createSmallerEq, createSquare, createString, createSubtract, createTanh, createTypeOf, createUnequal, createXgcd, createAcoth, createAddScalar, createAsech, createBitAnd, createCombinationsWithRep, createCosh, createCsch, createDivideScalar, createEqualText, createExpm1, createIsNumeric, createLN2, createLcm, createLog10, createMultiplyScalar, createNthRoot, createPickRandom, createRandomInt, createRightArithShift, createSec, createSinh, createSqrt, createTan, createUnaryMinus, createAcosh, createApply, createAsinh, createBitOr, createClone, createCoth, createEqual, createFactorial, createHasNumericValue, createIsNaN, createLarger, createLog2, createMode, createNorm, createPartitionSelect, createPrint, createRound, createSmaller, createSubtractScalar, createTrue, createVariance, createZeta, createAcsch, createAtan2, createCatalan, createCompareNatural, createComposition, createCumSum, createFloor, createHypot, createLgamma, createMedian, createMultinomial, createPermutations, createQuantileSeq, createSign, createStd, createStirlingS2, createCeil, createDeepEqual, createFix, createIsPrime, createNumeric, createProd, createBellNumbers, createGcd, createMad, createRange, createSum, createCorr, createMax, createMin } from '../factoriesNumber.js';
 export var e = /* #__PURE__ */createE({
   config
 });
@@ -76,10 +76,13 @@ export var atan = /* #__PURE__ */createAtan({
 export var atanh = /* #__PURE__ */createAtanh({
   typed
 });
-export var bitAnd = /* #__PURE__ */createBitAnd({
+export var bigint = /* #__PURE__ */createBigint({
   typed
 });
-export var bitOr = /* #__PURE__ */createBitOr({
+export var bitNot = /* #__PURE__ */createBitNot({
+  typed
+});
+export var bitXor = /* #__PURE__ */createBitXor({
   typed
 });
 export var boolean = /* #__PURE__ */createBoolean({
@@ -248,7 +251,7 @@ export var addScalar = /* #__PURE__ */createAddScalar({
 export var asech = /* #__PURE__ */createAsech({
   typed
 });
-export var bitNot = /* #__PURE__ */createBitNot({
+export var bitAnd = /* #__PURE__ */createBitAnd({
   typed
 });
 export var combinationsWithRep = /* #__PURE__ */createCombinationsWithRep({
@@ -325,7 +328,7 @@ export var apply = /* #__PURE__ */createApply({
 export var asinh = /* #__PURE__ */createAsinh({
   typed
 });
-export var bitXor = /* #__PURE__ */createBitXor({
+export var bitOr = /* #__PURE__ */createBitOr({
   typed
 });
 export var clone = /* #__PURE__ */createClone({

package/lib/esm/entry/typeChecks.js

@@ -1,2 +1,2 @@
 // util functions
-export { isAccessorNode, isArray, isArrayNode, isAssignmentNode, isBigNumber, isBlockNode, isBoolean, isChain, isCollection, isComplex, isConditionalNode, isConstantNode, isDate, isDenseMatrix, isFraction, isFunction, isFunctionAssignmentNode, isFunctionNode, isHelp, isIndex, isIndexNode, isMatrix, isNode, isNull, isNumber, isString, isUndefined, isObject, isObjectNode, isOperatorNode, isParenthesisNode, isRange, isRangeNode, isRelationalNode, isRegExp, isResultSet, isSparseMatrix, isSymbolNode, isUnit } from '../utils/is.js';
+export { isAccessorNode, isArray, isArrayNode, isAssignmentNode, isBigNumber, isBigInt, isBlockNode, isBoolean, isChain, isCollection, isComplex, isConditionalNode, isConstantNode, isDate, isDenseMatrix, isFraction, isFunction, isFunctionAssignmentNode, isFunctionNode, isHelp, isIndex, isIndexNode, isMatrix, isNode, isNull, isNumber, isString, isUndefined, isObject, isObjectNode, isOperatorNode, isParenthesisNode, isRange, isRangeNode, isRelationalNode, isRegExp, isResultSet, isSparseMatrix, isSymbolNode, isUnit } from '../utils/is.js';

package/lib/esm/expression/embeddedDocs/construction/bigint.js

@@ -0,0 +1,8 @@
+export var bigintDocs = {
+  name: 'bigint',
+  category: 'Construction',
+  syntax: ['bigint(x)'],
+  description: 'Create a bigint, an integer with an arbitrary number of digits, from a number or string.',
+  examples: ['123123123123123123 # a large number will lose digits', 'bigint("123123123123123123")', 'bignumber(["1", "3", "5"])'],
+  seealso: ['boolean', 'bignumber', 'number', 'complex', 'fraction', 'index', 'matrix', 'string', 'unit']
+};

package/lib/esm/expression/embeddedDocs/construction/bignumber.js

@@ -4,5 +4,5 @@ export var bignumberDocs = {
   syntax: ['bignumber(x)'],
   description: 'Create a big number from a number or string.',
   examples: ['0.1 + 0.2', 'bignumber(0.1) + bignumber(0.2)', 'bignumber("7.2")', 'bignumber("7.2e500")', 'bignumber([0.1, 0.2, 0.3])'],
-  seealso: ['boolean', 'complex', 'fraction', 'index', 'matrix', 'string', 'unit']
+  seealso: ['boolean', 'bigint', 'complex', 'fraction', 'index', 'matrix', 'string', 'unit']
 };

package/lib/esm/expression/embeddedDocs/construction/number.js

@@ -4,5 +4,5 @@ export var numberDocs = {
   syntax: ['x', 'number(x)', 'number(unit, valuelessUnit)'],
   description: 'Create a number or convert a string or boolean into a number.',
   examples: ['2', '2e3', '4.05', 'number(2)', 'number("7.2")', 'number(true)', 'number([true, false, true, true])', 'number(unit("52cm"), "m")'],
-  seealso: ['bignumber', 'boolean', 'complex', 'fraction', 'index', 'matrix', 'string', 'unit']
+  seealso: ['bignumber', 'bigint', 'boolean', 'complex', 'fraction', 'index', 'matrix', 'string', 'unit']
 };

package/lib/esm/expression/embeddedDocs/embeddedDocs.js

@@ -16,6 +16,7 @@ import { tauDocs } from './constants/tau.js';
 import { trueDocs } from './constants/true.js';
 import { versionDocs } from './constants/version.js';
 import { bignumberDocs } from './construction/bignumber.js';
+import { bigintDocs } from './construction/bigint.js';
 import { booleanDocs } from './construction/boolean.js';
 import { complexDocs } from './construction/complex.js';
 import { createUnitDocs } from './construction/createUnit.js';
@@ -244,6 +245,7 @@ import { solveODEDocs } from './function/numeric/solveODE.js';
 export var embeddedDocs = {
   // construction functions
   bignumber: bignumberDocs,
+  bigint: bigintDocs,
   boolean: booleanDocs,
   complex: complexDocs,
   createUnit: createUnitDocs,

package/lib/esm/expression/embeddedDocs/function/utils/numeric.js

@@ -2,7 +2,7 @@ export var numericDocs = {
   name: 'numeric',
   category: 'Utils',
   syntax: ['numeric(x)'],
-  description: 'Convert a numeric input to a specific numeric type: number, BigNumber, or Fraction.',
-  examples: ['numeric("4")', 'numeric("4", "number")', 'numeric("4", "BigNumber")', 'numeric("4", "Fraction")', 'numeric(4, "Fraction")', 'numeric(fraction(2, 5), "number")'],
-  seealso: ['number', 'fraction', 'bignumber', 'string', 'format']
+  description: 'Convert a numeric input to a specific numeric type: number, BigNumber, bigint, or Fraction.',
+  examples: ['numeric("4")', 'numeric("4", "number")', 'numeric("4", "bigint")', 'numeric("4", "BigNumber")', 'numeric("4", "Fraction")', 'numeric(4, "Fraction")', 'numeric(fraction(2, 5), "number")'],
+  seealso: ['number', 'bigint', 'fraction', 'bignumber', 'string', 'format']
 };

package/lib/esm/expression/node/ConstantNode.js

@@ -18,7 +18,7 @@ export var createConstantNode = /* #__PURE__ */factory(name, dependencies, _ref
      *     new ConstantNode(2.3)
      *     new ConstantNode('hello')
      *
-     * @param {*} value    Value can be any type (number, BigNumber, string, ...)
+     * @param {*} value    Value can be any type (number, BigNumber, bigint, string, ...)
      * @constructor ConstantNode
      * @extends {Node}
      */
@@ -97,6 +97,7 @@ export var createConstantNode = /* #__PURE__ */factory(name, dependencies, _ref
       var value = this._toString(options);
       switch (typeOf(this.value)) {
         case 'number':
+        case 'bigint':
         case 'BigNumber':
         case 'Fraction':
           return '<span class="math-number">' + value + '</span>';
@@ -159,6 +160,10 @@ export var createConstantNode = /* #__PURE__ */factory(name, dependencies, _ref
             }
             return value;
           }
+        case 'bigint':
+          {
+            return value.toString();
+          }
         case 'Fraction':
           return this.value.toLatex();
         default:

package/lib/esm/expression/parse.js

@@ -2,6 +2,7 @@ import _extends from "@babel/runtime/helpers/extends";
 import { factory } from '../utils/factory.js';
 import { isAccessorNode, isConstantNode, isFunctionNode, isOperatorNode, isSymbolNode, rule2Node } from '../utils/is.js';
 import { deepMap } from '../utils/collection.js';
+import { safeNumberType } from '../utils/number.js';
 import { hasOwnProperty } from '../utils/object.js';
 var name = 'parse';
 var dependencies = ['typed', 'numeric', 'config', 'AccessorNode', 'ArrayNode', 'AssignmentNode', 'BlockNode', 'ConditionalNode', 'ConstantNode', 'FunctionAssignmentNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'ParenthesisNode', 'RangeNode', 'RelationalNode', 'SymbolNode'];
@@ -952,7 +953,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
   }
 
   /**
-   * multiply, divide, modulus
+   * multiply, divide
    * @return {Node} node
    * @private
    */
@@ -1016,7 +1017,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @private
    */
   function parseRule2(state) {
-    var node = parsePercentage(state);
+    var node = parseModulusPercentage(state);
     var last = node;
     var tokenStates = [];
     while (true) {
@@ -1038,7 +1039,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
             // Rewind once and build the "number / number" node; the symbol will be consumed later
             _extends(state, tokenStates.pop());
             tokenStates.pop();
-            last = parsePercentage(state);
+            last = parseModulusPercentage(state);
             node = new OperatorNode('/', 'divide', [node, last]);
           } else {
             // Not a match, so rewind
@@ -1059,11 +1060,11 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
   }
 
   /**
-   * percentage or mod
+   * modulus and percentage
    * @return {Node} node
    * @private
    */
-  function parsePercentage(state) {
+  function parseModulusPercentage(state) {
     var node, name, fn, params;
     node = parseUnary(state);
     var operators = {
@@ -1226,7 +1227,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
       if (hasOwnProperty(CONSTANTS, name)) {
         // true, false, null, ...
         node = new ConstantNode(CONSTANTS[name]);
-      } else if (NUMERIC_CONSTANTS.indexOf(name) !== -1) {
+      } else if (NUMERIC_CONSTANTS.includes(name)) {
         // NaN, Infinity
         node = new ConstantNode(numeric(name, 'number'));
       } else {
@@ -1256,7 +1257,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   function parseAccessors(state, node, types) {
     var params;
-    while ((state.token === '(' || state.token === '[' || state.token === '.') && (!types || types.indexOf(state.token) !== -1)) {
+    while ((state.token === '(' || state.token === '[' || state.token === '.') && (!types || types.includes(state.token))) {
       // eslint-disable-line no-unmodified-loop-condition
       params = [];
       if (state.token === '(') {
@@ -1527,7 +1528,9 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
       // this is a number
       numberStr = state.token;
       getToken(state);
-      return new ConstantNode(numeric(numberStr, config.number));
+      var numericType = safeNumberType(numberStr, config);
+      var value = numeric(numberStr, numericType);
+      return new ConstantNode(value);
     }
     return parseParentheses(state);
   }

package/lib/esm/factoriesAny.js

@@ -18,6 +18,7 @@ export { createTypeOf } from './function/utils/typeOf.js';
 export { createEqualScalar } from './function/relational/equalScalar.js';
 export { createSparseMatrixClass } from './type/matrix/SparseMatrix.js';
 export { createNumber } from './type/number.js';
+export { createBigint } from './type/bigint.js';
 export { createString } from './type/string.js';
 export { createBoolean } from './type/boolean.js';
 export { createBignumber } from './type/bignumber/function/bignumber.js';

package/lib/esm/factoriesNumber.js

@@ -87,6 +87,7 @@ createSQRT2, createTau, createTrue, createVersion } from './constants.js';
 
 // create
 export { createNumber } from './type/number.js';
+export { createBigint } from './type/bigint.js';
 export { createString } from './type/string.js';
 export { createBoolean } from './type/boolean.js';
 export { createParser } from './expression/function/parser.js';

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

@@ -1,5 +1,6 @@
 import { isConstantNode, typeOf } from '../../utils/is.js';
 import { factory } from '../../utils/factory.js';
+import { safeNumberType } from '../../utils/number.js';
 var name = 'derivative';
 var dependencies = ['typed', 'config', 'parse', 'simplify', 'equal', 'isZero', 'numeric', 'ConstantNode', 'FunctionNode', 'OperatorNode', 'ParenthesisNode', 'SymbolNode'];
 export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -159,7 +160,7 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
       return constTag(constNodes, node.content, varName);
     },
     'Object, FunctionAssignmentNode, string': function ObjectFunctionAssignmentNodeString(constNodes, node, varName) {
-      if (node.params.indexOf(varName) === -1) {
+      if (!node.params.includes(varName)) {
         constNodes[node] = true;
         return true;
       }
@@ -513,7 +514,7 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
    * @return {ConstantNode}
    */
   function createConstantNode(value, valueType) {
-    return new ConstantNode(numeric(value, valueType || config.number));
+    return new ConstantNode(numeric(value, valueType || safeNumberType(String(value), config)));
   }
   return derivative;
 });

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

@@ -229,7 +229,7 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
             recPoly(node.args[0]);
           }
         } else {
-          if (oper.indexOf(node.op) === -1) {
+          if (!oper.includes(node.op)) {
             throw new Error('Operator ' + node.op + ' invalid in polynomial expression');
           }
           for (var i = 0; i < node.args.length; i++) {
@@ -727,7 +727,7 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
         throw new Error('There is an unsolved function call');
       } else if (tp === 'OperatorNode') {
         // ***** OperatorName *****
-        if ('+-*^'.indexOf(node.op) === -1) throw new Error('Operator ' + node.op + ' invalid');
+        if (!'+-*^'.includes(node.op)) throw new Error('Operator ' + node.op + ' invalid');
         if (noPai !== null) {
           // -(unary),^  : children of *,+,-
           if ((node.fn === 'unaryMinus' || node.fn === 'pow') && noPai.fn !== 'add' && noPai.fn !== 'subtract' && noPai.fn !== 'multiply') {

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

@@ -1,5 +1,6 @@
 import { isFraction, isMatrix, isNode, isArrayNode, isConstantNode, isIndexNode, isObjectNode, isOperatorNode } from '../../utils/is.js';
 import { factory } from '../../utils/factory.js';
+import { safeNumberType } from '../../utils/number.js';
 import { createUtil } from './simplify/util.js';
 import { noBignumber, noFraction } from '../../utils/noop.js';
 var name = 'simplifyConstant';
@@ -100,6 +101,12 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
       }
       return new ConstantNode(n); // old parameters: (n.toString(), 'number')
     },
+    bigint: function bigint(n) {
+      if (n < 0n) {
+        return unaryMinusNode(new ConstantNode(-n));
+      }
+      return new ConstantNode(n);
+    },
     Complex: function Complex(s) {
       throw new Error('Cannot convert Complex number to Node');
     },
@@ -136,12 +143,15 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
   // BigNumbers are left alone
   var _toNumber = typed({
     'string, Object': function stringObject(s, options) {
-      if (config.number === 'BigNumber') {
+      var numericType = safeNumberType(s, config);
+      if (numericType === 'BigNumber') {
         if (bignumber === undefined) {
           noBignumber();
         }
         return bignumber(s);
-      } else if (config.number === 'Fraction') {
+      } else if (numericType === 'bigint') {
+        return BigInt(s);
+      } else if (numericType === 'Fraction') {
         if (fraction === undefined) {
           noFraction();
         }
@@ -164,6 +174,9 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
     'number, Object': function numberObject(s, options) {
       return _exactFraction(s, options);
     },
+    'bigint, Object': function bigintObject(s, options) {
+      return s;
+    },
     'Complex, Object': function ComplexObject(s, options) {
       if (s.im !== 0) {
         return s;
@@ -326,6 +339,8 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
         switch (typeof node.value) {
           case 'number':
             return _toNumber(node.value, options);
+          case 'bigint':
+            return _toNumber(node.value, options);
           case 'string':
             return node.value;
           default:
@@ -339,7 +354,7 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
         {
           // Process operators as OperatorNode
           var operatorFunctions = ['add', 'multiply'];
-          if (operatorFunctions.indexOf(node.name) === -1) {
+          if (!operatorFunctions.includes(node.name)) {
             var args = node.args.map(arg => foldFraction(arg, options));
 
             // If all args are numbers

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

@@ -26,14 +26,15 @@ export var createAbs = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    sign
    *
-   * @param  {number | BigNumber | Fraction | Complex | Array | Matrix | Unit} x
+   * @param  {number | BigNumber | bigint | Fraction | Complex | Array | Matrix | Unit} x
    *            A number or matrix for which to get the absolute value
-   * @return {number | BigNumber | Fraction | Complex | Array | Matrix | Unit}
+   * @return {number | BigNumber | bigint | Fraction | Complex | Array | Matrix | Unit}
    *            Absolute value of `x`
    */
   return typed(name, {
     number: absNumber,
     'Complex | BigNumber | Fraction | Unit': x => x.abs(),
+    bigint: x => x < 0n ? -x : x,
     // deep map collection, skip zeros since abs(0) = 0
     'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self, true))
   });

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

@@ -61,9 +61,9 @@ export var createAdd = /* #__PURE__ */factory(name, dependencies, _ref => {
   *
   *    subtract, sum
   *
-  * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x First value to add
-  * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} y Second value to add
-  * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} Sum of `x` and `y`
+  * @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`
   */
   return typed(name, {
     'any, any': addScalar,

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

@@ -13,9 +13,9 @@ export var createAddScalar = /* #__PURE__ */factory(name, dependencies, _ref =>
    *
    * This function does not support collections (Array or Matrix).
    *
-   * @param  {number | BigNumber | Fraction | Complex | Unit} x   First value to add
-   * @param  {number | BigNumber | Fraction | Complex} y          Second value to add
-   * @return {number | BigNumber | Fraction | Complex | Unit}     Sum of `x` and `y`
+   * @param  {number | BigNumber | bigint | Fraction | Complex | Unit} x   First value to add
+   * @param  {number | BigNumber | bigint | Fraction | Complex} y          Second value to add
+   * @return {number | BigNumber | bigint | Fraction | Complex | Unit}     Sum of `x` and `y`
    * @private
    */
   return typed(name, {
@@ -26,6 +26,9 @@ export var createAddScalar = /* #__PURE__ */factory(name, dependencies, _ref =>
     'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
       return x.plus(y);
     },
+    'bigint, bigint': function bigintBigint(x, y) {
+      return x + y;
+    },
     'Fraction, Fraction': function FractionFraction(x, y) {
       return x.add(y);
     },

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

@@ -16,14 +16,14 @@ export var createCeilNumber = /* #__PURE__ */factory(name, ['typed', 'config', '
   } = _ref;
   return typed(name, {
     number: function number(x) {
-      if (nearlyEqual(x, round(x), config.epsilon)) {
+      if (nearlyEqual(x, round(x), config.relTol, config.absTol)) {
         return round(x);
       } else {
         return Math.ceil(x);
       }
     },
     'number, number': function numberNumber(x, n) {
-      if (nearlyEqual(x, round(x, n), config.epsilon)) {
+      if (nearlyEqual(x, round(x, n), config.relTol, config.absTol)) {
         return round(x, n);
       } else {
         var [number, exponent] = "".concat(x, "e").split('e');
@@ -110,14 +110,14 @@ export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref2 => {
       return x.ceil(n.toNumber());
     },
     BigNumber: function BigNumber(x) {
-      if (bigNearlyEqual(x, round(x), config.epsilon)) {
+      if (bigNearlyEqual(x, round(x), config.relTol, config.absTol)) {
         return round(x);
       } else {
         return x.ceil();
       }
     },
     'BigNumber, BigNumber': function BigNumberBigNumber(x, n) {
-      if (bigNearlyEqual(x, round(x, n), config.epsilon)) {
+      if (bigNearlyEqual(x, round(x, n), config.relTol, config.absTol)) {
         return round(x, n);
       } else {
         return x.toDecimalPlaces(n.toNumber(), Decimal.ROUND_CEIL);

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

@@ -28,8 +28,8 @@ export var createCube = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    multiply, square, pow, cbrt
    *
-   * @param  {number | BigNumber | Fraction | Complex | Unit} x  Number for which to calculate the cube
-   * @return {number | BigNumber | Fraction | Complex | Unit} Cube of x
+   * @param  {number | BigNumber | bigint | Fraction | Complex | Unit} x  Number for which to calculate the cube
+   * @return {number | BigNumber | bigint | Fraction | Complex | Unit} Cube of x
    */
   return typed(name, {
     number: cubeNumber,
@@ -39,6 +39,9 @@ export var createCube = /* #__PURE__ */factory(name, dependencies, _ref => {
     BigNumber: function BigNumber(x) {
       return x.times(x).times(x);
     },
+    bigint: function bigint(x) {
+      return x * x * x;
+    },
     Fraction: function Fraction(x) {
       return x.pow(3); // Is faster than mul()mul()mul()
     },

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

@@ -48,9 +48,9 @@ export var createDivide = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    multiply
    *
-   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x   Numerator
-   * @param  {number | BigNumber | Fraction | Complex | Array | Matrix} y          Denominator
-   * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix}                      Quotient, `x / y`
+   * @param  {number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix} x   Numerator
+   * @param  {number | BigNumber | bigint | Fraction | Complex | Array | Matrix} y          Denominator
+   * @return {number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix}                      Quotient, `x / y`
    */
   return typed('divide', extend({
     // we extend the signatures of divideScalar with signatures dealing with matrices

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

@@ -13,9 +13,9 @@ export var createDivideScalar = /* #__PURE__ */factory(name, dependencies, _ref
    *
    * This function does not support collections (Array or Matrix).
    *
-   * @param  {number | BigNumber | Fraction | Complex | Unit} x   Numerator
-   * @param  {number | BigNumber | Fraction | Complex} y          Denominator
-   * @return {number | BigNumber | Fraction | Complex | Unit}     Quotient, `x / y`
+   * @param  {number | BigNumber | bigint | Fraction | Complex | Unit} x   Numerator
+   * @param  {number | BigNumber | bigint | Fraction | Complex} y          Denominator
+   * @return {number | BigNumber | bigint | Fraction | Complex | Unit}     Quotient, `x / y`
    * @private
    */
   return typed(name, {
@@ -28,6 +28,9 @@ export var createDivideScalar = /* #__PURE__ */factory(name, dependencies, _ref
     'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
       return x.div(y);
     },
+    'bigint, bigint': function bigintBigint(x, y) {
+      return x / y;
+    },
     'Fraction, Fraction': function FractionFraction(x, y) {
       return x.div(y);
     },

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

@@ -16,14 +16,14 @@ export var createFloorNumber = /* #__PURE__ */factory(name, ['typed', 'config',
   } = _ref;
   return typed(name, {
     number: function number(x) {
-      if (nearlyEqual(x, round(x), config.epsilon)) {
+      if (nearlyEqual(x, round(x), config.relTol, config.absTol)) {
         return round(x);
       } else {
         return Math.floor(x);
       }
     },
     'number, number': function numberNumber(x, n) {
-      if (nearlyEqual(x, round(x, n), config.epsilon)) {
+      if (nearlyEqual(x, round(x, n), config.relTol, config.absTol)) {
         return round(x, n);
       } else {
         var [number, exponent] = "".concat(x, "e").split('e');
@@ -113,14 +113,14 @@ export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref2 => {
       return x.floor(n.toNumber());
     },
     BigNumber: function BigNumber(x) {
-      if (bigNearlyEqual(x, round(x), config.epsilon)) {
+      if (bigNearlyEqual(x, round(x), config.relTol, config.absTol)) {
         return round(x);
       } else {
         return x.floor();
       }
     },
     'BigNumber, BigNumber': function BigNumberBigNumber(x, n) {
-      if (bigNearlyEqual(x, round(x, n), config.epsilon)) {
+      if (bigNearlyEqual(x, round(x, n), config.relTol, config.absTol)) {
         return round(x, n);
       } else {
         return x.toDecimalPlaces(n.toNumber(), Decimal.ROUND_FLOOR);

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

@@ -84,15 +84,25 @@ export var createMod = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    divide
    *
-   * @param  {number | BigNumber | Fraction | Array | Matrix} x Dividend
-   * @param  {number | BigNumber | Fraction | Array | Matrix} y Divisor
-   * @return {number | BigNumber | Fraction | Array | Matrix} Returns the remainder of `x` divided by `y`.
+   * @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`.
    */
   return typed(name, {
     'number, number': _modNumber,
     'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
       return y.isZero() ? x : x.sub(y.mul(floor(x.div(y))));
     },
+    'bigint, bigint': function bigintBigint(x, y) {
+      if (y === 0n) {
+        return x;
+      }
+      if (x < 0) {
+        var m = x % y;
+        return m === 0n ? m : m + y;
+      }
+      return x % y;
+    },
     'Fraction, Fraction': function FractionFraction(x, y) {
       return y.equals(0) ? x : x.sub(y.mul(floor(x.div(y))));
     }

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

@@ -801,9 +801,9 @@ export var createMultiply = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    divide, prod, cross, dot
    *
-   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x First value to multiply
-   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} y Second value to multiply
-   * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} Multiplication of `x` and `y`
+   * @param  {number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix} x First value to multiply
+   * @param  {number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix} y Second value to multiply
+   * @return {number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix} Multiplication of `x` and `y`
    */
   return typed(name, multiplyScalar, {
     // we extend the signatures of multiplyScalar with signatures dealing with matrices

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

@@ -13,9 +13,9 @@ export var createMultiplyScalar = /* #__PURE__ */factory(name, dependencies, _re
    *
    * This function does not support collections (Array or Matrix).
    *
-   * @param  {number | BigNumber | Fraction | Complex | Unit} x   First value to multiply
-   * @param  {number | BigNumber | Fraction | Complex} y          Second value to multiply
-   * @return {number | BigNumber | Fraction | Complex | Unit}     Multiplication of `x` and `y`
+   * @param  {number | BigNumber | bigint | Fraction | Complex | Unit} x   First value to multiply
+   * @param  {number | BigNumber | bigint | Fraction | Complex} y          Second value to multiply
+   * @return {number | BigNumber | bigint | Fraction | Complex | Unit}     Multiplication of `x` and `y`
    * @private
    */
   return typed('multiplyScalar', {
@@ -26,6 +26,9 @@ export var createMultiplyScalar = /* #__PURE__ */factory(name, dependencies, _re
     'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
       return x.times(y);
     },
+    'bigint, bigint': function bigintBigint(x, y) {
+      return x * y;
+    },
     'Fraction, Fraction': function FractionFraction(x, y) {
       return x.mul(y);
     },

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

@@ -50,9 +50,9 @@ export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    multiply, sqrt, cbrt, nthRoot
    *
-   * @param  {number | BigNumber | Complex | Unit | Array | Matrix} x  The base
-   * @param  {number | BigNumber | Complex} y                          The exponent
-   * @return {number | BigNumber | Complex | Array | Matrix} The value of `x` to the power `y`
+   * @param  {number | BigNumber | bigint | Complex | Unit | Array | Matrix} x  The base
+   * @param  {number | BigNumber | bigint | Complex} y                          The exponent
+   * @return {number | BigNumber | bigint | Complex | Array | Matrix} The value of `x` to the power `y`
    */
   return typed(name, {
     'number, number': _pow,
@@ -66,6 +66,7 @@ export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
         return new Complex(x.toNumber(), 0).pow(y.toNumber(), 0);
       }
     },
+    'bigint, bigint': (x, y) => x ** y,
     'Fraction, Fraction': function FractionFraction(x, y) {
       var result = x.pow(y);
       if (result != null) {