mathjs 10.6.2 → 11.0.0

package/lib/cjs/expression/operators.js

@@ -4,30 +4,21 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getAssociativity = getAssociativity;
+exports.getOperator = getOperator;
 exports.getPrecedence = getPrecedence;
 exports.isAssociativeWith = isAssociativeWith;
 exports.properties = void 0;
 
 var _object = require("../utils/object.js");
 
-// list of identifiers of nodes in order of their precedence
-// also contains information about left/right associativity
-// and which other operator the operator is associative with
-// Example:
-// addition is associative with addition and subtraction, because:
-// (a+b)+c=a+(b+c)
-// (a+b)-c=a+(b-c)
-//
-// postfix operators are left associative, prefix operators
-// are right associative
-//
-// It's also possible to set the following properties:
-// latexParens: if set to false, this node doesn't need to be enclosed
-//              in parentheses when using LaTeX
-// latexLeftParens: if set to false, this !OperatorNode's!
-//                  left argument doesn't need to be enclosed
-//                  in parentheses
-// latexRightParens: the same for the right argument
+var _is = require("../utils/is.js");
+
+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 properties = [{
   // assignment
   AssignmentNode: {},
@@ -44,62 +35,74 @@ var properties = [{
 }, {
   // logical or
   'OperatorNode:or': {
+    op: 'or',
     associativity: 'left',
     associativeWith: []
   }
 }, {
   // logical xor
   'OperatorNode:xor': {
+    op: 'xor',
     associativity: 'left',
     associativeWith: []
   }
 }, {
   // logical and
   'OperatorNode:and': {
+    op: 'and',
     associativity: 'left',
     associativeWith: []
   }
 }, {
   // bitwise or
   'OperatorNode:bitOr': {
+    op: '|',
     associativity: 'left',
     associativeWith: []
   }
 }, {
   // bitwise xor
   'OperatorNode:bitXor': {
+    op: '^|',
     associativity: 'left',
     associativeWith: []
   }
 }, {
   // bitwise and
   'OperatorNode:bitAnd': {
+    op: '&',
     associativity: 'left',
     associativeWith: []
   }
 }, {
   // relational operators
   'OperatorNode:equal': {
+    op: '==',
     associativity: 'left',
     associativeWith: []
   },
   'OperatorNode:unequal': {
+    op: '!=',
     associativity: 'left',
     associativeWith: []
   },
   'OperatorNode:smaller': {
+    op: '<',
     associativity: 'left',
     associativeWith: []
   },
   'OperatorNode:larger': {
+    op: '>',
     associativity: 'left',
     associativeWith: []
   },
   'OperatorNode:smallerEq': {
+    op: '<=',
     associativity: 'left',
     associativeWith: []
   },
   'OperatorNode:largerEq': {
+    op: '>=',
     associativity: 'left',
     associativeWith: []
   },
@@ -110,20 +113,24 @@ var properties = [{
 }, {
   // bitshift operators
   'OperatorNode:leftShift': {
+    op: '<<',
     associativity: 'left',
     associativeWith: []
   },
   'OperatorNode:rightArithShift': {
+    op: '>>',
     associativity: 'left',
     associativeWith: []
   },
   'OperatorNode:rightLogShift': {
+    op: '>>>',
     associativity: 'left',
     associativeWith: []
   }
 }, {
   // unit conversion
   'OperatorNode:to': {
+    op: 'to',
     associativity: 'left',
     associativeWith: []
   }
@@ -133,20 +140,24 @@ var properties = [{
 }, {
   // addition, subtraction
   'OperatorNode:add': {
+    op: '+',
     associativity: 'left',
     associativeWith: ['OperatorNode:add', 'OperatorNode:subtract']
   },
   'OperatorNode:subtract': {
+    op: '-',
     associativity: 'left',
     associativeWith: []
   }
 }, {
   // multiply, divide, modulus
   'OperatorNode:multiply': {
+    op: '*',
     associativity: 'left',
     associativeWith: ['OperatorNode:multiply', 'OperatorNode:divide', 'Operator:dotMultiply', 'Operator:dotDivide']
   },
   'OperatorNode:divide': {
+    op: '/',
     associativity: 'left',
     associativeWith: [],
     latexLeftParens: false,
@@ -157,34 +168,48 @@ var properties = [{
 
   },
   'OperatorNode:dotMultiply': {
+    op: '.*',
     associativity: 'left',
     associativeWith: ['OperatorNode:multiply', 'OperatorNode:divide', 'OperatorNode:dotMultiply', 'OperatorNode:doDivide']
   },
   'OperatorNode:dotDivide': {
+    op: './',
     associativity: 'left',
     associativeWith: []
   },
   'OperatorNode:mod': {
+    op: 'mod',
     associativity: 'left',
     associativeWith: []
   }
+}, {
+  // Repeat multiplication for implicit multiplication
+  'OperatorNode:multiply': {
+    associativity: 'left',
+    associativeWith: ['OperatorNode:multiply', 'OperatorNode:divide', 'Operator:dotMultiply', 'Operator:dotDivide']
+  }
 }, {
   // unary prefix operators
   'OperatorNode:unaryPlus': {
+    op: '+',
     associativity: 'right'
   },
   'OperatorNode:unaryMinus': {
+    op: '-',
     associativity: 'right'
   },
   'OperatorNode:bitNot': {
+    op: '~',
     associativity: 'right'
   },
   'OperatorNode:not': {
+    op: 'not',
     associativity: 'right'
   }
 }, {
   // exponentiation
   'OperatorNode:pow': {
+    op: '^',
     associativity: 'right',
     associativeWith: [],
     latexRightParens: false // the exponent doesn't need parentheses in
@@ -193,20 +218,43 @@ var properties = [{
 
   },
   'OperatorNode:dotPow': {
+    op: '.^',
     associativity: 'right',
     associativeWith: []
   }
 }, {
   // factorial
   'OperatorNode:factorial': {
+    op: '!',
     associativity: 'left'
   }
 }, {
   // matrix transpose
-  'OperatorNode:transpose': {
+  'OperatorNode:ctranspose': {
+    op: "'",
     associativity: 'left'
   }
 }];
+/**
+ * Returns the first non-parenthesis internal node, but only
+ * when the 'parenthesis' option is unset or auto.
+ * @param {Node} _node
+ * @param {string} parenthesis
+ * @return {Node}
+ */
+
+exports.properties = properties;
+
+function unwrapParen(_node, parenthesis) {
+  if (!parenthesis || parenthesis !== 'auto') return _node;
+  var node = _node;
+
+  while ((0, _is.isParenthesisNode)(node)) {
+    node = node.content;
+  }
+
+  return node;
+}
 /**
  * Get the precedence of a Node.
  * Higher number for higher precedence, starting with 0.
@@ -214,12 +262,13 @@ var properties = [{
  *
  * @param {Node} _node
  * @param {string} parenthesis
+ * @param {string} implicit
+ * @param {Node} parent (for determining context for implicit multiplication)
  * @return {number | null}
  */
 
-exports.properties = properties;
 
-function getPrecedence(_node, parenthesis) {
+function getPrecedence(_node, parenthesis, implicit, parent) {
   var node = _node;
 
   if (parenthesis !== 'keep') {
@@ -228,14 +277,26 @@ function getPrecedence(_node, parenthesis) {
   }
 
   var identifier = node.getIdentifier();
+  var precedence = null;
 
   for (var i = 0; i < properties.length; i++) {
     if (identifier in properties[i]) {
-      return i;
+      precedence = i;
+      break;
+    }
+  } // Bump up precedence of implicit multiplication, except when preceded
+  // by a "Rule 2" fraction ( [unaryOp]constant / constant )
+
+
+  if (identifier === 'OperatorNode:multiply' && node.implicit && implicit !== 'show') {
+    var leftArg = unwrapParen(node.args[0], parenthesis);
+
+    if (!((0, _is.isConstantNode)(leftArg) && parent && parent.getIdentifier() === 'OperatorNode:divide' && (0, _is.rule2Node)(unwrapParen(parent.args[0], parenthesis))) && !(leftArg.getIdentifier() === 'OperatorNode:divide' && (0, _is.rule2Node)(unwrapParen(leftArg.args[0], parenthesis)) && (0, _is.isConstantNode)(unwrapParen(leftArg.args[1])))) {
+      precedence += 1;
     }
   }
 
-  return null;
+  return precedence;
 }
 /**
  * Get the associativity of an operator (left or right).
@@ -320,5 +381,38 @@ function isAssociativeWith(nodeA, nodeB, parenthesis) {
   } // associativeWith is not defined
 
 
+  return null;
+}
+/**
+ * Get the operator associated with a function name.
+ * Returns a string with the operator symbol, or null if the
+ * input is not the name of a function associated with an
+ * operator.
+ *
+ * @param {string} Function name
+ * @return {string | null} Associated operator symbol, if any
+ */
+
+
+function getOperator(fn) {
+  var identifier = 'OperatorNode:' + fn;
+
+  var _iterator = _createForOfIteratorHelper(properties),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var group = _step.value;
+
+      if (identifier in group) {
+        return group[identifier].op;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
   return null;
 }

package/lib/cjs/expression/parse.js

@@ -153,16 +153,16 @@ var createParse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
   var NAMED_DELIMITERS = {
     mod: true,
     to: true,
-    in: true,
+    "in": true,
     and: true,
     xor: true,
     or: true,
     not: true
   };
   var CONSTANTS = {
-    true: true,
-    false: false,
-    null: null,
+    "true": true,
+    "false": false,
+    "null": null,
     undefined: undefined
   };
   var NUMERIC_CONSTANTS = ['NaN', 'Infinity'];
@@ -588,7 +588,7 @@ var createParse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
 
   function parseStart(expression, extraNodes) {
     var state = initialState();
-    (0, _extends2.default)(state, {
+    (0, _extends2["default"])(state, {
       expression: expression,
       extraNodes: extraNodes
     });
@@ -624,7 +624,10 @@ var createParse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
 
     if (state.token !== '' && state.token !== '\n' && state.token !== ';') {
       node = parseAssignment(state);
-      node.comment = state.comment;
+
+      if (state.comment) {
+        node.comment = state.comment;
+      }
     } // TODO: simplify this loop
 
 
@@ -642,7 +645,11 @@ var createParse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
 
       if (state.token !== '\n' && state.token !== ';' && state.token !== '') {
         node = parseAssignment(state);
-        node.comment = state.comment;
+
+        if (state.comment) {
+          node.comment = state.comment;
+        }
+
         visible = state.token !== ';';
         blocks.push({
           node: node,
@@ -656,7 +663,10 @@ var createParse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
     } else {
       if (!node) {
         node = new ConstantNode(undefined);
-        node.comment = state.comment;
+
+        if (state.comment) {
+          node.comment = state.comment;
+        }
       }
 
       return node;
@@ -934,7 +944,7 @@ var createParse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
     node = parseRange(state);
     var operators = {
       to: 'to',
-      in: 'to' // alias of 'to'
+      "in": 'to' // alias of 'to'
 
     };
 
@@ -1100,8 +1110,10 @@ var createParse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
   }
   /**
    * Infamous "rule 2" as described in https://github.com/josdejong/mathjs/issues/792#issuecomment-361065370
+   * And as amended in https://github.com/josdejong/mathjs/issues/2370#issuecomment-1054052164
    * Explicit division gets higher precedence than implicit multiplication
-   * when the division matches this pattern: [number] / [number] [symbol]
+   * when the division matches this pattern:
+   *   [unaryPrefixOp]?[number] / [number] [symbol]
    * @return {Node} node
    * @private
    */
@@ -1114,32 +1126,32 @@ var createParse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
 
     while (true) {
       // Match the "number /" part of the pattern "number / number symbol"
-      if (state.token === '/' && (0, _is.isConstantNode)(last)) {
+      if (state.token === '/' && (0, _is.rule2Node)(last)) {
         // Look ahead to see if the next token is a number
-        tokenStates.push((0, _extends2.default)({}, state));
+        tokenStates.push((0, _extends2["default"])({}, state));
         getTokenSkipNewline(state); // Match the "number / number" part of the pattern
 
         if (state.tokenType === TOKENTYPE.NUMBER) {
           // Look ahead again
-          tokenStates.push((0, _extends2.default)({}, state));
+          tokenStates.push((0, _extends2["default"])({}, state));
           getTokenSkipNewline(state); // Match the "symbol" part of the pattern, or a left parenthesis
 
           if (state.tokenType === TOKENTYPE.SYMBOL || state.token === '(') {
             // We've matched the pattern "number / number symbol".
             // Rewind once and build the "number / number" node; the symbol will be consumed later
-            (0, _extends2.default)(state, tokenStates.pop());
+            (0, _extends2["default"])(state, tokenStates.pop());
             tokenStates.pop();
             last = parsePercentage(state);
             node = new OperatorNode('/', 'divide', [node, last]);
           } else {
             // Not a match, so rewind
             tokenStates.pop();
-            (0, _extends2.default)(state, tokenStates.pop());
+            (0, _extends2["default"])(state, tokenStates.pop());
             break;
           }
         } else {
           // Not a match, so rewind
-          (0, _extends2.default)(state, tokenStates.pop());
+          (0, _extends2["default"])(state, tokenStates.pop());
           break;
         }
       } else {
@@ -1787,7 +1799,7 @@ var createParse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
   function createSyntaxError(state, message) {
     var c = col(state);
     var error = new SyntaxError(message + ' (char ' + c + ')');
-    error.char = c;
+    error["char"] = c;
     return error;
   }
   /**
@@ -1802,10 +1814,16 @@ var createParse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
   function createError(state, message) {
     var c = col(state);
     var error = new SyntaxError(message + ' (char ' + c + ')');
-    error.char = c;
+    error["char"] = c;
     return error;
-  }
+  } // Now that we can parse, automatically convert strings to Nodes by parsing
+
 
+  typed.addConversion({
+    from: 'string',
+    to: 'Node',
+    convert: parse
+  });
   return parse;
 });
 exports.createParse = createParse;

package/lib/cjs/expression/transform/std.transform.js

@@ -14,7 +14,7 @@ var _errorTransform = require("./utils/errorTransform.js");
 var _lastDimToZeroBase = require("./utils/lastDimToZeroBase.js");
 
 var name = 'std';
-var dependencies = ['typed', 'sqrt', 'variance'];
+var dependencies = ['typed', 'map', 'sqrt', 'variance'];
 /**
  * Attach a transform function to math.std
  * Adds a property transform containing the transform function.
@@ -25,10 +25,12 @@ var dependencies = ['typed', 'sqrt', 'variance'];
 
 var createStdTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
+      map = _ref.map,
       sqrt = _ref.sqrt,
       variance = _ref.variance;
   var std = (0, _std.createStd)({
     typed: typed,
+    map: map,
     sqrt: sqrt,
     variance: variance
   });

package/lib/cjs/factoriesAny.js

@@ -1725,6 +1725,12 @@ Object.defineProperty(exports, "createSimplify", {
     return _simplify.createSimplify;
   }
 });
+Object.defineProperty(exports, "createSimplifyConstant", {
+  enumerable: true,
+  get: function get() {
+    return _simplifyConstant.createSimplifyConstant;
+  }
+});
 Object.defineProperty(exports, "createSimplifyCore", {
   enumerable: true,
   get: function get() {
@@ -2568,6 +2574,8 @@ var _leafCount = require("./function/algebra/leafCount.js");
 
 var _simplify = require("./function/algebra/simplify.js");
 
+var _simplifyConstant = require("./function/algebra/simplifyConstant.js");
+
 var _simplifyCore = require("./function/algebra/simplifyCore.js");
 
 var _resolve = require("./function/algebra/resolve.js");

package/lib/cjs/factoriesNumber.js

@@ -640,6 +640,12 @@ Object.defineProperty(exports, "createSimplify", {
     return _simplify.createSimplify;
   }
 });
+Object.defineProperty(exports, "createSimplifyConstant", {
+  enumerable: true,
+  get: function get() {
+    return _simplifyConstant.createSimplifyConstant;
+  }
+});
 Object.defineProperty(exports, "createSimplifyCore", {
   enumerable: true,
   get: function get() {
@@ -771,7 +777,8 @@ Object.defineProperty(exports, "createVersion", {
     return _constants.createVersion;
   }
 });
-exports.createXor = exports.createXgcd = void 0;
+exports.createXgcd = void 0;
+exports.createXor = void 0;
 
 var _index = require("./plain/number/index.js");
 
@@ -797,6 +804,8 @@ var _resolve = require("./function/algebra/resolve.js");
 
 var _simplify = require("./function/algebra/simplify.js");
 
+var _simplifyConstant = require("./function/algebra/simplifyConstant.js");
+
 var _simplifyCore = require("./function/algebra/simplifyCore.js");
 
 var _derivative = require("./function/algebra/derivative.js");

package/lib/cjs/function/algebra/decomposition/qr.js

@@ -73,7 +73,7 @@ var createQr = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function
    * @return {{Q: Array | Matrix, R: Array | Matrix}} Q: the orthogonal
    * matrix and R: the upper triangular matrix
    */
-  return (0, _extends2.default)(typed(name, {
+  return (0, _extends2["default"])(typed(name, {
     DenseMatrix: function DenseMatrix(m) {
       return _denseQR(m);
     },

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

@@ -63,39 +63,26 @@ var createDerivative = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
    *                         be simplified.
    * @return {ConstantNode | SymbolNode | ParenthesisNode | FunctionNode | OperatorNode}    The derivative of `expr`
    */
-  var derivative = typed('derivative', {
-    'Node, SymbolNode, Object': function NodeSymbolNodeObject(expr, variable, options) {
-      var constNodes = {};
-      constTag(constNodes, expr, variable.name);
+  function plainDerivative(expr, variable) {
+    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 res = _derivative(expr, constNodes);
 
-      return options.simplify ? simplify(res) : res;
-    },
-    'Node, SymbolNode': function NodeSymbolNode(expr, variable) {
-      return this(expr, variable, {
-        simplify: true
-      });
-    },
-    'string, SymbolNode': function stringSymbolNode(expr, variable) {
-      return this(parse(expr), variable);
-    },
-    'string, SymbolNode, Object': function stringSymbolNodeObject(expr, variable, options) {
-      return this(parse(expr), variable, options);
-    },
-    'string, string': function stringString(expr, variable) {
-      return this(parse(expr), parse(variable));
-    },
-    'string, string, Object': function stringStringObject(expr, variable, options) {
-      return this(parse(expr), parse(variable), options);
-    },
-    'Node, string': function NodeString(expr, variable) {
-      return this(expr, parse(variable));
-    },
-    'Node, string, Object': function NodeStringObject(expr, variable, options) {
-      return this(expr, parse(variable), options);
-    } // TODO: replace the 8 signatures above with 4 as soon as typed-function supports optional arguments
+    return options.simplify ? simplify(res) : res;
+  }
 
+  typed.addConversion({
+    from: 'identifier',
+    to: 'SymbolNode',
+    convert: parse
+  });
+  var derivative = typed(name, {
+    'Node, SymbolNode': plainDerivative,
+    'Node, SymbolNode, Object': plainDerivative
     /* TODO: implement and test syntax with order of derivatives -> implement as an option {order: number}
     'Node, SymbolNode, ConstantNode': function (expr, variable, {order}) {
       let res = expr
@@ -109,6 +96,11 @@ var createDerivative = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
     */
 
   });
+  typed.removeConversion({
+    from: 'identifier',
+    to: 'SymbolNode',
+    convert: parse
+  });
   derivative._simplify = true;
 
   derivative.toTex = function (deriv) {

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

@@ -55,9 +55,6 @@ var createLeafCount = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
 
 
   return typed(name, {
-    string: function string(expr) {
-      return this(parse(expr));
-    },
     Node: function Node(expr) {
       return countLeaves(expr);
     }