mathjs 13.2.3 → 14.0.1

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

@@ -5,7 +5,7 @@ import { createUtil } from './simplify/util.js';
 import { hasOwnProperty } from '../../utils/object.js';
 import { createEmptyMap, createMap } from '../../utils/map.js';
 var name = 'simplify';
-var dependencies = ['typed', 'parse', 'equal', 'resolve', 'simplifyConstant', 'simplifyCore', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'ParenthesisNode', 'SymbolNode'];
+var dependencies = ['typed', 'parse', 'equal', 'resolve', 'simplifyConstant', 'simplifyCore', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'ParenthesisNode', 'SymbolNode', 'replacer'];
 export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -22,7 +22,8 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
     ObjectNode,
     OperatorNode,
     ParenthesisNode,
-    SymbolNode
+    SymbolNode,
+    replacer
   } = _ref;
   var {
     hasProperty,
@@ -998,7 +999,7 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
     var uniqueSets = [];
     var unique = {};
     for (var i = 0; i < sets.length; i++) {
-      var s = JSON.stringify(sets[i]);
+      var s = JSON.stringify(sets[i], replacer);
       if (!unique[s]) {
         unique[s] = true;
         uniqueSets.push(sets[i]);

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

@@ -194,17 +194,11 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
     return new OperatorNode('-', 'unaryMinus', [n]);
   }
   function _fractionToNode(f) {
-    var n;
-    var 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
+    var fromBigInt = value => config.number === 'BigNumber' && bignumber ? bignumber(value) : Number(value);
+    var numeratorValue = f.s * f.n;
+    var 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/esm/function/arithmetic/ceil.js

@@ -69,6 +69,8 @@ export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref2 => {
    *
    *    math.ceil(x)
    *    math.ceil(x, n)
+   *    math.ceil(unit, valuelessUnit)
+   *    math.ceil(unit, n, valuelessUnit)
    *
    * Examples:
    *
@@ -86,6 +88,12 @@ export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref2 => {
    *    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]
    *
@@ -93,9 +101,10 @@ export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref2 => {
    *
    *    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,
@@ -132,6 +141,16 @@ export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref2 => {
     'Fraction, BigNumber': function Fraction_BigNumber(x, n) {
       return x.ceil(n.toNumber());
     },
+    'Unit, number, Unit': typed.referToSelf(self => function (x, n, unit) {
+      var 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 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 deepMap(x, self, true);

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

@@ -6,7 +6,7 @@ import { createMatAlgo11xS0s } from '../../type/matrix/utils/matAlgo11xS0s.js';
 import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
 import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 var name = 'dotDivide';
-var dependencies = ['typed', 'matrix', 'equalScalar', 'divideScalar', 'DenseMatrix', 'concat'];
+var dependencies = ['typed', 'matrix', 'equalScalar', 'divideScalar', 'DenseMatrix', 'concat', 'SparseMatrix'];
 export var createDotDivide = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -14,7 +14,8 @@ export var createDotDivide = /* #__PURE__ */factory(name, dependencies, _ref =>
     equalScalar,
     divideScalar,
     DenseMatrix,
-    concat
+    concat,
+    SparseMatrix
   } = _ref;
   var matAlgo02xDS0 = createMatAlgo02xDS0({
     typed,
@@ -25,7 +26,7 @@ export var createDotDivide = /* #__PURE__ */factory(name, dependencies, _ref =>
   });
   var matAlgo07xSSf = createMatAlgo07xSSf({
     typed,
-    DenseMatrix
+    SparseMatrix
   });
   var matAlgo11xS0s = createMatAlgo11xS0s({
     typed,

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

@@ -5,7 +5,7 @@ import { createMatAlgo11xS0s } from '../../type/matrix/utils/matAlgo11xS0s.js';
 import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
 import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 var name = 'dotPow';
-var dependencies = ['typed', 'equalScalar', 'matrix', 'pow', 'DenseMatrix', 'concat'];
+var dependencies = ['typed', 'equalScalar', 'matrix', 'pow', 'DenseMatrix', 'concat', 'SparseMatrix'];
 export var createDotPow = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -13,14 +13,15 @@ export var createDotPow = /* #__PURE__ */factory(name, dependencies, _ref => {
     matrix,
     pow,
     DenseMatrix,
-    concat
+    concat,
+    SparseMatrix
   } = _ref;
   var matAlgo03xDSf = createMatAlgo03xDSf({
     typed
   });
   var matAlgo07xSSf = createMatAlgo07xSSf({
     typed,
-    DenseMatrix
+    SparseMatrix
   });
   var matAlgo11xS0s = createMatAlgo11xS0s({
     typed,

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

@@ -50,6 +50,8 @@ export var createFix = /* #__PURE__ */factory(name, dependencies, _ref2 => {
    *
    *    math.fix(x)
    *    math.fix(x,n)
+   *    math.fix(unit, valuelessUnit)
+   *    math.fix(unit, n, valuelessUnit)
    *
    * Examples:
    *
@@ -67,6 +69,12 @@ export var createFix = /* #__PURE__ */factory(name, dependencies, _ref2 => {
    *    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]
    *
@@ -74,9 +82,10 @@ export var createFix = /* #__PURE__ */factory(name, dependencies, _ref2 => {
    *
    *    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,
@@ -98,11 +107,21 @@ export var createFix = /* #__PURE__ */factory(name, dependencies, _ref2 => {
       return x.isNegative() ? ceil(x, n) : floor(x, n);
     },
     Fraction: function Fraction(x) {
-      return x.s < 0 ? x.ceil() : x.floor();
+      return x.s < 0n ? x.ceil() : x.floor();
     },
     'Fraction, number | BigNumber': function Fraction_number__BigNumber(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) {
+      var 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 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 deepMap(x, self, true);

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

@@ -68,6 +68,8 @@ export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref2 => {
    *
    *    math.floor(x)
    *    math.floor(x, n)
+   *    math.floor(unit, valuelessUnit)
+   *    math.floor(unit, n, valuelessUnit)
    *
    * Examples:
    *
@@ -85,6 +87,12 @@ export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref2 => {
    *    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]
    *
@@ -96,9 +104,10 @@ export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref2 => {
    *
    *    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,
@@ -135,6 +144,16 @@ export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref2 => {
     'Fraction, BigNumber': function Fraction_BigNumber(x, n) {
       return x.floor(n.toNumber());
     },
+    'Unit, number, Unit': typed.referToSelf(self => function (x, n, unit) {
+      var 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 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 deepMap(x, self, true);

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

@@ -1,10 +1,11 @@
 import { factory } from '../../utils/factory.js';
 import { logNumber } from '../../plain/number/index.js';
 var name = 'log';
-var dependencies = ['config', 'typed', 'divideScalar', 'Complex'];
+var dependencies = ['config', 'typed', 'typeOf', 'divideScalar', 'Complex'];
 export var createLog = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
+    typeOf,
     config,
     divideScalar,
     Complex
@@ -36,12 +37,12 @@ export var createLog = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    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, {
@@ -66,6 +67,13 @@ export var createLog = /* #__PURE__ */factory(name, dependencies, _ref => {
     },
     'any, any': typed.referToSelf(self => (x, base) => {
       // calculate logarithm for a specified base, log(x, base)
+
+      if (typeOf(x) === 'Fraction' && typeOf(base) === 'Fraction') {
+        var result = x.log(base);
+        if (result !== null) {
+          return result;
+        }
+      }
       return divideScalar(self(x), self(base));
     })
   });

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

@@ -107,8 +107,8 @@ export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
         var yFrac = fraction(y);
         var 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) {