mathjs 14.0.0 → 14.1.0

package/lib/cjs/entry/dependenciesAny/dependenciesLarger.generated.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.largerDependencies = void 0;
 var _dependenciesDenseMatrixClassGenerated = require("./dependenciesDenseMatrixClass.generated.js");
 var _dependenciesSparseMatrixClassGenerated = require("./dependenciesSparseMatrixClass.generated.js");
+var _dependenciesBignumberGenerated = require("./dependenciesBignumber.generated.js");
 var _dependenciesConcatGenerated = require("./dependenciesConcat.generated.js");
 var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
 var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
@@ -18,6 +19,7 @@ var _factoriesAny = require("../../factoriesAny.js");
 const largerDependencies = exports.largerDependencies = {
   DenseMatrixDependencies: _dependenciesDenseMatrixClassGenerated.DenseMatrixDependencies,
   SparseMatrixDependencies: _dependenciesSparseMatrixClassGenerated.SparseMatrixDependencies,
+  bignumberDependencies: _dependenciesBignumberGenerated.bignumberDependencies,
   concatDependencies: _dependenciesConcatGenerated.concatDependencies,
   matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
   typedDependencies: _dependenciesTypedGenerated.typedDependencies,

package/lib/cjs/entry/dependenciesAny/dependenciesRandomInt.generated.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.randomIntDependencies = void 0;
+var _dependenciesLog2Generated = require("./dependenciesLog2.generated.js");
 var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
 var _factoriesAny = require("../../factoriesAny.js");
 /**
@@ -12,6 +13,7 @@ var _factoriesAny = require("../../factoriesAny.js");
  */
 
 const randomIntDependencies = exports.randomIntDependencies = {
+  log2Dependencies: _dependenciesLog2Generated.log2Dependencies,
   typedDependencies: _dependenciesTypedGenerated.typedDependencies,
   createRandomInt: _factoriesAny.createRandomInt
 };

package/lib/cjs/entry/dependenciesAny/dependenciesSmaller.generated.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.smallerDependencies = void 0;
 var _dependenciesDenseMatrixClassGenerated = require("./dependenciesDenseMatrixClass.generated.js");
 var _dependenciesSparseMatrixClassGenerated = require("./dependenciesSparseMatrixClass.generated.js");
+var _dependenciesBignumberGenerated = require("./dependenciesBignumber.generated.js");
 var _dependenciesConcatGenerated = require("./dependenciesConcat.generated.js");
 var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
 var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
@@ -18,6 +19,7 @@ var _factoriesAny = require("../../factoriesAny.js");
 const smallerDependencies = exports.smallerDependencies = {
   DenseMatrixDependencies: _dependenciesDenseMatrixClassGenerated.DenseMatrixDependencies,
   SparseMatrixDependencies: _dependenciesSparseMatrixClassGenerated.SparseMatrixDependencies,
+  bignumberDependencies: _dependenciesBignumberGenerated.bignumberDependencies,
   concatDependencies: _dependenciesConcatGenerated.concatDependencies,
   matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
   typedDependencies: _dependenciesTypedGenerated.typedDependencies,

package/lib/cjs/entry/dependenciesNumber/dependenciesRandomInt.generated.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.randomIntDependencies = void 0;
+var _dependenciesLog2Generated = require("./dependenciesLog2.generated.js");
 var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
 var _factoriesNumber = require("../../factoriesNumber.js");
 /**
@@ -12,6 +13,7 @@ var _factoriesNumber = require("../../factoriesNumber.js");
  */
 
 const randomIntDependencies = exports.randomIntDependencies = {
+  log2Dependencies: _dependenciesLog2Generated.log2Dependencies,
   typedDependencies: _dependenciesTypedGenerated.typedDependencies,
   createRandomInt: _factoriesNumber.createRandomInt
 };

package/lib/cjs/entry/impureFunctionsNumber.generated.js

@@ -339,7 +339,6 @@ const parser = exports.parser = (0, _factoriesNumber.createParser)({
   multiplyScalar: _pureFunctionsNumberGenerated.multiplyScalar,
   nthRoot: _pureFunctionsNumberGenerated.nthRoot,
   pickRandom: _pureFunctionsNumberGenerated.pickRandom,
-  randomInt: _pureFunctionsNumberGenerated.randomInt,
   rightArithShift: _pureFunctionsNumberGenerated.rightArithShift,
   sec: _pureFunctionsNumberGenerated.sec,
   sinh: _pureFunctionsNumberGenerated.sinh,
@@ -362,6 +361,7 @@ const parser = exports.parser = (0, _factoriesNumber.createParser)({
   norm: _pureFunctionsNumberGenerated.norm,
   partitionSelect: _pureFunctionsNumberGenerated.partitionSelect,
   print: _pureFunctionsNumberGenerated.print,
+  randomInt: _pureFunctionsNumberGenerated.randomInt,
   round: _pureFunctionsNumberGenerated.round,
   smaller: _pureFunctionsNumberGenerated.smaller,
   subtractScalar: _pureFunctionsNumberGenerated.subtractScalar,

package/lib/cjs/entry/pureFunctionsAny.generated.js

@@ -352,6 +352,7 @@ const isPrime = exports.isPrime = /* #__PURE__ */(0, _factoriesAny.createIsPrime
 });
 const randomInt = exports.randomInt = /* #__PURE__ */(0, _factoriesAny.createRandomInt)({
   config: _configReadonly.config,
+  log2,
   typed
 });
 const sech = exports.sech = /* #__PURE__ */(0, _factoriesAny.createSech)({
@@ -612,6 +613,7 @@ const round = exports.round = /* #__PURE__ */(0, _factoriesAny.createRound)({
 const smaller = exports.smaller = /* #__PURE__ */(0, _factoriesAny.createSmaller)({
   DenseMatrix,
   SparseMatrix,
+  bignumber,
   concat,
   config: _configReadonly.config,
   matrix,
@@ -791,6 +793,7 @@ const Index = exports.Index = /* #__PURE__ */(0, _factoriesAny.createIndexClass)
 const larger = exports.larger = /* #__PURE__ */(0, _factoriesAny.createLarger)({
   DenseMatrix,
   SparseMatrix,
+  bignumber,
   concat,
   config: _configReadonly.config,
   matrix,

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

@@ -302,10 +302,6 @@ const pickRandom = exports.pickRandom = /* #__PURE__ */(0, _factoriesNumber.crea
   config: _configReadonly.config,
   typed
 });
-const randomInt = exports.randomInt = /* #__PURE__ */(0, _factoriesNumber.createRandomInt)({
-  config: _configReadonly.config,
-  typed
-});
 const rightArithShift = exports.rightArithShift = /* #__PURE__ */(0, _factoriesNumber.createRightArithShift)({
   typed
 });
@@ -382,6 +378,11 @@ const partitionSelect = exports.partitionSelect = /* #__PURE__ */(0, _factoriesN
 const print = exports.print = /* #__PURE__ */(0, _factoriesNumber.createPrint)({
   typed
 });
+const randomInt = exports.randomInt = /* #__PURE__ */(0, _factoriesNumber.createRandomInt)({
+  config: _configReadonly.config,
+  log2,
+  typed
+});
 const round = exports.round = /* #__PURE__ */(0, _factoriesNumber.createRound)({
   typed
 });

package/lib/cjs/expression/embeddedDocs/function/arithmetic/sign.js

@@ -8,7 +8,7 @@ const signDocs = exports.signDocs = {
   name: 'sign',
   category: 'Arithmetic',
   syntax: ['sign(x)'],
-  description: 'Compute the sign of a value. The sign of a value x is 1 when x>1, -1 when x<0, and 0 when x=0.',
+  description: 'Compute the sign of a value. The sign of a value x is 1 when x>0, -1 when x<0, and 0 when x=0.',
   examples: ['sign(3.5)', 'sign(-4.2)', 'sign(0)'],
   seealso: ['abs']
 };

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

@@ -66,9 +66,18 @@ const createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.
     let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
       simplify: true
     };
-    const constNodes = {};
-    constTag(constNodes, expr, variable.name);
-    const res = _derivative(expr, constNodes);
+    const cache = new Map();
+    const variableName = variable.name;
+    function isConstCached(node) {
+      const cached = cache.get(node);
+      if (cached !== undefined) {
+        return cached;
+      }
+      const res = _isConst(isConstCached, node, variableName);
+      cache.set(node, res);
+      return res;
+    }
+    const res = _derivative(expr, isConstCached);
     return options.simplify ? simplify(res) : res;
   }
   function parseIdentifier(string) {
@@ -88,9 +97,8 @@ const createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.
     'Node, SymbolNode, ConstantNode': function (expr, variable, {order}) {
       let res = expr
       for (let i = 0; i < order; i++) {
-        let constNodes = {}
-        constTag(constNodes, expr, variable.name)
-        res = _derivative(res, constNodes)
+        <create caching isConst>
+        res = _derivative(res, isConst)
       }
       return res
     }
@@ -133,56 +141,39 @@ const createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.
   });
 
   /**
-   * Does a depth-first search on the expression tree to identify what Nodes
-   * are constants (e.g. 2 + 2), and stores the ones that are constants in
-   * constNodes. Classification is done as follows:
+   * Checks if a node is constants (e.g. 2 + 2).
+   * Accepts (usually memoized) version of self as the first parameter for recursive calls.
+   * Classification is done as follows:
    *
    *   1. ConstantNodes are constants.
    *   2. If there exists a SymbolNode, of which we are differentiating over,
    *      in the subtree it is not constant.
    *
-   * @param  {Object} constNodes  Holds the nodes that are constant
+   * @param  {function} isConst  Function that tells whether sub-expression is a constant
    * @param  {ConstantNode | SymbolNode | ParenthesisNode | FunctionNode | OperatorNode} node
    * @param  {string} varName     Variable that we are differentiating
    * @return {boolean}  if node is constant
    */
-  // TODO: can we rewrite constTag into a pure function?
-  const constTag = typed('constTag', {
-    'Object, ConstantNode, string': function (constNodes, node) {
-      constNodes[node] = true;
+  const _isConst = typed('_isConst', {
+    'function, ConstantNode, string': function () {
       return true;
     },
-    'Object, SymbolNode, string': function (constNodes, node, varName) {
+    'function, SymbolNode, string': function (isConst, node, varName) {
       // Treat other variables like constants. For reasoning, see:
       //   https://en.wikipedia.org/wiki/Partial_derivative
-      if (node.name !== varName) {
-        constNodes[node] = true;
-        return true;
-      }
-      return false;
+      return node.name !== varName;
     },
-    'Object, ParenthesisNode, string': function (constNodes, node, varName) {
-      return constTag(constNodes, node.content, varName);
+    'function, ParenthesisNode, string': function (isConst, node, varName) {
+      return isConst(node.content, varName);
     },
-    'Object, FunctionAssignmentNode, string': function (constNodes, node, varName) {
+    'function, FunctionAssignmentNode, string': function (isConst, node, varName) {
       if (!node.params.includes(varName)) {
-        constNodes[node] = true;
         return true;
       }
-      return constTag(constNodes, node.expr, varName);
+      return isConst(node.expr, varName);
     },
-    'Object, FunctionNode | OperatorNode, string': function (constNodes, node, varName) {
-      if (node.args.length > 0) {
-        let isConst = constTag(constNodes, node.args[0], varName);
-        for (let i = 1; i < node.args.length; ++i) {
-          isConst = constTag(constNodes, node.args[i], varName) && isConst;
-        }
-        if (isConst) {
-          constNodes[node] = true;
-          return true;
-        }
-      }
-      return false;
+    'function, FunctionNode | OperatorNode, string': function (isConst, node, varName) {
+      return node.args.every(arg => isConst(arg, varName));
     }
   });
 
@@ -190,30 +181,30 @@ const createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.
    * Applies differentiation rules.
    *
    * @param  {ConstantNode | SymbolNode | ParenthesisNode | FunctionNode | OperatorNode} node
-   * @param  {Object} constNodes  Holds the nodes that are constant
+   * @param  {function} isConst  Function that tells if a node is constant
    * @return {ConstantNode | SymbolNode | ParenthesisNode | FunctionNode | OperatorNode}    The derivative of `expr`
    */
   const _derivative = typed('_derivative', {
-    'ConstantNode, Object': function (node) {
+    'ConstantNode, function': function () {
       return createConstantNode(0);
     },
-    'SymbolNode, Object': function (node, constNodes) {
-      if (constNodes[node] !== undefined) {
+    'SymbolNode, function': function (node, isConst) {
+      if (isConst(node)) {
         return createConstantNode(0);
       }
       return createConstantNode(1);
     },
-    'ParenthesisNode, Object': function (node, constNodes) {
-      return new ParenthesisNode(_derivative(node.content, constNodes));
+    'ParenthesisNode, function': function (node, isConst) {
+      return new ParenthesisNode(_derivative(node.content, isConst));
     },
-    'FunctionAssignmentNode, Object': function (node, constNodes) {
-      if (constNodes[node] !== undefined) {
+    'FunctionAssignmentNode, function': function (node, isConst) {
+      if (isConst(node)) {
         return createConstantNode(0);
       }
-      return _derivative(node.expr, constNodes);
+      return _derivative(node.expr, isConst);
     },
-    'FunctionNode, Object': function (node, constNodes) {
-      if (constNodes[node] !== undefined) {
+    'FunctionNode, function': function (node, isConst) {
+      if (isConst(node)) {
         return createConstantNode(0);
       }
       const arg0 = node.args[0];
@@ -237,10 +228,7 @@ const createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.
           } else if (node.args.length === 2) {
             // Rearrange from nthRoot(x, a) -> x^(1/a)
             arg1 = new OperatorNode('/', 'divide', [createConstantNode(1), node.args[1]]);
-
-            // Is a variable?
-            constNodes[arg1] = constNodes[node.args[1]];
-            return _derivative(new OperatorNode('^', 'pow', [arg0, arg1]), constNodes);
+            return _derivative(new OperatorNode('^', 'pow', [arg0, arg1]), isConst);
           }
           break;
         case 'log10':
@@ -251,20 +239,19 @@ const createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.
             // d/dx(log(x)) = 1 / x
             funcDerivative = arg0.clone();
             div = true;
-          } else if (node.args.length === 1 && arg1 || node.args.length === 2 && constNodes[node.args[1]] !== undefined) {
+          } else if (node.args.length === 1 && arg1 || node.args.length === 2 && isConst(node.args[1])) {
             // d/dx(log(x, c)) = 1 / (x*ln(c))
             funcDerivative = new OperatorNode('*', 'multiply', [arg0.clone(), new FunctionNode('log', [arg1 || node.args[1]])]);
             div = true;
           } else if (node.args.length === 2) {
             // d/dx(log(f(x), g(x))) = d/dx(log(f(x)) / log(g(x)))
-            return _derivative(new OperatorNode('/', 'divide', [new FunctionNode('log', [arg0]), new FunctionNode('log', [node.args[1]])]), constNodes);
+            return _derivative(new OperatorNode('/', 'divide', [new FunctionNode('log', [arg0]), new FunctionNode('log', [node.args[1]])]), isConst);
           }
           break;
         case 'pow':
           if (node.args.length === 2) {
-            constNodes[arg1] = constNodes[node.args[1]];
             // Pass to pow operator node parser
-            return _derivative(new OperatorNode('^', 'pow', [arg0, node.args[1]]), constNodes);
+            return _derivative(new OperatorNode('^', 'pow', [arg0, node.args[1]]), isConst);
           }
           break;
         case 'exp':
@@ -410,51 +397,51 @@ const createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.
       /* Apply chain rule to all functions:
          F(x)  = f(g(x))
          F'(x) = g'(x)*f'(g(x)) */
-      let chainDerivative = _derivative(arg0, constNodes);
+      let chainDerivative = _derivative(arg0, isConst);
       if (negative) {
         chainDerivative = new OperatorNode('-', 'unaryMinus', [chainDerivative]);
       }
       return new OperatorNode(op, func, [chainDerivative, funcDerivative]);
     },
-    'OperatorNode, Object': function (node, constNodes) {
-      if (constNodes[node] !== undefined) {
+    'OperatorNode, function': function (node, isConst) {
+      if (isConst(node)) {
         return createConstantNode(0);
       }
       if (node.op === '+') {
         // d/dx(sum(f(x)) = sum(f'(x))
         return new OperatorNode(node.op, node.fn, node.args.map(function (arg) {
-          return _derivative(arg, constNodes);
+          return _derivative(arg, isConst);
         }));
       }
       if (node.op === '-') {
         // d/dx(+/-f(x)) = +/-f'(x)
         if (node.isUnary()) {
-          return new OperatorNode(node.op, node.fn, [_derivative(node.args[0], constNodes)]);
+          return new OperatorNode(node.op, node.fn, [_derivative(node.args[0], isConst)]);
         }
 
         // Linearity of differentiation, d/dx(f(x) +/- g(x)) = f'(x) +/- g'(x)
         if (node.isBinary()) {
-          return new OperatorNode(node.op, node.fn, [_derivative(node.args[0], constNodes), _derivative(node.args[1], constNodes)]);
+          return new OperatorNode(node.op, node.fn, [_derivative(node.args[0], isConst), _derivative(node.args[1], isConst)]);
         }
       }
       if (node.op === '*') {
         // d/dx(c*f(x)) = c*f'(x)
         const constantTerms = node.args.filter(function (arg) {
-          return constNodes[arg] !== undefined;
+          return isConst(arg);
         });
         if (constantTerms.length > 0) {
           const nonConstantTerms = node.args.filter(function (arg) {
-            return constNodes[arg] === undefined;
+            return !isConst(arg);
           });
           const nonConstantNode = nonConstantTerms.length === 1 ? nonConstantTerms[0] : new OperatorNode('*', 'multiply', nonConstantTerms);
-          const newArgs = constantTerms.concat(_derivative(nonConstantNode, constNodes));
+          const newArgs = constantTerms.concat(_derivative(nonConstantNode, isConst));
           return new OperatorNode('*', 'multiply', newArgs);
         }
 
         // Product Rule, d/dx(f(x)*g(x)) = f'(x)*g(x) + f(x)*g'(x)
         return new OperatorNode('+', 'add', node.args.map(function (argOuter) {
           return new OperatorNode('*', 'multiply', node.args.map(function (argInner) {
-            return argInner === argOuter ? _derivative(argInner, constNodes) : argInner.clone();
+            return argInner === argOuter ? _derivative(argInner, isConst) : argInner.clone();
           }));
         }));
       }
@@ -463,31 +450,31 @@ const createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.
         const arg1 = node.args[1];
 
         // d/dx(f(x) / c) = f'(x) / c
-        if (constNodes[arg1] !== undefined) {
-          return new OperatorNode('/', 'divide', [_derivative(arg0, constNodes), arg1]);
+        if (isConst(arg1)) {
+          return new OperatorNode('/', 'divide', [_derivative(arg0, isConst), arg1]);
         }
 
         // Reciprocal Rule, d/dx(c / f(x)) = -c(f'(x)/f(x)^2)
-        if (constNodes[arg0] !== undefined) {
-          return new OperatorNode('*', 'multiply', [new OperatorNode('-', 'unaryMinus', [arg0]), new OperatorNode('/', 'divide', [_derivative(arg1, constNodes), new OperatorNode('^', 'pow', [arg1.clone(), createConstantNode(2)])])]);
+        if (isConst(arg0)) {
+          return new OperatorNode('*', 'multiply', [new OperatorNode('-', 'unaryMinus', [arg0]), new OperatorNode('/', 'divide', [_derivative(arg1, isConst), new OperatorNode('^', 'pow', [arg1.clone(), createConstantNode(2)])])]);
         }
 
         // Quotient rule, d/dx(f(x) / g(x)) = (f'(x)g(x) - f(x)g'(x)) / g(x)^2
-        return new OperatorNode('/', 'divide', [new OperatorNode('-', 'subtract', [new OperatorNode('*', 'multiply', [_derivative(arg0, constNodes), arg1.clone()]), new OperatorNode('*', 'multiply', [arg0.clone(), _derivative(arg1, constNodes)])]), new OperatorNode('^', 'pow', [arg1.clone(), createConstantNode(2)])]);
+        return new OperatorNode('/', 'divide', [new OperatorNode('-', 'subtract', [new OperatorNode('*', 'multiply', [_derivative(arg0, isConst), arg1.clone()]), new OperatorNode('*', 'multiply', [arg0.clone(), _derivative(arg1, isConst)])]), new OperatorNode('^', 'pow', [arg1.clone(), createConstantNode(2)])]);
       }
       if (node.op === '^' && node.isBinary()) {
         const arg0 = node.args[0];
         const arg1 = node.args[1];
-        if (constNodes[arg0] !== undefined) {
+        if (isConst(arg0)) {
           // If is secretly constant; 0^f(x) = 1 (in JS), 1^f(x) = 1
           if ((0, _is.isConstantNode)(arg0) && (isZero(arg0.value) || equal(arg0.value, 1))) {
             return createConstantNode(0);
           }
 
           // d/dx(c^f(x)) = c^f(x)*ln(c)*f'(x)
-          return new OperatorNode('*', 'multiply', [node, new OperatorNode('*', 'multiply', [new FunctionNode('log', [arg0.clone()]), _derivative(arg1.clone(), constNodes)])]);
+          return new OperatorNode('*', 'multiply', [node, new OperatorNode('*', 'multiply', [new FunctionNode('log', [arg0.clone()]), _derivative(arg1.clone(), isConst)])]);
         }
-        if (constNodes[arg1] !== undefined) {
+        if (isConst(arg1)) {
           if ((0, _is.isConstantNode)(arg1)) {
             // If is secretly constant; f(x)^0 = 1 -> d/dx(1) = 0
             if (isZero(arg1.value)) {
@@ -495,17 +482,17 @@ const createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.
             }
             // Ignore exponent; f(x)^1 = f(x)
             if (equal(arg1.value, 1)) {
-              return _derivative(arg0, constNodes);
+              return _derivative(arg0, isConst);
             }
           }
 
           // Elementary Power Rule, d/dx(f(x)^c) = c*f'(x)*f(x)^(c-1)
           const powMinusOne = new OperatorNode('^', 'pow', [arg0.clone(), new OperatorNode('-', 'subtract', [arg1, createConstantNode(1)])]);
-          return new OperatorNode('*', 'multiply', [arg1.clone(), new OperatorNode('*', 'multiply', [_derivative(arg0, constNodes), powMinusOne])]);
+          return new OperatorNode('*', 'multiply', [arg1.clone(), new OperatorNode('*', 'multiply', [_derivative(arg0, isConst), powMinusOne])]);
         }
 
         // Functional Power Rule, d/dx(f^g) = f^g*[f'*(g/f) + g'ln(f)]
-        return new OperatorNode('*', 'multiply', [new OperatorNode('^', 'pow', [arg0.clone(), arg1.clone()]), new OperatorNode('+', 'add', [new OperatorNode('*', 'multiply', [_derivative(arg0, constNodes), new OperatorNode('/', 'divide', [arg1.clone(), arg0.clone()])]), new OperatorNode('*', 'multiply', [_derivative(arg1, constNodes), new FunctionNode('log', [arg0.clone()])])])]);
+        return new OperatorNode('*', 'multiply', [new OperatorNode('^', 'pow', [arg0.clone(), arg1.clone()]), new OperatorNode('+', 'add', [new OperatorNode('*', 'multiply', [_derivative(arg0, isConst), new OperatorNode('/', 'divide', [arg1.clone(), arg0.clone()])]), new OperatorNode('*', 'multiply', [_derivative(arg1, isConst), new FunctionNode('log', [arg0.clone()])])])]);
       }
       throw new Error('Cannot process operator "' + node.op + '" in derivative: ' + 'the operator is not supported, undefined, or the number of arguments passed to it are not supported');
     }

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

@@ -5,9 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createLog = void 0;
 var _factory = require("../../utils/factory.js");
+var _bigint = require("../../utils/bigint.js");
 var _index = require("../../plain/number/index.js");
 const name = 'log';
 const dependencies = ['config', 'typed', 'typeOf', 'divideScalar', 'Complex'];
+const nlg16 = Math.log(16);
 const createLog = exports.createLog = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
     typed,
@@ -51,24 +53,29 @@ const createLog = exports.createLog = /* #__PURE__ */(0, _factory.factory)(name,
    * @return {number | BigNumber | Fraction | Complex}
    *            Returns the logarithm of `x`
    */
+  function complexLog(c) {
+    return c.log();
+  }
+  function complexLogNumber(x) {
+    return complexLog(new Complex(x, 0));
+  }
   return typed(name, {
     number: function (x) {
       if (x >= 0 || config.predictable) {
         return (0, _index.logNumber)(x);
       } else {
         // negative value -> complex value computation
-        return new Complex(x, 0).log();
+        return complexLogNumber(x);
       }
     },
-    Complex: function (x) {
-      return x.log();
-    },
+    bigint: (0, _bigint.promoteLogarithm)(nlg16, _index.logNumber, config, complexLogNumber),
+    Complex: complexLog,
     BigNumber: function (x) {
       if (!x.isNegative() || config.predictable) {
         return x.ln();
       } else {
         // downgrade to number, return Complex valued result
-        return new Complex(x.toNumber(), 0).log();
+        return complexLogNumber(x.toNumber());
       }
     },
     'any, any': typed.referToSelf(self => (x, base) => {

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

@@ -4,11 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createLog10 = void 0;
-var _factory = require("../../utils/factory.js");
-var _collection = require("../../utils/collection.js");
 var _index = require("../../plain/number/index.js");
+var _bigint = require("../../utils/bigint.js");
+var _collection = require("../../utils/collection.js");
+var _factory = require("../../utils/factory.js");
 const name = 'log10';
 const dependencies = ['typed', 'config', 'Complex'];
+const log16 = (0, _index.log10Number)(16);
 const createLog10 = exports.createLog10 = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
     typed,
@@ -40,24 +42,30 @@ const createLog10 = exports.createLog10 = /* #__PURE__ */(0, _factory.factory)(n
    * @return {number | BigNumber | Complex | Array | Matrix}
    *            Returns the 10-base logarithm of `x`
    */
+
+  function complexLog(c) {
+    return c.log().div(Math.LN10);
+  }
+  function complexLogNumber(x) {
+    return complexLog(new Complex(x, 0));
+  }
   return typed(name, {
     number: function (x) {
       if (x >= 0 || config.predictable) {
         return (0, _index.log10Number)(x);
       } else {
         // negative value -> complex value computation
-        return new Complex(x, 0).log().div(Math.LN10);
+        return complexLogNumber(x);
       }
     },
-    Complex: function (x) {
-      return new Complex(x).log().div(Math.LN10);
-    },
+    bigint: (0, _bigint.promoteLogarithm)(log16, _index.log10Number, config, complexLogNumber),
+    Complex: complexLog,
     BigNumber: function (x) {
       if (!x.isNegative() || config.predictable) {
         return x.log();
       } else {
         // downgrade to number, return Complex valued result
-        return new Complex(x.toNumber(), 0).log().div(Math.LN10);
+        return complexLogNumber(x.toNumber());
       }
     },
     'Array | Matrix': typed.referToSelf(self => x => (0, _collection.deepMap)(x, self))

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

@@ -4,9 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createLog2 = void 0;
-var _factory = require("../../utils/factory.js");
-var _collection = require("../../utils/collection.js");
 var _index = require("../../plain/number/index.js");
+var _bigint = require("../../utils/bigint.js");
+var _collection = require("../../utils/collection.js");
+var _factory = require("../../utils/factory.js");
 const name = 'log2';
 const dependencies = ['typed', 'config', 'Complex'];
 const createLog2 = exports.createLog2 = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
@@ -40,22 +41,26 @@ const createLog2 = exports.createLog2 = /* #__PURE__ */(0, _factory.factory)(nam
    * @return {number | BigNumber | Complex | Array | Matrix}
    *            Returns the 2-base logarithm of `x`
    */
+  function complexLog2Number(x) {
+    return _log2Complex(new Complex(x, 0));
+  }
   return typed(name, {
     number: function (x) {
       if (x >= 0 || config.predictable) {
         return (0, _index.log2Number)(x);
       } else {
         // negative value -> complex value computation
-        return _log2Complex(new Complex(x, 0));
+        return complexLog2Number(x);
       }
     },
+    bigint: (0, _bigint.promoteLogarithm)(4, _index.log2Number, config, complexLog2Number),
     Complex: _log2Complex,
     BigNumber: function (x) {
       if (!x.isNegative() || config.predictable) {
         return x.log(2);
       } else {
         // downgrade to number, return Complex valued result
-        return _log2Complex(new Complex(x.toNumber(), 0));
+        return complexLog2Number(x.toNumber());
       }
     },
     'Array | Matrix': typed.referToSelf(self => x => (0, _collection.deepMap)(x, self))

package/lib/cjs/function/probability/randomInt.js

@@ -9,11 +9,13 @@ var _randomMatrix = require("./util/randomMatrix.js");
 var _seededRNG = require("./util/seededRNG.js");
 var _is = require("../../utils/is.js");
 const name = 'randomInt';
-const dependencies = ['typed', 'config', '?on'];
+const dependencies = ['typed', 'config', 'log2', '?on'];
+const simpleCutoff = 2n ** 30n;
 const createRandomInt = exports.createRandomInt = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
     typed,
     config,
+    log2,
     on
   } = _ref;
   // seeded pseudo random number generator
@@ -32,7 +34,7 @@ const createRandomInt = exports.createRandomInt = /* #__PURE__ */(0, _factory.fa
    *
    * Syntax:
    *
-   *     math.randomInt()                // generate a random integer between 0 and 1
+   *     math.randomInt()                // generate either 0 or 1, randomly
    *     math.randomInt(max)             // generate a random integer between 0 and max
    *     math.randomInt(min, max)        // generate a random integer between min and max
    *     math.randomInt(size)            // generate a matrix with random integer between 0 and 1
@@ -56,9 +58,11 @@ const createRandomInt = exports.createRandomInt = /* #__PURE__ */(0, _factory.fa
    * @return {number | Array | Matrix} A random integer value
    */
   return typed(name, {
-    '': () => _randomInt(0, 1),
+    '': () => _randomInt(0, 2),
     number: max => _randomInt(0, max),
     'number, number': (min, max) => _randomInt(min, max),
+    bigint: max => _randomBigint(0n, max),
+    'bigint, bigint': _randomBigint,
     'Array | Matrix': size => _randomIntMatrix(size, 0, 1),
     'Array | Matrix, number': (size, max) => _randomIntMatrix(size, 0, max),
     'Array | Matrix, number, number': (size, min, max) => _randomIntMatrix(size, min, max)
@@ -70,4 +74,23 @@ const createRandomInt = exports.createRandomInt = /* #__PURE__ */(0, _factory.fa
   function _randomInt(min, max) {
     return Math.floor(min + rng() * (max - min));
   }
+  function _randomBigint(min, max) {
+    const width = max - min; // number of choices
+    if (width <= simpleCutoff) {
+      // do it with number type
+      return min + BigInt(_randomInt(0, Number(width)));
+    }
+    // Too big to choose accurately that way. Instead, choose the correct
+    // number of random bits to cover the width, and repeat until the
+    // resulting number falls within the width
+    const bits = log2(width);
+    let picked = width;
+    while (picked >= width) {
+      picked = 0n;
+      for (let i = 0; i < bits; ++i) {
+        picked = 2n * picked + (rng() < 0.5 ? 0n : 1n);
+      }
+    }
+    return min + picked;
+  }
 });