mathjs 13.2.2 → 14.0.0

package/lib/esm/expression/parse.js

@@ -932,7 +932,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   function parseAddSubtract(state) {
     var node, name, fn, params;
-    node = parseMultiplyDivide(state);
+    node = parseMultiplyDivideModulusPercentage(state);
     var operators = {
       '+': 'add',
       '-': 'subtract'
@@ -941,7 +941,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
       name = state.token;
       fn = operators[name];
       getTokenSkipNewline(state);
-      var rightNode = parseMultiplyDivide(state);
+      var rightNode = parseMultiplyDivideModulusPercentage(state);
       if (rightNode.isPercentage) {
         params = [node, new OperatorNode('*', 'multiply', [node, rightNode])];
       } else {
@@ -953,11 +953,11 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
   }
 
   /**
-   * multiply, divide
+   * multiply, divide, modulus, percentage
    * @return {Node} node
    * @private
    */
-  function parseMultiplyDivide(state) {
+  function parseMultiplyDivideModulusPercentage(state) {
     var node, last, name, fn;
     node = parseImplicitMultiplication(state);
     last = node;
@@ -965,7 +965,9 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
       '*': 'multiply',
       '.*': 'dotMultiply',
       '/': 'divide',
-      './': 'dotDivide'
+      './': 'dotDivide',
+      '%': 'mod',
+      mod: 'mod'
     };
     while (true) {
       if (hasOwnProperty(operators, state.token)) {
@@ -973,8 +975,23 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
         name = state.token;
         fn = operators[name];
         getTokenSkipNewline(state);
-        last = parseImplicitMultiplication(state);
-        node = new OperatorNode(name, fn, [node, last]);
+        if (name === '%' && state.tokenType === TOKENTYPE.DELIMITER && state.token !== '(') {
+          // If the expression contains only %, then treat that as /100
+          if (state.token !== '' && operators[state.token]) {
+            var left = new OperatorNode('/', 'divide', [node, new ConstantNode(100)], false, true);
+            name = state.token;
+            fn = operators[name];
+            getTokenSkipNewline(state);
+            last = parseImplicitMultiplication(state);
+            node = new OperatorNode(name, fn, [left, last]);
+          } else {
+            node = new OperatorNode('/', 'divide', [node, new ConstantNode(100)], false, true);
+          }
+          // return node
+        } else {
+          last = parseImplicitMultiplication(state);
+          node = new OperatorNode(name, fn, [node, last]);
+        }
       } else {
         break;
       }
@@ -1017,7 +1034,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @private
    */
   function parseRule2(state) {
-    var node = parseModulusPercentage(state);
+    var node = parseUnary(state);
     var last = node;
     var tokenStates = [];
     while (true) {
@@ -1039,7 +1056,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
             // Rewind once and build the "number / number" node; the symbol will be consumed later
             _extends(state, tokenStates.pop());
             tokenStates.pop();
-            last = parseModulusPercentage(state);
+            last = parseUnary(state);
             node = new OperatorNode('/', 'divide', [node, last]);
           } else {
             // Not a match, so rewind
@@ -1059,33 +1076,6 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
     return node;
   }
 
-  /**
-   * modulus and percentage
-   * @return {Node} node
-   * @private
-   */
-  function parseModulusPercentage(state) {
-    var node, name, fn, params;
-    node = parseUnary(state);
-    var operators = {
-      '%': 'mod',
-      mod: 'mod'
-    };
-    while (hasOwnProperty(operators, state.token)) {
-      name = state.token;
-      fn = operators[name];
-      getTokenSkipNewline(state);
-      if (name === '%' && state.tokenType === TOKENTYPE.DELIMITER && state.token !== '(') {
-        // If the expression contains only %, then treat that as /100
-        node = new OperatorNode('/', 'divide', [node, new ConstantNode(100)], false, true);
-      } else {
-        params = [node, parseUnary(state)];
-        node = new OperatorNode(name, fn, params);
-      }
-    }
-    return node;
-  }
-
   /**
    * Unary plus and minus, and logical and bitwise not
    * @return {Node} node

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) {

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

@@ -76,7 +76,7 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @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 | Array | Matrix} Rounded value
+   * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} Rounded value
    */
   return typed(name, {
     number: function number(x) {
@@ -157,13 +157,11 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
       return unit.multiply(self(valueless, n));
     }),
     'Unit, BigNumber, Unit': typed.referToSelf(self => (x, n, unit) => self(x, n.toNumber(), unit)),
-    'Unit, Unit': typed.referToSelf(self => (x, unit) => self(x, 0, unit)),
-    'Array | Matrix, number, Unit': typed.referToSelf(self => (x, n, unit) => {
+    'Array | Matrix, number | BigNumber, Unit': typed.referToSelf(self => (x, n, unit) => {
       // deep map collection, skip zeros since round(0) = 0
       return deepMap(x, value => self(value, n, unit), true);
     }),
-    'Array | Matrix, BigNumber, Unit': typed.referToSelf(self => (x, n, unit) => self(x, n.toNumber(), unit)),
-    'Array | Matrix, Unit': typed.referToSelf(self => (x, unit) => self(x, 0, unit)),
+    '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 round(0) = 0
       return deepMap(x, self, true);

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

@@ -52,7 +52,7 @@ export var createSign = /* #__PURE__ */factory(name, dependencies, _ref => {
       return x > 0n ? 1n : x < 0n ? -1n : 0n;
     },
     Fraction: function Fraction(x) {
-      return new _Fraction(x.s, 1);
+      return new _Fraction(x.s);
     },
     // deep map collection, skip zeros since sign(0) = 0
     'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self, true)),

package/lib/esm/function/bitwise/bitXor.js

@@ -6,20 +6,21 @@ import { factory } from '../../utils/factory.js';
 import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 import { bitXorNumber } from '../../plain/number/index.js';
 var name = 'bitXor';
-var dependencies = ['typed', 'matrix', 'DenseMatrix', 'concat'];
+var dependencies = ['typed', 'matrix', 'DenseMatrix', 'concat', 'SparseMatrix'];
 export var createBitXor = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     matrix,
     DenseMatrix,
-    concat
+    concat,
+    SparseMatrix
   } = _ref;
   var matAlgo03xDSf = createMatAlgo03xDSf({
     typed
   });
   var matAlgo07xSSf = createMatAlgo07xSSf({
     typed,
-    DenseMatrix
+    SparseMatrix
   });
   var matAlgo12xSfs = createMatAlgo12xSfs({
     typed,

package/lib/esm/function/logical/xor.js

@@ -5,20 +5,21 @@ import { factory } from '../../utils/factory.js';
 import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 import { xorNumber } from '../../plain/number/index.js';
 var name = 'xor';
-var dependencies = ['typed', 'matrix', 'DenseMatrix', 'concat'];
+var dependencies = ['typed', 'matrix', 'DenseMatrix', 'concat', 'SparseMatrix'];
 export var createXor = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     matrix,
     DenseMatrix,
-    concat
+    concat,
+    SparseMatrix
   } = _ref;
   var matAlgo03xDSf = createMatAlgo03xDSf({
     typed
   });
   var matAlgo07xSSf = createMatAlgo07xSSf({
     typed,
-    DenseMatrix
+    SparseMatrix
   });
   var matAlgo12xSfs = createMatAlgo12xSfs({
     typed,

package/lib/esm/function/matrix/filter.js

@@ -10,6 +10,13 @@ export var createFilter = /* #__PURE__ */factory(name, dependencies, _ref => {
   /**
    * Filter the items in an array or one dimensional matrix.
    *
+   * The callback is invoked with three arguments: the current value,
+   * the current index, and the matrix operated upon.
+   * Note that because the matrix/array might be
+   * multidimensional, the "index" argument is always an array of numbers giving
+   * the index in each dimension. This is true even for vectors: the "index"
+   * argument is an array of length 1, rather than simply a number.
+   *
    * Syntax:
    *
    *    math.filter(x, test)

package/lib/esm/function/matrix/forEach.js

@@ -10,6 +10,13 @@ export var createForEach = /* #__PURE__ */factory(name, dependencies, _ref => {
   /**
    * Iterate over all elements of a matrix/array, and executes the given callback function.
    *
+   * The callback is invoked with three arguments: the current value,
+   * the current index, and the matrix operated upon.
+   * Note that because the matrix/array might be
+   * multidimensional, the "index" argument is always an array of numbers giving
+   * the index in each dimension. This is true even for vectors: the "index"
+   * argument is an array of length 1, rather than simply a number.
+   *
    * Syntax:
    *
    *    math.forEach(x, callback)

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

@@ -4,21 +4,22 @@ import { createMatAlgo07xSSf } from '../../type/matrix/utils/matAlgo07xSSf.js';
 import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
 import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 var name = 'equal';
-var dependencies = ['typed', 'matrix', 'equalScalar', 'DenseMatrix', 'concat'];
+var dependencies = ['typed', 'matrix', 'equalScalar', 'DenseMatrix', 'concat', 'SparseMatrix'];
 export var createEqual = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     matrix,
     equalScalar,
     DenseMatrix,
-    concat
+    concat,
+    SparseMatrix
   } = _ref;
   var matAlgo03xDSf = createMatAlgo03xDSf({
     typed
   });
   var matAlgo07xSSf = createMatAlgo07xSSf({
     typed,
-    DenseMatrix
+    SparseMatrix
   });
   var matAlgo12xSfs = createMatAlgo12xSfs({
     typed,

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

@@ -7,21 +7,22 @@ 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'];
+var dependencies = ['typed', 'config', 'matrix', 'DenseMatrix', 'concat', 'SparseMatrix'];
 export var createLarger = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     config,
     matrix,
     DenseMatrix,
-    concat
+    concat,
+    SparseMatrix
   } = _ref;
   var matAlgo03xDSf = createMatAlgo03xDSf({
     typed
   });
   var matAlgo07xSSf = createMatAlgo07xSSf({
     typed,
-    DenseMatrix
+    SparseMatrix
   });
   var matAlgo12xSfs = createMatAlgo12xSfs({
     typed,

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

@@ -7,21 +7,22 @@ import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
 import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 import { createCompareUnits } from './compareUnits.js';
 var name = 'largerEq';
-var dependencies = ['typed', 'config', 'matrix', 'DenseMatrix', 'concat'];
+var dependencies = ['typed', 'config', 'matrix', 'DenseMatrix', 'concat', 'SparseMatrix'];
 export var createLargerEq = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     config,
     matrix,
     DenseMatrix,
-    concat
+    concat,
+    SparseMatrix
   } = _ref;
   var matAlgo03xDSf = createMatAlgo03xDSf({
     typed
   });
   var matAlgo07xSSf = createMatAlgo07xSSf({
     typed,
-    DenseMatrix
+    SparseMatrix
   });
   var matAlgo12xSfs = createMatAlgo12xSfs({
     typed,