mathjs 9.5.2 → 10.1.0

package/lib/esm/expression/embeddedDocs/embeddedDocs.js

@@ -1,4 +1,5 @@
 import { bignumberDocs } from './construction/bignumber.js';
+import { printDocs } from './function/utils/print.js';
 import { typeOfDocs } from './function/utils/typeOf.js';
 import { isZeroDocs } from './function/utils/isZero.js';
 import { isPrimeDocs } from './function/utils/isPrime.js';
@@ -135,6 +136,7 @@ import { bitOrDocs } from './function/bitwise/bitOr.js';
 import { bitNotDocs } from './function/bitwise/bitNot.js';
 import { bitAndDocs } from './function/bitwise/bitAnd.js';
 import { xgcdDocs } from './function/arithmetic/xgcd.js';
+import { invmodDocs } from './function/arithmetic/invmod.js';
 import { unaryPlusDocs } from './function/arithmetic/unaryPlus.js';
 import { unaryMinusDocs } from './function/arithmetic/unaryMinus.js';
 import { squareDocs } from './function/arithmetic/square.js';
@@ -507,6 +509,7 @@ export var embeddedDocs = {
   unaryMinus: unaryMinusDocs,
   unaryPlus: unaryPlusDocs,
   xgcd: xgcdDocs,
+  invmod: invmodDocs,
   // functions - bitwise
   bitAnd: bitAndDocs,
   bitNot: bitNotDocs,
@@ -668,7 +671,7 @@ export var embeddedDocs = {
   isPositive: isPositiveDocs,
   isPrime: isPrimeDocs,
   isZero: isZeroDocs,
-  // print: printDocs // TODO: add documentation for print as soon as the parser supports objects.
+  print: printDocs,
   typeOf: typeOfDocs,
   numeric: numericDocs
 };

package/lib/esm/expression/embeddedDocs/function/arithmetic/invmod.js

@@ -0,0 +1,8 @@
+export var invmodDocs = {
+  name: 'invmod',
+  category: 'Arithmetic',
+  syntax: ['invmod(a, b)'],
+  description: 'Calculate the (modular) multiplicative inverse of a modulo b. Solution to the equation ax ≣ 1 (mod b)',
+  examples: ['invmod(8, 12)=NaN', 'invmod(7, 13)=2', 'math.invmod(15151, 15122)=10429'],
+  seealso: ['gcd', 'xgcd']
+};

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

@@ -3,6 +3,6 @@ export var forEachDocs = {
   category: 'Matrix',
   syntax: ['forEach(x, callback)'],
   description: 'Iterates over all elements of a matrix/array, and executes the given callback function.',
-  examples: ['forEach([1, 2, 3], function(val) { console.log(val) })'],
+  examples: [],
   seealso: ['map', 'sort', 'filter']
 };

package/lib/esm/factoriesAny.js

@@ -53,6 +53,7 @@ export { createSqrt } from './function/arithmetic/sqrt.js';
 export { createSquare } from './function/arithmetic/square.js';
 export { createSubtract } from './function/arithmetic/subtract.js';
 export { createXgcd } from './function/arithmetic/xgcd.js';
+export { createInvmod } from './function/arithmetic/invmod.js';
 export { createDotMultiply } from './function/arithmetic/dotMultiply.js';
 export { createBitAnd } from './function/bitwise/bitAnd.js';
 export { createBitNot } from './function/bitwise/bitNot.js';

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

@@ -3,7 +3,7 @@ import { factory } from '../../utils/factory.js';
 import { createSimplifyConstant } from './simplify/simplifyConstant.js';
 import { createSimplifyCore } from './simplify/simplifyCore.js';
 var name = 'rationalize';
-var dependencies = ['config', 'typed', 'equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'parse', 'simplify', '?bignumber', '?fraction', 'mathWithTransform', 'ConstantNode', 'OperatorNode', 'FunctionNode', 'SymbolNode', 'ParenthesisNode'];
+var dependencies = ['config', 'typed', 'equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'parse', 'simplify', '?bignumber', '?fraction', 'mathWithTransform', 'matrix', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'SymbolNode', 'ParenthesisNode'];
 export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     config,
@@ -20,9 +20,14 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
     fraction,
     bignumber,
     mathWithTransform,
+    matrix,
+    AccessorNode,
+    ArrayNode,
     ConstantNode,
-    OperatorNode,
     FunctionNode,
+    IndexNode,
+    ObjectNode,
+    OperatorNode,
     SymbolNode,
     ParenthesisNode
   } = _ref;
@@ -30,11 +35,16 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
     typed,
     config,
     mathWithTransform,
+    matrix,
     fraction,
     bignumber,
+    AccessorNode,
+    ArrayNode,
     ConstantNode,
-    OperatorNode,
     FunctionNode,
+    IndexNode,
+    ObjectNode,
+    OperatorNode,
     SymbolNode
   });
   var simplifyCore = createSimplifyCore({
@@ -45,9 +55,13 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
     multiply,
     divide,
     pow,
+    AccessorNode,
+    ArrayNode,
     ConstantNode,
-    OperatorNode,
     FunctionNode,
+    IndexNode,
+    ObjectNode,
+    OperatorNode,
     ParenthesisNode
   });
   /**

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

@@ -1,20 +1,25 @@
 // TODO this could be improved by simplifying seperated constants under associative and commutative operators
-import { isFraction, isNode, isOperatorNode } from '../../../utils/is.js';
+import { isFraction, isMatrix, isNode, isArrayNode, isConstantNode, isIndexNode, isObjectNode, isOperatorNode } from '../../../utils/is.js';
 import { factory } from '../../../utils/factory.js';
 import { createUtil } from './util.js';
 import { noBignumber, noFraction } from '../../../utils/noop.js';
 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'];
 export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     config,
     mathWithTransform,
+    matrix,
     fraction,
     bignumber,
+    AccessorNode,
+    ArrayNode,
     ConstantNode,
-    OperatorNode,
     FunctionNode,
+    IndexNode,
+    ObjectNode,
+    OperatorNode,
     SymbolNode
   } = _ref;
   var {
@@ -29,22 +34,31 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
   });
 
   function simplifyConstant(expr, options) {
-    var res = foldFraction(expr, options);
-    return isNode(res) ? res : _toNode(res);
+    return _ensureNode(foldFraction(expr, options));
+  }
+
+  function _removeFractions(thing) {
+    if (isFraction(thing)) {
+      return thing.valueOf();
+    }
+
+    if (thing instanceof Array) {
+      return thing.map(_removeFractions);
+    }
+
+    if (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 (isFraction(x)) {
-          return x.valueOf();
-        }
-
-        return x;
-      });
+      args = args.map(_removeFractions);
       return _toNumber(mathWithTransform[fnname].apply(null, args), options);
     }
   }
@@ -67,8 +81,22 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
     },
     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(e => _toNode(e)));
+    }
+  });
+
+  function _ensureNode(thing) {
+    if (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
 
 
@@ -125,6 +153,12 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
       }
 
       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);
     }
   });
 
@@ -148,6 +182,103 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
 
     return new OperatorNode('/', 'divide', [n, new ConstantNode(f.d)]);
   }
+  /* Handles constant indexing of ArrayNodes, matrices, and ObjectNodes */
+
+
+  function _foldAccessor(obj, index, options) {
+    if (!isIndexNode(index)) {
+      // don't know what to do with that...
+      return new AccessorNode(_ensureNode(obj), _ensureNode(index));
+    }
+
+    if (isArrayNode(obj) || 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 (isConstantNode(remainingDims[0]) && typeof remainingDims[0].value !== 'string') {
+          var first = _toNumber(remainingDims.shift().value, options);
+
+          if (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 && isConstantNode(remainingDims[1]) && typeof remainingDims[1].value !== 'string') {
+          var second = _toNumber(remainingDims[1].value, options);
+
+          var tryItems = [];
+          var fromItems = isArrayNode(obj) ? obj.items : obj.valueOf();
+
+          for (var item of fromItems) {
+            if (isArrayNode(item)) {
+              tryItems.push(item.items[second - 1]);
+            } else if (isMatrix(obj)) {
+              tryItems.push(item[second - 1]);
+            } else {
+              break;
+            }
+          }
+
+          if (tryItems.length === fromItems.length) {
+            if (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 (isObjectNode(obj) && index.dimensions.length === 1 && 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
@@ -186,8 +317,15 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
         return node;
 
       case 'ConstantNode':
-        if (typeof node.value === 'number' || !isNaN(node.value)) {
-          return _toNumber(node.value, options);
+        switch (typeof 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;
@@ -207,14 +345,24 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
             if (!args.some(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 && isArrayNode(args[0])) {
+              var sz = [];
+              var section = args[0];
+
+              while (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 isNode(arg) ? arg : _toNode(arg);
-            });
-            return new FunctionNode(node.name, args);
+            return new FunctionNode(node.name, args.map(_ensureNode));
           } else {// treat as operator
           }
         }
@@ -281,10 +429,36 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
         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(item => foldFraction(item, options));
+
+          if (foldItems.some(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(n => 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 */
@@ -295,12 +469,6 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
       case 'FunctionAssignmentNode':
       /* falls through */
 
-      case 'IndexNode':
-      /* falls through */
-
-      case 'ObjectNode':
-      /* falls through */
-
       case 'RangeNode':
       /* falls through */
 

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

@@ -1,7 +1,7 @@
-import { isConstantNode, isFunctionNode, isOperatorNode, isParenthesisNode, isSymbolNode } from '../../../utils/is.js';
+import { isAccessorNode, isArrayNode, isConstantNode, isFunctionNode, isIndexNode, isObjectNode, isOperatorNode, isParenthesisNode, isSymbolNode } from '../../../utils/is.js';
 import { factory } from '../../../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'];
 export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     equal,
@@ -11,13 +11,23 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
     multiply,
     divide,
     pow,
+    AccessorNode,
+    ArrayNode,
     ConstantNode,
-    OperatorNode,
     FunctionNode,
+    IndexNode,
+    ObjectNode,
+    OperatorNode,
     ParenthesisNode
   } = _ref;
   var node0 = new ConstantNode(0);
   var node1 = new ConstantNode(1);
+
+  function mapSimplifyCore(nodeArray) {
+    return nodeArray.map(simplifyCore).map(function (arg) {
+      return isParenthesisNode(arg) ? arg.content : arg;
+    });
+  }
   /**
    * simplifyCore() performs single pass simplification suitable for
    * applications requiring ultimate performance. In contrast, simplify()
@@ -42,6 +52,7 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
    *     The expression to be simplified
    */
 
+
   function simplifyCore(node) {
     if (isOperatorNode(node) && node.isUnary()) {
       var a0 = simplifyCore(node.args[0]);
@@ -177,10 +188,27 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
 
       return new ParenthesisNode(c);
     } else if (isFunctionNode(node)) {
-      var args = node.args.map(simplifyCore).map(function (arg) {
-        return isParenthesisNode(arg) ? arg.content : arg;
-      });
-      return new FunctionNode(simplifyCore(node.fn), args);
+      return new FunctionNode(simplifyCore(node.fn), mapSimplifyCore(node.args));
+    } else if (isArrayNode(node)) {
+      return new ArrayNode(mapSimplifyCore(node.items));
+    } else if (isAccessorNode(node)) {
+      var obj = mapSimplifyCore(node.object);
+
+      if (isParenthesisNode(obj)) {
+        obj = obj.content;
+      }
+
+      return new AccessorNode(obj, simplifyCore(node.index));
+    } else if (isIndexNode(node)) {
+      return new IndexNode(mapSimplifyCore(node.dimensions));
+    } else if (isObjectNode(node)) {
+      var newProps = {};
+
+      for (var prop in node.properties) {
+        newProps[prop] = simplifyCore(node.properties[prop]);
+      }
+
+      return new ObjectNode(newProps);
     } else {// cannot simplify
     }