mathjs 14.0.0 → 14.1.0

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

@@ -60,9 +60,18 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
     var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
       simplify: true
     };
-    var constNodes = {};
-    constTag(constNodes, expr, variable.name);
-    var res = _derivative(expr, constNodes);
+    var cache = new Map();
+    var variableName = variable.name;
+    function isConstCached(node) {
+      var cached = cache.get(node);
+      if (cached !== undefined) {
+        return cached;
+      }
+      var res = _isConst(isConstCached, node, variableName);
+      cache.set(node, res);
+      return res;
+    }
+    var res = _derivative(expr, isConstCached);
     return options.simplify ? simplify(res) : res;
   }
   function parseIdentifier(string) {
@@ -82,9 +91,8 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
     '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
     }
@@ -127,56 +135,39 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
   });
 
   /**
-   * 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?
-  var constTag = typed('constTag', {
-    'Object, ConstantNode, string': function Object_ConstantNode_string(constNodes, node) {
-      constNodes[node] = true;
+  var _isConst = typed('_isConst', {
+    'function, ConstantNode, string': function function_ConstantNode_string() {
       return true;
     },
-    'Object, SymbolNode, string': function Object_SymbolNode_string(constNodes, node, varName) {
+    'function, SymbolNode, string': function function_SymbolNode_string(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 Object_ParenthesisNode_string(constNodes, node, varName) {
-      return constTag(constNodes, node.content, varName);
+    'function, ParenthesisNode, string': function function_ParenthesisNode_string(isConst, node, varName) {
+      return isConst(node.content, varName);
     },
-    'Object, FunctionAssignmentNode, string': function Object_FunctionAssignmentNode_string(constNodes, node, varName) {
+    'function, FunctionAssignmentNode, string': function function_FunctionAssignmentNode_string(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 Object_FunctionNode__OperatorNode_string(constNodes, node, varName) {
-      if (node.args.length > 0) {
-        var isConst = constTag(constNodes, node.args[0], varName);
-        for (var 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 function_FunctionNode__OperatorNode_string(isConst, node, varName) {
+      return node.args.every(arg => isConst(arg, varName));
     }
   });
 
@@ -184,30 +175,30 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
    * 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`
    */
   var _derivative = typed('_derivative', {
-    'ConstantNode, Object': function ConstantNode_Object(node) {
+    'ConstantNode, function': function ConstantNode_function() {
       return createConstantNode(0);
     },
-    'SymbolNode, Object': function SymbolNode_Object(node, constNodes) {
-      if (constNodes[node] !== undefined) {
+    'SymbolNode, function': function SymbolNode_function(node, isConst) {
+      if (isConst(node)) {
         return createConstantNode(0);
       }
       return createConstantNode(1);
     },
-    'ParenthesisNode, Object': function ParenthesisNode_Object(node, constNodes) {
-      return new ParenthesisNode(_derivative(node.content, constNodes));
+    'ParenthesisNode, function': function ParenthesisNode_function(node, isConst) {
+      return new ParenthesisNode(_derivative(node.content, isConst));
     },
-    'FunctionAssignmentNode, Object': function FunctionAssignmentNode_Object(node, constNodes) {
-      if (constNodes[node] !== undefined) {
+    'FunctionAssignmentNode, function': function FunctionAssignmentNode_function(node, isConst) {
+      if (isConst(node)) {
         return createConstantNode(0);
       }
-      return _derivative(node.expr, constNodes);
+      return _derivative(node.expr, isConst);
     },
-    'FunctionNode, Object': function FunctionNode_Object(node, constNodes) {
-      if (constNodes[node] !== undefined) {
+    'FunctionNode, function': function FunctionNode_function(node, isConst) {
+      if (isConst(node)) {
         return createConstantNode(0);
       }
       var arg0 = node.args[0];
@@ -231,10 +222,7 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
           } 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':
@@ -245,20 +233,19 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
             // 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':
@@ -404,51 +391,51 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
       /* Apply chain rule to all functions:
          F(x)  = f(g(x))
          F'(x) = g'(x)*f'(g(x)) */
-      var chainDerivative = _derivative(arg0, constNodes);
+      var chainDerivative = _derivative(arg0, isConst);
       if (negative) {
         chainDerivative = new OperatorNode('-', 'unaryMinus', [chainDerivative]);
       }
       return new OperatorNode(op, func, [chainDerivative, funcDerivative]);
     },
-    'OperatorNode, Object': function OperatorNode_Object(node, constNodes) {
-      if (constNodes[node] !== undefined) {
+    'OperatorNode, function': function OperatorNode_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)
         var constantTerms = node.args.filter(function (arg) {
-          return constNodes[arg] !== undefined;
+          return isConst(arg);
         });
         if (constantTerms.length > 0) {
           var nonConstantTerms = node.args.filter(function (arg) {
-            return constNodes[arg] === undefined;
+            return !isConst(arg);
           });
           var nonConstantNode = nonConstantTerms.length === 1 ? nonConstantTerms[0] : new OperatorNode('*', 'multiply', nonConstantTerms);
-          var newArgs = constantTerms.concat(_derivative(nonConstantNode, constNodes));
+          var 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();
           }));
         }));
       }
@@ -457,31 +444,31 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
         var 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()) {
         var _arg = node.args[0];
         var _arg2 = node.args[1];
-        if (constNodes[_arg] !== undefined) {
+        if (isConst(_arg)) {
           // If is secretly constant; 0^f(x) = 1 (in JS), 1^f(x) = 1
           if (isConstantNode(_arg) && (isZero(_arg.value) || equal(_arg.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', [_arg.clone()]), _derivative(_arg2.clone(), constNodes)])]);
+          return new OperatorNode('*', 'multiply', [node, new OperatorNode('*', 'multiply', [new FunctionNode('log', [_arg.clone()]), _derivative(_arg2.clone(), isConst)])]);
         }
-        if (constNodes[_arg2] !== undefined) {
+        if (isConst(_arg2)) {
           if (isConstantNode(_arg2)) {
             // If is secretly constant; f(x)^0 = 1 -> d/dx(1) = 0
             if (isZero(_arg2.value)) {
@@ -489,17 +476,17 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
             }
             // Ignore exponent; f(x)^1 = f(x)
             if (equal(_arg2.value, 1)) {
-              return _derivative(_arg, constNodes);
+              return _derivative(_arg, isConst);
             }
           }
 
           // Elementary Power Rule, d/dx(f(x)^c) = c*f'(x)*f(x)^(c-1)
           var powMinusOne = new OperatorNode('^', 'pow', [_arg.clone(), new OperatorNode('-', 'subtract', [_arg2, createConstantNode(1)])]);
-          return new OperatorNode('*', 'multiply', [_arg2.clone(), new OperatorNode('*', 'multiply', [_derivative(_arg, constNodes), powMinusOne])]);
+          return new OperatorNode('*', 'multiply', [_arg2.clone(), new OperatorNode('*', 'multiply', [_derivative(_arg, isConst), powMinusOne])]);
         }
 
         // Functional Power Rule, d/dx(f^g) = f^g*[f'*(g/f) + g'ln(f)]
-        return new OperatorNode('*', 'multiply', [new OperatorNode('^', 'pow', [_arg.clone(), _arg2.clone()]), new OperatorNode('+', 'add', [new OperatorNode('*', 'multiply', [_derivative(_arg, constNodes), new OperatorNode('/', 'divide', [_arg2.clone(), _arg.clone()])]), new OperatorNode('*', 'multiply', [_derivative(_arg2, constNodes), new FunctionNode('log', [_arg.clone()])])])]);
+        return new OperatorNode('*', 'multiply', [new OperatorNode('^', 'pow', [_arg.clone(), _arg2.clone()]), new OperatorNode('+', 'add', [new OperatorNode('*', 'multiply', [_derivative(_arg, isConst), new OperatorNode('/', 'divide', [_arg2.clone(), _arg.clone()])]), new OperatorNode('*', 'multiply', [_derivative(_arg2, isConst), new FunctionNode('log', [_arg.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/esm/function/arithmetic/log.js

@@ -1,7 +1,9 @@
 import { factory } from '../../utils/factory.js';
+import { promoteLogarithm } from '../../utils/bigint.js';
 import { logNumber } from '../../plain/number/index.js';
 var name = 'log';
 var dependencies = ['config', 'typed', 'typeOf', 'divideScalar', 'Complex'];
+var nlg16 = Math.log(16);
 export var createLog = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -45,24 +47,29 @@ export var createLog = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @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 number(x) {
       if (x >= 0 || config.predictable) {
         return logNumber(x);
       } else {
         // negative value -> complex value computation
-        return new Complex(x, 0).log();
+        return complexLogNumber(x);
       }
     },
-    Complex: function Complex(x) {
-      return x.log();
-    },
+    bigint: promoteLogarithm(nlg16, logNumber, config, complexLogNumber),
+    Complex: complexLog,
     BigNumber: function BigNumber(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/esm/function/arithmetic/log10.js

@@ -1,13 +1,15 @@
-import { factory } from '../../utils/factory.js';
-import { deepMap } from '../../utils/collection.js';
 import { log10Number } from '../../plain/number/index.js';
+import { promoteLogarithm } from '../../utils/bigint.js';
+import { deepMap } from '../../utils/collection.js';
+import { factory } from '../../utils/factory.js';
 var name = 'log10';
 var dependencies = ['typed', 'config', 'Complex'];
+var log16 = log10Number(16);
 export var createLog10 = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     config,
-    Complex: _Complex
+    Complex
   } = _ref;
   /**
    * Calculate the 10-base logarithm of a value. This is the same as calculating `log(x, 10)`.
@@ -34,24 +36,30 @@ export var createLog10 = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @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 number(x) {
       if (x >= 0 || config.predictable) {
         return log10Number(x);
       } else {
         // negative value -> complex value computation
-        return new _Complex(x, 0).log().div(Math.LN10);
+        return complexLogNumber(x);
       }
     },
-    Complex: function Complex(x) {
-      return new _Complex(x).log().div(Math.LN10);
-    },
+    bigint: promoteLogarithm(log16, log10Number, config, complexLogNumber),
+    Complex: complexLog,
     BigNumber: function BigNumber(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 => deepMap(x, self))

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

@@ -1,6 +1,7 @@
-import { factory } from '../../utils/factory.js';
-import { deepMap } from '../../utils/collection.js';
 import { log2Number } from '../../plain/number/index.js';
+import { promoteLogarithm } from '../../utils/bigint.js';
+import { deepMap } from '../../utils/collection.js';
+import { factory } from '../../utils/factory.js';
 var name = 'log2';
 var dependencies = ['typed', 'config', 'Complex'];
 export var createLog2 = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -34,22 +35,26 @@ export var createLog2 = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @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 number(x) {
       if (x >= 0 || config.predictable) {
         return log2Number(x);
       } else {
         // negative value -> complex value computation
-        return _log2Complex(new Complex(x, 0));
+        return complexLog2Number(x);
       }
     },
+    bigint: promoteLogarithm(4, log2Number, config, complexLog2Number),
     Complex: _log2Complex,
     BigNumber: function BigNumber(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 => deepMap(x, self))

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

@@ -3,11 +3,13 @@ import { randomMatrix } from './util/randomMatrix.js';
 import { createRng } from './util/seededRNG.js';
 import { isMatrix } from '../../utils/is.js';
 var name = 'randomInt';
-var dependencies = ['typed', 'config', '?on'];
+var dependencies = ['typed', 'config', 'log2', '?on'];
+var simpleCutoff = 2n ** 30n;
 export var createRandomInt = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     config,
+    log2,
     on
   } = _ref;
   // seeded pseudo random number generator
@@ -26,7 +28,7 @@ export var createRandomInt = /* #__PURE__ */factory(name, dependencies, _ref =>
    *
    * 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
@@ -50,9 +52,11 @@ export var createRandomInt = /* #__PURE__ */factory(name, dependencies, _ref =>
    * @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)
@@ -64,4 +68,23 @@ export var createRandomInt = /* #__PURE__ */factory(name, dependencies, _ref =>
   function _randomInt(min, max) {
     return Math.floor(min + rng() * (max - min));
   }
+  function _randomBigint(min, max) {
+    var 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
+    var bits = log2(width);
+    var picked = width;
+    while (picked >= width) {
+      picked = 0n;
+      for (var i = 0; i < bits; ++i) {
+        picked = 2n * picked + (rng() < 0.5 ? 0n : 1n);
+      }
+    }
+    return min + picked;
+  }
 });

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

@@ -7,11 +7,12 @@ import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
 import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 import { createCompareUnits } from './compareUnits.js';
 var name = 'larger';
-var dependencies = ['typed', 'config', 'matrix', 'DenseMatrix', 'concat', 'SparseMatrix'];
+var dependencies = ['typed', 'config', 'bignumber', 'matrix', 'DenseMatrix', 'concat', 'SparseMatrix'];
 export var createLarger = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     config,
+    bignumber,
     matrix,
     DenseMatrix,
     concat,
@@ -68,16 +69,23 @@ export var createLarger = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @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
    */
+  function bignumLarger(x, y) {
+    return x.gt(y) && !bigNearlyEqual(x, y, config.relTol, config.absTol);
+  }
   return typed(name, createLargerNumber({
     typed,
     config
   }), {
     'boolean, boolean': (x, y) => x > y,
-    'BigNumber, BigNumber': function BigNumber_BigNumber(x, y) {
-      return x.gt(y) && !bigNearlyEqual(x, y, config.relTol, config.absTol);
-    },
+    'BigNumber, BigNumber': bignumLarger,
     'bigint, bigint': (x, y) => x > y,
     'Fraction, Fraction': (x, y) => x.compare(y) === 1,
+    'Fraction, BigNumber': function Fraction_BigNumber(x, y) {
+      return bignumLarger(bignumber(x), y);
+    },
+    'BigNumber, Fraction': function BigNumber_Fraction(x, y) {
+      return bignumLarger(x, bignumber(y));
+    },
     'Complex, Complex': function Complex_Complex() {
       throw new TypeError('No ordering relation is defined for complex numbers');
     }

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

@@ -7,11 +7,12 @@ import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
 import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 import { createCompareUnits } from './compareUnits.js';
 var name = 'smaller';
-var dependencies = ['typed', 'config', 'matrix', 'DenseMatrix', 'concat', 'SparseMatrix'];
+var dependencies = ['typed', 'config', 'bignumber', 'matrix', 'DenseMatrix', 'concat', 'SparseMatrix'];
 export var createSmaller = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     config,
+    bignumber,
     matrix,
     DenseMatrix,
     concat,
@@ -68,16 +69,23 @@ export var createSmaller = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @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
    */
+  function bignumSmaller(x, y) {
+    return x.lt(y) && !bigNearlyEqual(x, y, config.relTol, config.absTol);
+  }
   return typed(name, createSmallerNumber({
     typed,
     config
   }), {
     'boolean, boolean': (x, y) => x < y,
-    'BigNumber, BigNumber': function BigNumber_BigNumber(x, y) {
-      return x.lt(y) && !bigNearlyEqual(x, y, config.relTol, config.absTol);
-    },
+    'BigNumber, BigNumber': bignumSmaller,
     'bigint, bigint': (x, y) => x < y,
     'Fraction, Fraction': (x, y) => x.compare(y) === -1,
+    'Fraction, BigNumber': function Fraction_BigNumber(x, y) {
+      return bignumSmaller(bignumber(x), y);
+    },
+    'BigNumber, Fraction': function BigNumber_Fraction(x, y) {
+      return bignumSmaller(x, bignumber(y));
+    },
     'Complex, Complex': function Complex_Complex(x, y) {
       throw new TypeError('No ordering relation is defined for complex numbers');
     }

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

@@ -83,7 +83,7 @@ export var createMax = /* #__PURE__ */factory(name, dependencies, _ref => {
     var res;
     deepForEach(array, function (value) {
       try {
-        if (isNaN(value) && typeof value === 'number') {
+        if (typeof value === 'number' && isNaN(value)) {
           res = NaN;
         } else if (res === undefined || larger(value, res)) {
           res = value;

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

@@ -83,7 +83,7 @@ export var createMin = /* #__PURE__ */factory(name, dependencies, _ref => {
     var min;
     deepForEach(array, function (value) {
       try {
-        if (isNaN(value) && typeof value === 'number') {
+        if (typeof value === 'number' && isNaN(value)) {
           min = NaN;
         } else if (min === undefined || smaller(value, min)) {
           min = value;

package/lib/esm/function/string/print.js

@@ -25,12 +25,12 @@ export var createPrint = /* #__PURE__ */factory(name, dependencies, _ref => {
    *     // the following outputs: 'The value of pi is 3.141592654'
    *     math.print('The value of pi is $pi', {pi: math.pi}, 10)
    *
-   *     // the following outputs: 'hello Mary! The date is 2013-03-23'
+   *     // the following outputs: 'Hello Mary! The date is 2013-03-23'
    *     math.print('Hello $user.name! The date is $date', {
    *       user: {
    *         name: 'Mary',
    *       },
-   *       date: new Date(2013, 2, 23).toISOString().substring(0, 10)
+   *       date: '2013-03-23'
    *     })
    *
    *     // the following outputs: 'My favorite fruits are apples and bananas !'

package/lib/esm/function/utils/isInteger.js

@@ -26,7 +26,7 @@ export var createIsInteger = /* #__PURE__ */factory(name, dependencies, _ref =>
    *    math.isInteger(math.fraction(4))      // returns true
    *    math.isInteger('3')                   // returns true
    *    math.isInteger([3, 0.5, -2])          // returns [true, false, true]
-   *    math.isInteger(math.complex('2-4i'))  // throws an error
+   *    math.isInteger(math.complex('2-4i'))  // throws TypeError
    *
    * See also:
    *

package/lib/esm/header.js

@@ -10,7 +10,7 @@
  * @date    @@date
  *
  * @license
- * Copyright (C) 2013-2024 Jos de Jong <wjosdejong@gmail.com>
+ * Copyright (C) 2013-2025 Jos de Jong <wjosdejong@gmail.com>
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy