mathjs 10.0.2 → 10.1.0

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

@@ -1,10 +1,14 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createSimplifyConstant = void 0;
 
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
 var _is = require("../../../utils/is.js");
 
 var _factory = require("../../../utils/factory.js");
@@ -13,18 +17,28 @@ var _util = require("./util.js");
 
 var _noop = require("../../../utils/noop.js");
 
-// TODO this could be improved by simplifying seperated constants under associative and commutative operators
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
 var name = 'simplifyConstant';
-var dependencies = ['typed', 'config', 'mathWithTransform', '?fraction', '?bignumber', 'ConstantNode', 'OperatorNode', 'FunctionNode', 'SymbolNode'];
+var dependencies = ['typed', 'config', 'mathWithTransform', 'matrix', '?fraction', '?bignumber', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'SymbolNode'];
 var createSimplifyConstant = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
       config = _ref.config,
       mathWithTransform = _ref.mathWithTransform,
+      matrix = _ref.matrix,
       fraction = _ref.fraction,
       bignumber = _ref.bignumber,
+      AccessorNode = _ref.AccessorNode,
+      ArrayNode = _ref.ArrayNode,
       ConstantNode = _ref.ConstantNode,
-      OperatorNode = _ref.OperatorNode,
       FunctionNode = _ref.FunctionNode,
+      IndexNode = _ref.IndexNode,
+      ObjectNode = _ref.ObjectNode,
+      OperatorNode = _ref.OperatorNode,
       SymbolNode = _ref.SymbolNode;
 
   var _createUtil = (0, _util.createUtil)({
@@ -38,22 +52,31 @@ var createSimplifyConstant = /* #__PURE__ */(0, _factory.factory)(name, dependen
       createMakeNodeFunction = _createUtil.createMakeNodeFunction;
 
   function simplifyConstant(expr, options) {
-    var res = foldFraction(expr, options);
-    return (0, _is.isNode)(res) ? res : _toNode(res);
+    return _ensureNode(foldFraction(expr, options));
+  }
+
+  function _removeFractions(thing) {
+    if ((0, _is.isFraction)(thing)) {
+      return thing.valueOf();
+    }
+
+    if (thing instanceof Array) {
+      return thing.map(_removeFractions);
+    }
+
+    if ((0, _is.isMatrix)(thing)) {
+      return matrix(_removeFractions(thing.valueOf()));
+    }
+
+    return thing;
   }
 
   function _eval(fnname, args, options) {
     try {
-      return _toNumber(mathWithTransform[fnname].apply(null, args), options);
+      return mathWithTransform[fnname].apply(null, args);
     } catch (ignore) {
       // sometimes the implicit type conversion causes the evaluation to fail, so we'll try again after removing Fractions
-      args = args.map(function (x) {
-        if ((0, _is.isFraction)(x)) {
-          return x.valueOf();
-        }
-
-        return x;
-      });
+      args = args.map(_removeFractions);
       return _toNumber(mathWithTransform[fnname].apply(null, args), options);
     }
   }
@@ -76,8 +99,24 @@ var createSimplifyConstant = /* #__PURE__ */(0, _factory.factory)(name, dependen
     },
     Complex: function Complex(s) {
       throw new Error('Cannot convert Complex number to Node');
+    },
+    string: function string(s) {
+      return new ConstantNode(s);
+    },
+    Matrix: function Matrix(m) {
+      return new ArrayNode(m.valueOf().map(function (e) {
+        return _toNode(e);
+      }));
+    }
+  });
+
+  function _ensureNode(thing) {
+    if ((0, _is.isNode)(thing)) {
+      return thing;
     }
-  }); // convert a number to a fraction only if it can be expressed exactly,
+
+    return _toNode(thing);
+  } // convert a number to a fraction only if it can be expressed exactly,
   // and when both numerator and denominator are small enough
 
 
@@ -134,6 +173,12 @@ var createSimplifyConstant = /* #__PURE__ */(0, _factory.factory)(name, dependen
       }
 
       return _exactFraction(s.re, options);
+    },
+    'Matrix, Object': function MatrixObject(s, options) {
+      return matrix(_exactFraction(s.valueOf()));
+    },
+    'Array, Object': function ArrayObject(s, options) {
+      return s.map(_exactFraction);
     }
   });
 
@@ -157,6 +202,114 @@ var createSimplifyConstant = /* #__PURE__ */(0, _factory.factory)(name, dependen
 
     return new OperatorNode('/', 'divide', [n, new ConstantNode(f.d)]);
   }
+  /* Handles constant indexing of ArrayNodes, matrices, and ObjectNodes */
+
+
+  function _foldAccessor(obj, index, options) {
+    if (!(0, _is.isIndexNode)(index)) {
+      // don't know what to do with that...
+      return new AccessorNode(_ensureNode(obj), _ensureNode(index));
+    }
+
+    if ((0, _is.isArrayNode)(obj) || (0, _is.isMatrix)(obj)) {
+      var remainingDims = Array.from(index.dimensions);
+      /* We will resolve constant indices one at a time, looking
+       * just in the first or second dimensions because (a) arrays
+       * of more than two dimensions are likely rare, and (b) pulling
+       * out the third or higher dimension would be pretty intricate.
+       * The price is that we miss simplifying [..3d array][x,y,1]
+       */
+
+      while (remainingDims.length > 0) {
+        if ((0, _is.isConstantNode)(remainingDims[0]) && typeof remainingDims[0].value !== 'string') {
+          var first = _toNumber(remainingDims.shift().value, options);
+
+          if ((0, _is.isArrayNode)(obj)) {
+            obj = obj.items[first - 1];
+          } else {
+            // matrix
+            obj = obj.valueOf()[first - 1];
+
+            if (obj instanceof Array) {
+              obj = matrix(obj);
+            }
+          }
+        } else if (remainingDims.length > 1 && (0, _is.isConstantNode)(remainingDims[1]) && typeof remainingDims[1].value !== 'string') {
+          var second = _toNumber(remainingDims[1].value, options);
+
+          var tryItems = [];
+          var fromItems = (0, _is.isArrayNode)(obj) ? obj.items : obj.valueOf();
+
+          var _iterator = _createForOfIteratorHelper(fromItems),
+              _step;
+
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var item = _step.value;
+
+              if ((0, _is.isArrayNode)(item)) {
+                tryItems.push(item.items[second - 1]);
+              } else if ((0, _is.isMatrix)(obj)) {
+                tryItems.push(item[second - 1]);
+              } else {
+                break;
+              }
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+
+          if (tryItems.length === fromItems.length) {
+            if ((0, _is.isArrayNode)(obj)) {
+              obj = new ArrayNode(tryItems);
+            } else {
+              // matrix
+              obj = matrix(tryItems);
+            }
+
+            remainingDims.splice(1, 1);
+          } else {
+            // extracting slice along 2nd dimension failed, give up
+            break;
+          }
+        } else {
+          // neither 1st or 2nd dimension is constant, give up
+          break;
+        }
+      }
+
+      if (remainingDims.length === index.dimensions.length) {
+        /* No successful constant indexing */
+        return new AccessorNode(_ensureNode(obj), index);
+      }
+
+      if (remainingDims.length > 0) {
+        /* Indexed some but not all dimensions */
+        index = new IndexNode(remainingDims);
+        return new AccessorNode(_ensureNode(obj), index);
+      }
+      /* All dimensions were constant, access completely resolved */
+
+
+      return obj;
+    }
+
+    if ((0, _is.isObjectNode)(obj) && index.dimensions.length === 1 && (0, _is.isConstantNode)(index.dimensions[0])) {
+      var key = index.dimensions[0].value;
+
+      if (key in obj.properties) {
+        return obj.properties[key];
+      }
+
+      return new ConstantNode(); // undefined
+    }
+    /* Don't know how to index this sort of obj, at least not with this index */
+
+
+    return new AccessorNode(_ensureNode(obj), index);
+  }
   /*
    * Create a binary tree from a list of Fractions and Nodes.
    * Tries to fold Fractions by evaluating them until the first Node in the list is hit, so
@@ -195,8 +348,15 @@ var createSimplifyConstant = /* #__PURE__ */(0, _factory.factory)(name, dependen
         return node;
 
       case 'ConstantNode':
-        if (typeof node.value === 'number' || !isNaN(node.value)) {
-          return _toNumber(node.value, options);
+        switch ((0, _typeof2["default"])(node.value)) {
+          case 'number':
+            return _toNumber(node.value, options);
+
+          case 'string':
+            return node.value;
+
+          default:
+            if (!isNaN(node.value)) return _toNumber(node.value, options);
         }
 
         return node;
@@ -218,14 +378,24 @@ var createSimplifyConstant = /* #__PURE__ */(0, _factory.factory)(name, dependen
             if (!args.some(_is.isNode)) {
               try {
                 return _eval(node.name, args, options);
-              } catch (ignoreandcontine) {}
+              } catch (ignoreandcontinue) {}
+            } // Size of a matrix does not depend on entries
+
+
+            if (node.name === 'size' && args.length === 1 && (0, _is.isArrayNode)(args[0])) {
+              var sz = [];
+              var section = args[0];
+
+              while ((0, _is.isArrayNode)(section)) {
+                sz.push(section.items.length);
+                section = section.items[0];
+              }
+
+              return matrix(sz);
             } // Convert all args to nodes and construct a symbolic function call
 
 
-            args = args.map(function (arg) {
-              return (0, _is.isNode)(arg) ? arg : _toNode(arg);
-            });
-            return new FunctionNode(node.name, args);
+            return new FunctionNode(node.name, args.map(_ensureNode));
           } else {// treat as operator
           }
         }
@@ -296,10 +466,40 @@ var createSimplifyConstant = /* #__PURE__ */(0, _factory.factory)(name, dependen
         return foldFraction(node.content, options);
 
       case 'AccessorNode':
-      /* falls through */
+        return _foldAccessor(foldFraction(node.object, options), foldFraction(node.index, options), options);
 
       case 'ArrayNode':
-      /* falls through */
+        {
+          var foldItems = node.items.map(function (item) {
+            return foldFraction(item, options);
+          });
+
+          if (foldItems.some(_is.isNode)) {
+            return new ArrayNode(foldItems.map(_ensureNode));
+          }
+          /* All literals -- return a Matrix so we can operate on it */
+
+
+          return matrix(foldItems);
+        }
+
+      case 'IndexNode':
+        {
+          return new IndexNode(node.dimensions.map(function (n) {
+            return simplifyConstant(n, options);
+          }));
+        }
+
+      case 'ObjectNode':
+        {
+          var foldProps = {};
+
+          for (var prop in node.properties) {
+            foldProps[prop] = simplifyConstant(node.properties[prop], options);
+          }
+
+          return new ObjectNode(foldProps);
+        }
 
       case 'AssignmentNode':
       /* falls through */
@@ -310,12 +510,6 @@ var createSimplifyConstant = /* #__PURE__ */(0, _factory.factory)(name, dependen
       case 'FunctionAssignmentNode':
       /* falls through */
 
-      case 'IndexNode':
-      /* falls through */
-
-      case 'ObjectNode':
-      /* falls through */
-
       case 'RangeNode':
       /* falls through */
 

package/lib/cjs/function/algebra/simplify/simplifyCore.js

@@ -10,7 +10,7 @@ var _is = require("../../../utils/is.js");
 var _factory = require("../../../utils/factory.js");
 
 var name = 'simplifyCore';
-var dependencies = ['equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'ConstantNode', 'OperatorNode', 'FunctionNode', 'ParenthesisNode'];
+var dependencies = ['equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'ParenthesisNode'];
 var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var equal = _ref.equal,
       isZero = _ref.isZero,
@@ -19,12 +19,22 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
       multiply = _ref.multiply,
       divide = _ref.divide,
       pow = _ref.pow,
+      AccessorNode = _ref.AccessorNode,
+      ArrayNode = _ref.ArrayNode,
       ConstantNode = _ref.ConstantNode,
-      OperatorNode = _ref.OperatorNode,
       FunctionNode = _ref.FunctionNode,
+      IndexNode = _ref.IndexNode,
+      ObjectNode = _ref.ObjectNode,
+      OperatorNode = _ref.OperatorNode,
       ParenthesisNode = _ref.ParenthesisNode;
   var node0 = new ConstantNode(0);
   var node1 = new ConstantNode(1);
+
+  function mapSimplifyCore(nodeArray) {
+    return nodeArray.map(simplifyCore).map(function (arg) {
+      return (0, _is.isParenthesisNode)(arg) ? arg.content : arg;
+    });
+  }
   /**
    * simplifyCore() performs single pass simplification suitable for
    * applications requiring ultimate performance. In contrast, simplify()
@@ -49,6 +59,7 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
    *     The expression to be simplified
    */
 
+
   function simplifyCore(node) {
     if ((0, _is.isOperatorNode)(node) && node.isUnary()) {
       var a0 = simplifyCore(node.args[0]);
@@ -184,10 +195,27 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
 
       return new ParenthesisNode(c);
     } else if ((0, _is.isFunctionNode)(node)) {
-      var args = node.args.map(simplifyCore).map(function (arg) {
-        return (0, _is.isParenthesisNode)(arg) ? arg.content : arg;
-      });
-      return new FunctionNode(simplifyCore(node.fn), args);
+      return new FunctionNode(simplifyCore(node.fn), mapSimplifyCore(node.args));
+    } else if ((0, _is.isArrayNode)(node)) {
+      return new ArrayNode(mapSimplifyCore(node.items));
+    } else if ((0, _is.isAccessorNode)(node)) {
+      var obj = mapSimplifyCore(node.object);
+
+      if ((0, _is.isParenthesisNode)(obj)) {
+        obj = obj.content;
+      }
+
+      return new AccessorNode(obj, simplifyCore(node.index));
+    } else if ((0, _is.isIndexNode)(node)) {
+      return new IndexNode(mapSimplifyCore(node.dimensions));
+    } else if ((0, _is.isObjectNode)(node)) {
+      var newProps = {};
+
+      for (var prop in node.properties) {
+        newProps[prop] = simplifyCore(node.properties[prop]);
+      }
+
+      return new ObjectNode(newProps);
     } else {// cannot simplify
     }
 

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

@@ -26,7 +26,7 @@ var _object = require("../../utils/object.js");
 var _map = require("../../utils/map.js");
 
 var name = 'simplify';
-var dependencies = ['config', 'typed', 'parse', 'add', 'subtract', 'multiply', 'divide', 'pow', 'isZero', 'equal', '?fraction', '?bignumber', 'mathWithTransform', 'ConstantNode', 'FunctionNode', 'OperatorNode', 'ParenthesisNode', 'SymbolNode'];
+var dependencies = ['config', 'typed', 'parse', 'add', 'subtract', 'multiply', 'divide', 'pow', 'isZero', 'equal', '?fraction', '?bignumber', 'mathWithTransform', 'matrix', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'ParenthesisNode', 'SymbolNode'];
 var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var config = _ref.config,
       typed = _ref.typed,
@@ -41,8 +41,13 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
       fraction = _ref.fraction,
       bignumber = _ref.bignumber,
       mathWithTransform = _ref.mathWithTransform,
+      matrix = _ref.matrix,
+      AccessorNode = _ref.AccessorNode,
+      ArrayNode = _ref.ArrayNode,
       ConstantNode = _ref.ConstantNode,
       FunctionNode = _ref.FunctionNode,
+      IndexNode = _ref.IndexNode,
+      ObjectNode = _ref.ObjectNode,
       OperatorNode = _ref.OperatorNode,
       ParenthesisNode = _ref.ParenthesisNode,
       SymbolNode = _ref.SymbolNode;
@@ -50,11 +55,16 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
     typed: typed,
     config: config,
     mathWithTransform: mathWithTransform,
+    matrix: matrix,
     fraction: fraction,
     bignumber: bignumber,
+    AccessorNode: AccessorNode,
+    ArrayNode: ArrayNode,
     ConstantNode: ConstantNode,
-    OperatorNode: OperatorNode,
     FunctionNode: FunctionNode,
+    IndexNode: IndexNode,
+    ObjectNode: ObjectNode,
+    OperatorNode: OperatorNode,
     SymbolNode: SymbolNode
   });
   var simplifyCore = (0, _simplifyCore.createSimplifyCore)({
@@ -65,9 +75,13 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
     multiply: multiply,
     divide: divide,
     pow: pow,
+    AccessorNode: AccessorNode,
+    ArrayNode: ArrayNode,
     ConstantNode: ConstantNode,
-    OperatorNode: OperatorNode,
     FunctionNode: FunctionNode,
+    IndexNode: IndexNode,
+    ObjectNode: ObjectNode,
+    OperatorNode: OperatorNode,
     ParenthesisNode: ParenthesisNode
   });
   var resolve = (0, _resolve.createResolve)({
@@ -280,17 +294,19 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
     l: 'log(e)',
     r: '1'
   }, // temporary rules
+  // Note initially we tend constants to the right because like-term
+  // collection prefers the left, and we would rather collect nonconstants
   {
     l: 'n-n1',
     r: 'n+-n1'
   }, // temporarily replace 'subtract' so we can further flatten the 'add' operator
   {
     l: '-(c*v)',
-    r: '(-c) * v'
+    r: 'v * (-c)'
   }, // make non-constant terms positive
   {
     l: '-v',
-    r: '(-1) * v'
+    r: 'v * (-1)'
   }, {
     l: 'n/n1^n2',
     r: 'n*n1^-n2'
@@ -298,6 +314,17 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
   {
     l: 'n/n1',
     r: 'n*n1^-1'
+  }, // remove parenthesis in the case of negating a quantity
+  {
+    l: 'n1 + (n2 + n3)*(-1)',
+    r: 'n1 + n2*(-1) + n3*(-1)'
+  }, // subsume resulting -1 into constants where possible
+  {
+    l: '(-1) * c',
+    r: '-c'
+  }, {
+    l: '(-1) * (-c)',
+    r: 'c'
   }, // expand nested exponentiation
   {
     l: '(n ^ n1) ^ n2',
@@ -320,20 +347,21 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
     l: 'n+-n',
     r: '0'
   }, {
-    l: 'n1*n2 + n2',
-    r: '(n1+1)*n2'
-  }, {
-    l: 'n1*n3 + n2*n3',
-    r: '(n1+n2)*n3'
-  }, // remove parenthesis in the case of negating a quantitiy
+    l: 'v*n + v',
+    r: 'v*(n+1)'
+  }, // NOTE: leftmost position is special:
   {
-    l: 'n1 + -1 * (n2 + n3)',
-    r: 'n1 + -1 * n2 + -1 * n3'
+    l: 'n3*n1 + n3*n2',
+    r: 'n3*(n1+n2)'
+  }, // All sub-monomials tried there.
+  {
+    l: 'n*c + c',
+    r: '(n+1)*c'
   }, simplifyConstant, {
     l: '(-n)*n1',
     r: '-(n*n1)'
   }, // make factors positive (and undo 'make non-constant terms positive')
-  // ordering of constants
+  // final ordering of constants
   {
     l: 'c+v',
     r: 'v+c',
@@ -437,7 +465,7 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
           };
 
           if (rule.context) {
-            newRule.evaluate = rule.context;
+            newRule.context = rule.context;
           }
 
           if (rule.evaluate) {
@@ -481,6 +509,14 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
   function _getExpandPlaceholderSymbol() {
     return new SymbolNode('_p' + _lastsym++);
   }
+
+  function mapRule(nodes, rule) {
+    if (nodes) {
+      for (var i = 0; i < nodes.length; ++i) {
+        nodes[i] = applyRule(nodes[i], rule);
+      }
+    }
+  }
   /**
    * Returns a simplfied form of node, or the original node if no simplification was possible.
    *
@@ -494,19 +530,31 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
       // console.log('Entering applyRule(' + node.toString() + ')')
       // Do not clone node unless we find a match
       var res = node; // First replace our child nodes with their simplified versions
-      // If a child could not be simplified, the assignments will have
-      // no effect since the node is returned unchanged
+      // If a child could not be simplified, applying the rule to it
+      // will have no effect since the node is returned unchanged
 
       if (res instanceof OperatorNode || res instanceof FunctionNode) {
-        if (res.args) {
-          for (var i = 0; i < res.args.length; i++) {
-            res.args[i] = applyRule(res.args[i], rule);
-          }
-        }
+        mapRule(res.args, rule);
       } else if (res instanceof ParenthesisNode) {
         if (res.content) {
           res.content = applyRule(res.content, rule);
         }
+      } else if (res instanceof ArrayNode) {
+        mapRule(res.items, rule);
+      } else if (res instanceof AccessorNode) {
+        if (res.object) {
+          res.object = applyRule(res.object, rule);
+        }
+
+        if (res.index) {
+          res.index = applyRule(res.index, rule);
+        }
+      } else if (res instanceof IndexNode) {
+        mapRule(res.dimensions, rule);
+      } else if (res instanceof ObjectNode) {
+        for (var prop in res.properties) {
+          res.properties[prop] = applyRule(res.properties[prop], rule);
+        }
       } // Try to match a rule against this node
 
 

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

@@ -0,0 +1,73 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createInvmod = void 0;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _factory = require("../../utils/factory.js");
+
+var name = 'invmod';
+var dependencies = ['typed', 'config', 'BigNumber', 'xgcd', 'equal', 'smaller', 'mod', 'add', 'isInteger'];
+var createInvmod = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+      config = _ref.config,
+      BigNumber = _ref.BigNumber,
+      xgcd = _ref.xgcd,
+      equal = _ref.equal,
+      smaller = _ref.smaller,
+      mod = _ref.mod,
+      add = _ref.add,
+      isInteger = _ref.isInteger;
+
+  /**
+   * Calculate the (modular) multiplicative inverse of a modulo b. Solution to the equation `ax ≣ 1 (mod b)`
+   * See https://en.wikipedia.org/wiki/Modular_multiplicative_inverse.
+   *
+   * Syntax:
+   *
+   *    math.invmod(a, b)
+   *
+   * Examples:
+   *
+   *    math.invmod(8, 12)             // returns NaN
+   *    math.invmod(7, 13)             // return 2
+   *    math.invmod(15151, 15122)      // returns 10429
+   *
+   * See also:
+   *
+   *    gcd, xgcd
+   *
+   * @param {number | BigNumber} a  An integer number
+   * @param {number | BigNumber} b  An integer number
+   * @return {number | BigNumber }  Returns an integer number
+   *                              where `invmod(a,b)*a ≣ 1 (mod b)`
+   */
+  return typed(name, {
+    'number, number': invmod,
+    'BigNumber, BigNumber': invmod
+  });
+
+  function invmod(a, b) {
+    if (!isInteger(a) || !isInteger(b)) throw new Error('Parameters in function invmod must be integer numbers');
+    a = mod(a, b);
+    if (equal(b, 0)) throw new Error('Divisor must be non zero');
+    var res = xgcd(a, b);
+    res = res.valueOf();
+
+    var _res = res,
+        _res2 = (0, _slicedToArray2["default"])(_res, 2),
+        gcd = _res2[0],
+        inv = _res2[1];
+
+    if (!equal(gcd, BigNumber(1))) return NaN;
+    inv = mod(inv, b);
+    if (smaller(inv, BigNumber(0))) inv = add(inv, b);
+    return inv;
+  }
+});
+exports.createInvmod = createInvmod;