mathjs 13.2.3 → 14.0.1

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/algebra/simplify.js

@@ -11,7 +11,7 @@ var _util = require("./simplify/util.js");
 var _object = require("../../utils/object.js");
 var _map = require("../../utils/map.js");
 const name = 'simplify';
-const dependencies = ['typed', 'parse', 'equal', 'resolve', 'simplifyConstant', 'simplifyCore', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'ParenthesisNode', 'SymbolNode'];
+const dependencies = ['typed', 'parse', 'equal', 'resolve', 'simplifyConstant', 'simplifyCore', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'ParenthesisNode', 'SymbolNode', 'replacer'];
 const createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
     typed,
@@ -28,7 +28,8 @@ const createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.fact
     ObjectNode,
     OperatorNode,
     ParenthesisNode,
-    SymbolNode
+    SymbolNode,
+    replacer
   } = _ref;
   const {
     hasProperty,
@@ -1004,7 +1005,7 @@ const createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.fact
     const uniqueSets = [];
     const unique = {};
     for (let i = 0; i < sets.length; i++) {
-      const s = JSON.stringify(sets[i]);
+      const s = JSON.stringify(sets[i], replacer);
       if (!unique[s]) {
         unique[s] = true;
         uniqueSets.push(sets[i]);

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

@@ -200,17 +200,11 @@ const createSimplifyConstant = exports.createSimplifyConstant = /* #__PURE__ */(
     return new OperatorNode('-', 'unaryMinus', [n]);
   }
   function _fractionToNode(f) {
-    let n;
-    const vn = f.s * f.n;
-    if (vn < 0) {
-      n = new OperatorNode('-', 'unaryMinus', [new ConstantNode(-vn)]);
-    } else {
-      n = new ConstantNode(vn);
-    }
-    if (f.d === 1) {
-      return n;
-    }
-    return new OperatorNode('/', 'divide', [n, new ConstantNode(f.d)]);
+    // note: we convert await from bigint values, because bigint values gives issues with divisions: 1n/2n=0n and not 0.5
+    const fromBigInt = value => config.number === 'BigNumber' && bignumber ? bignumber(value) : Number(value);
+    const numeratorValue = f.s * f.n;
+    const numeratorNode = numeratorValue < 0n ? new OperatorNode('-', 'unaryMinus', [new ConstantNode(-fromBigInt(numeratorValue))]) : new ConstantNode(fromBigInt(numeratorValue));
+    return f.d === 1n ? numeratorNode : new OperatorNode('/', 'divide', [numeratorNode, new ConstantNode(fromBigInt(f.d))]);
   }
 
   /* Handles constant indexing of ArrayNodes, matrices, and ObjectNodes */

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

@@ -76,6 +76,8 @@ const createCeil = exports.createCeil = /* #__PURE__ */(0, _factory.factory)(nam
    *
    *    math.ceil(x)
    *    math.ceil(x, n)
+   *    math.ceil(unit, valuelessUnit)
+   *    math.ceil(unit, n, valuelessUnit)
    *
    * Examples:
    *
@@ -93,6 +95,12 @@ const createCeil = exports.createCeil = /* #__PURE__ */(0, _factory.factory)(nam
    *    math.ceil(c)                 // returns Complex 4 - 2i
    *    math.ceil(c, 1)              // returns Complex 3.3 - 2.7i
    *
+   *    const unit = math.unit('3.241 cm')
+   *    const cm = math.unit('cm')
+   *    const mm = math.unit('mm')
+   *    math.ceil(unit, 1, cm)      // returns Unit 3.3 cm
+   *    math.ceil(unit, 1, mm)      // returns Unit 32.5 mm
+   *
    *    math.ceil([3.2, 3.8, -4.7])  // returns Array [4, 4, -4]
    *    math.ceil([3.21, 3.82, -4.71], 1)  // returns Array [3.3, 3.9, -4.7]
    *
@@ -100,9 +108,10 @@ const createCeil = exports.createCeil = /* #__PURE__ */(0, _factory.factory)(nam
    *
    *    floor, fix, round
    *
-   * @param  {number | BigNumber | Fraction | Complex | Array | Matrix} x  Number to be rounded
+   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x  Value to be rounded
    * @param  {number | BigNumber | Array} [n=0]                            Number of decimals
-   * @return {number | BigNumber | Fraction | Complex | Array | Matrix} Rounded value
+   * @param  {Unit} [valuelessUnit]                                        A valueless unit
+   * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} Rounded value
    */
   return typed('ceil', {
     number: ceilNumber.signatures.number,
@@ -139,6 +148,16 @@ const createCeil = exports.createCeil = /* #__PURE__ */(0, _factory.factory)(nam
     'Fraction, BigNumber': function (x, n) {
       return x.ceil(n.toNumber());
     },
+    'Unit, number, Unit': typed.referToSelf(self => function (x, n, unit) {
+      const valueless = x.toNumeric(unit);
+      return unit.multiply(self(valueless, n));
+    }),
+    'Unit, BigNumber, Unit': typed.referToSelf(self => (x, n, unit) => self(x, n.toNumber(), unit)),
+    'Array | Matrix, number | BigNumber, Unit': typed.referToSelf(self => (x, n, unit) => {
+      // deep map collection, skip zeros since ceil(0) = 0
+      return (0, _collection.deepMap)(x, value => self(value, n, unit), true);
+    }),
+    'Array | Matrix | Unit, Unit': typed.referToSelf(self => (x, unit) => self(x, 0, unit)),
     'Array | Matrix': typed.referToSelf(self => x => {
       // deep map collection, skip zeros since ceil(0) = 0
       return (0, _collection.deepMap)(x, self, true);

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

@@ -12,7 +12,7 @@ var _matAlgo11xS0s = require("../../type/matrix/utils/matAlgo11xS0s.js");
 var _matAlgo12xSfs = require("../../type/matrix/utils/matAlgo12xSfs.js");
 var _matrixAlgorithmSuite = require("../../type/matrix/utils/matrixAlgorithmSuite.js");
 const name = 'dotDivide';
-const dependencies = ['typed', 'matrix', 'equalScalar', 'divideScalar', 'DenseMatrix', 'concat'];
+const dependencies = ['typed', 'matrix', 'equalScalar', 'divideScalar', 'DenseMatrix', 'concat', 'SparseMatrix'];
 const createDotDivide = exports.createDotDivide = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
     typed,
@@ -20,7 +20,8 @@ const createDotDivide = exports.createDotDivide = /* #__PURE__ */(0, _factory.fa
     equalScalar,
     divideScalar,
     DenseMatrix,
-    concat
+    concat,
+    SparseMatrix
   } = _ref;
   const matAlgo02xDS0 = (0, _matAlgo02xDS.createMatAlgo02xDS0)({
     typed,
@@ -31,7 +32,7 @@ const createDotDivide = exports.createDotDivide = /* #__PURE__ */(0, _factory.fa
   });
   const matAlgo07xSSf = (0, _matAlgo07xSSf.createMatAlgo07xSSf)({
     typed,
-    DenseMatrix
+    SparseMatrix
   });
   const matAlgo11xS0s = (0, _matAlgo11xS0s.createMatAlgo11xS0s)({
     typed,

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

@@ -11,7 +11,7 @@ var _matAlgo11xS0s = require("../../type/matrix/utils/matAlgo11xS0s.js");
 var _matAlgo12xSfs = require("../../type/matrix/utils/matAlgo12xSfs.js");
 var _matrixAlgorithmSuite = require("../../type/matrix/utils/matrixAlgorithmSuite.js");
 const name = 'dotPow';
-const dependencies = ['typed', 'equalScalar', 'matrix', 'pow', 'DenseMatrix', 'concat'];
+const dependencies = ['typed', 'equalScalar', 'matrix', 'pow', 'DenseMatrix', 'concat', 'SparseMatrix'];
 const createDotPow = exports.createDotPow = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
     typed,
@@ -19,14 +19,15 @@ const createDotPow = exports.createDotPow = /* #__PURE__ */(0, _factory.factory)
     matrix,
     pow,
     DenseMatrix,
-    concat
+    concat,
+    SparseMatrix
   } = _ref;
   const matAlgo03xDSf = (0, _matAlgo03xDSf.createMatAlgo03xDSf)({
     typed
   });
   const matAlgo07xSSf = (0, _matAlgo07xSSf.createMatAlgo07xSSf)({
     typed,
-    DenseMatrix
+    SparseMatrix
   });
   const matAlgo11xS0s = (0, _matAlgo11xS0s.createMatAlgo11xS0s)({
     typed,

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

@@ -56,6 +56,8 @@ const createFix = exports.createFix = /* #__PURE__ */(0, _factory.factory)(name,
    *
    *    math.fix(x)
    *    math.fix(x,n)
+   *    math.fix(unit, valuelessUnit)
+   *    math.fix(unit, n, valuelessUnit)
    *
    * Examples:
    *
@@ -73,6 +75,12 @@ const createFix = exports.createFix = /* #__PURE__ */(0, _factory.factory)(name,
    *    math.fix(c)                  // returns Complex 3 - 2i
    *    math.fix(c, 1)               // returns Complex 3.2 -2.7i
    *
+   *    const unit = math.unit('3.241 cm')
+   *    const cm = math.unit('cm')
+   *    const mm = math.unit('mm')
+   *    math.fix(unit, 1, cm)      // returns Unit 3.2 cm
+   *    math.fix(unit, 1, mm)      // returns Unit 32.4 mm
+   *
    *    math.fix([3.2, 3.8, -4.7])      // returns Array [3, 3, -4]
    *    math.fix([3.2, 3.8, -4.7], 1)   // returns Array [3.2, 3.8, -4.7]
    *
@@ -80,9 +88,10 @@ const createFix = exports.createFix = /* #__PURE__ */(0, _factory.factory)(name,
    *
    *    ceil, floor, round
    *
-   * @param  {number | BigNumber | Fraction | Complex | Array | Matrix} x    Number to be rounded
-   * @param  {number | BigNumber | Array} [n=0]                             Number of decimals
-   * @return {number | BigNumber | Fraction | Complex | Array | Matrix}     Rounded value
+   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x  Value to be rounded
+   * @param  {number | BigNumber | Array} [n=0]                            Number of decimals
+   * @param  {Unit} [valuelessUnit]                                        A valueless unit
+   * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} Rounded value
    */
   return typed('fix', {
     number: fixNumber.signatures.number,
@@ -104,11 +113,21 @@ const createFix = exports.createFix = /* #__PURE__ */(0, _factory.factory)(name,
       return x.isNegative() ? ceil(x, n) : floor(x, n);
     },
     Fraction: function (x) {
-      return x.s < 0 ? x.ceil() : x.floor();
+      return x.s < 0n ? x.ceil() : x.floor();
     },
     'Fraction, number | BigNumber': function (x, n) {
-      return x.s < 0 ? ceil(x, n) : floor(x, n);
+      return x.s < 0n ? ceil(x, n) : floor(x, n);
     },
+    'Unit, number, Unit': typed.referToSelf(self => function (x, n, unit) {
+      const valueless = x.toNumeric(unit);
+      return unit.multiply(self(valueless, n));
+    }),
+    'Unit, BigNumber, Unit': typed.referToSelf(self => (x, n, unit) => self(x, n.toNumber(), unit)),
+    'Array | Matrix, number | BigNumber, Unit': typed.referToSelf(self => (x, n, unit) => {
+      // deep map collection, skip zeros since fix(0) = 0
+      return (0, _collection.deepMap)(x, value => self(value, n, unit), true);
+    }),
+    'Array | Matrix | Unit, Unit': typed.referToSelf(self => (x, unit) => self(x, 0, unit)),
     'Array | Matrix': typed.referToSelf(self => x => {
       // deep map collection, skip zeros since fix(0) = 0
       return (0, _collection.deepMap)(x, self, true);

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

@@ -75,6 +75,8 @@ const createFloor = exports.createFloor = /* #__PURE__ */(0, _factory.factory)(n
    *
    *    math.floor(x)
    *    math.floor(x, n)
+   *    math.floor(unit, valuelessUnit)
+   *    math.floor(unit, n, valuelessUnit)
    *
    * Examples:
    *
@@ -92,6 +94,12 @@ const createFloor = exports.createFloor = /* #__PURE__ */(0, _factory.factory)(n
    *    math.floor(c)                 // returns Complex 3 - 3i
    *    math.floor(c, 1)              // returns Complex 3.2 -2.8i
    *
+   *    const unit = math.unit('3.241 cm')
+   *    const cm = math.unit('cm')
+   *    const mm = math.unit('mm')
+   *    math.floor(unit, 1, cm)      // returns Unit 3.2 cm
+   *    math.floor(unit, 1, mm)      // returns Unit 32.4 mm
+   *
    *    math.floor([3.2, 3.8, -4.7])       // returns Array [3, 3, -5]
    *    math.floor([3.21, 3.82, -4.71], 1)  // returns Array [3.2, 3.8, -4.8]
    *
@@ -103,9 +111,10 @@ const createFloor = exports.createFloor = /* #__PURE__ */(0, _factory.factory)(n
    *
    *    ceil, fix, round
    *
-   * @param  {number | BigNumber | Fraction | Complex | Array | Matrix} x  Number to be rounded
+   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x  Value to be rounded
    * @param  {number | BigNumber | Array} [n=0]                            Number of decimals
-   * @return {number | BigNumber | Fraction | Complex | Array | Matrix} Rounded value
+   * @param  {Unit} [valuelessUnit]                                        A valueless unit
+   * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} Rounded value
    */
   return typed('floor', {
     number: floorNumber.signatures.number,
@@ -142,6 +151,16 @@ const createFloor = exports.createFloor = /* #__PURE__ */(0, _factory.factory)(n
     'Fraction, BigNumber': function (x, n) {
       return x.floor(n.toNumber());
     },
+    'Unit, number, Unit': typed.referToSelf(self => function (x, n, unit) {
+      const valueless = x.toNumeric(unit);
+      return unit.multiply(self(valueless, n));
+    }),
+    'Unit, BigNumber, Unit': typed.referToSelf(self => (x, n, unit) => self(x, n.toNumber(), unit)),
+    'Array | Matrix, number | BigNumber, Unit': typed.referToSelf(self => (x, n, unit) => {
+      // deep map collection, skip zeros since floor(0) = 0
+      return (0, _collection.deepMap)(x, value => self(value, n, unit), true);
+    }),
+    'Array | Matrix | Unit, Unit': typed.referToSelf(self => (x, unit) => self(x, 0, unit)),
     'Array | Matrix': typed.referToSelf(self => x => {
       // deep map collection, skip zeros since floor(0) = 0
       return (0, _collection.deepMap)(x, self, true);

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

@@ -7,10 +7,11 @@ exports.createLog = void 0;
 var _factory = require("../../utils/factory.js");
 var _index = require("../../plain/number/index.js");
 const name = 'log';
-const dependencies = ['config', 'typed', 'divideScalar', 'Complex'];
+const dependencies = ['config', 'typed', 'typeOf', 'divideScalar', 'Complex'];
 const createLog = exports.createLog = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
     typed,
+    typeOf,
     config,
     divideScalar,
     Complex
@@ -42,12 +43,12 @@ const createLog = exports.createLog = /* #__PURE__ */(0, _factory.factory)(name,
    *
    *    exp, log2, log10, log1p
    *
-   * @param {number | BigNumber | Complex} x
+   * @param {number | BigNumber | Fraction | Complex} x
    *            Value for which to calculate the logarithm.
-   * @param {number | BigNumber | Complex} [base=e]
+   * @param {number | BigNumber | Fraction | Complex} [base=e]
    *            Optional base for the logarithm. If not provided, the natural
    *            logarithm of `x` is calculated.
-   * @return {number | BigNumber | Complex}
+   * @return {number | BigNumber | Fraction | Complex}
    *            Returns the logarithm of `x`
    */
   return typed(name, {
@@ -72,6 +73,13 @@ const createLog = exports.createLog = /* #__PURE__ */(0, _factory.factory)(name,
     },
     'any, any': typed.referToSelf(self => (x, base) => {
       // calculate logarithm for a specified base, log(x, base)
+
+      if (typeOf(x) === 'Fraction' && typeOf(base) === 'Fraction') {
+        const result = x.log(base);
+        if (result !== null) {
+          return result;
+        }
+      }
       return divideScalar(self(x), self(base));
     })
   });

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

@@ -113,8 +113,8 @@ const createPow = exports.createPow = /* #__PURE__ */(0, _factory.factory)(name,
         const yFrac = fraction(y);
         const yNum = number(yFrac);
         if (y === yNum || Math.abs((y - yNum) / y) < 1e-14) {
-          if (yFrac.d % 2 === 1) {
-            return (yFrac.n % 2 === 0 ? 1 : -1) * Math.pow(-x, y);
+          if (yFrac.d % 2n === 1n) {
+            return (yFrac.n % 2n === 0n ? 1 : -1) * Math.pow(-x, y);
           }
         }
       } catch (ex) {