mathjs-min 11.7.2

package/lib/cjs/expression/node/IndexNode.js

@@ -0,0 +1,268 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createIndexNode = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _array = require("../../utils/array.js");
+var _customs = require("../../utils/customs.js");
+var _factory = require("../../utils/factory.js");
+var _is = require("../../utils/is.js");
+var _string = require("../../utils/string.js");
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+var name = 'IndexNode';
+var dependencies = ['Node', 'size'];
+var createIndexNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var Node = _ref.Node,
+    size = _ref.size;
+  var IndexNode = /*#__PURE__*/function (_Node) {
+    (0, _inherits2["default"])(IndexNode, _Node);
+    var _super = _createSuper(IndexNode);
+    /**
+     * @constructor IndexNode
+     * @extends Node
+     *
+     * Describes a subset of a matrix or an object property.
+     * Cannot be used on its own, needs to be used within an AccessorNode or
+     * AssignmentNode.
+     *
+     * @param {Node[]} dimensions
+     * @param {boolean} [dotNotation=false]
+     *     Optional property describing whether this index was written using dot
+     *     notation like `a.b`, or using bracket notation like `a["b"]`
+     *     (which is the default). This property is used for string conversion.
+     */
+    function IndexNode(dimensions, dotNotation) {
+      var _this;
+      (0, _classCallCheck2["default"])(this, IndexNode);
+      _this = _super.call(this);
+      _this.dimensions = dimensions;
+      _this.dotNotation = dotNotation || false;
+
+      // validate input
+      if (!Array.isArray(dimensions) || !dimensions.every(_is.isNode)) {
+        throw new TypeError('Array containing Nodes expected for parameter "dimensions"');
+      }
+      if (_this.dotNotation && !_this.isObjectProperty()) {
+        throw new Error('dotNotation only applicable for object properties');
+      }
+      return _this;
+    }
+    (0, _createClass2["default"])(IndexNode, [{
+      key: "type",
+      get: function get() {
+        return name;
+      }
+    }, {
+      key: "isIndexNode",
+      get: function get() {
+        return true;
+      }
+
+      /**
+       * Compile a node into a JavaScript function.
+       * This basically pre-calculates as much as possible and only leaves open
+       * calculations which depend on a dynamic scope with variables.
+       * @param {Object} math     Math.js namespace with functions and constants.
+       * @param {Object} argNames An object with argument names as key and `true`
+       *                          as value. Used in the SymbolNode to optimize
+       *                          for arguments from user assigned functions
+       *                          (see FunctionAssignmentNode) or special symbols
+       *                          like `end` (see IndexNode).
+       * @return {function} Returns a function which can be called like:
+       *                        evalNode(scope: Object, args: Object, context: *)
+       */
+    }, {
+      key: "_compile",
+      value: function _compile(math, argNames) {
+        // TODO: implement support for bignumber (currently bignumbers are silently
+        //       reduced to numbers when changing the value to zero-based)
+
+        // TODO: Optimization: when the range values are ConstantNodes,
+        //       we can beforehand resolve the zero-based value
+
+        // optimization for a simple object property
+        var evalDimensions = (0, _array.map)(this.dimensions, function (dimension, i) {
+          var needsEnd = dimension.filter(function (node) {
+            return node.isSymbolNode && node.name === 'end';
+          }).length > 0;
+          if (needsEnd) {
+            // SymbolNode 'end' is used inside the index,
+            // like in `A[end]` or `A[end - 2]`
+            var childArgNames = Object.create(argNames);
+            childArgNames.end = true;
+            var _evalDimension = dimension._compile(math, childArgNames);
+            return function evalDimension(scope, args, context) {
+              if (!(0, _is.isMatrix)(context) && !(0, _is.isArray)(context) && !(0, _is.isString)(context)) {
+                throw new TypeError('Cannot resolve "end": ' + 'context must be a Matrix, Array, or string but is ' + (0, _is.typeOf)(context));
+              }
+              var s = size(context).valueOf();
+              var childArgs = Object.create(args);
+              childArgs.end = s[i];
+              return _evalDimension(scope, childArgs, context);
+            };
+          } else {
+            // SymbolNode `end` not used
+            return dimension._compile(math, argNames);
+          }
+        });
+        var index = (0, _customs.getSafeProperty)(math, 'index');
+        return function evalIndexNode(scope, args, context) {
+          var dimensions = (0, _array.map)(evalDimensions, function (evalDimension) {
+            return evalDimension(scope, args, context);
+          });
+          return index.apply(void 0, (0, _toConsumableArray2["default"])(dimensions));
+        };
+      }
+
+      /**
+       * Execute a callback for each of the child nodes of this node
+       * @param {function(child: Node, path: string, parent: Node)} callback
+       */
+    }, {
+      key: "forEach",
+      value: function forEach(callback) {
+        for (var i = 0; i < this.dimensions.length; i++) {
+          callback(this.dimensions[i], 'dimensions[' + i + ']', this);
+        }
+      }
+
+      /**
+       * Create a new IndexNode whose children are the results of calling
+       * the provided callback function for each child of the original node.
+       * @param {function(child: Node, path: string, parent: Node): Node} callback
+       * @returns {IndexNode} Returns a transformed copy of the node
+       */
+    }, {
+      key: "map",
+      value: function map(callback) {
+        var dimensions = [];
+        for (var i = 0; i < this.dimensions.length; i++) {
+          dimensions[i] = this._ifNode(callback(this.dimensions[i], 'dimensions[' + i + ']', this));
+        }
+        return new IndexNode(dimensions, this.dotNotation);
+      }
+
+      /**
+       * Create a clone of this node, a shallow copy
+       * @return {IndexNode}
+       */
+    }, {
+      key: "clone",
+      value: function clone() {
+        return new IndexNode(this.dimensions.slice(0), this.dotNotation);
+      }
+
+      /**
+       * Test whether this IndexNode contains a single property name
+       * @return {boolean}
+       */
+    }, {
+      key: "isObjectProperty",
+      value: function isObjectProperty() {
+        return this.dimensions.length === 1 && (0, _is.isConstantNode)(this.dimensions[0]) && typeof this.dimensions[0].value === 'string';
+      }
+
+      /**
+       * Returns the property name if IndexNode contains a property.
+       * If not, returns null.
+       * @return {string | null}
+       */
+    }, {
+      key: "getObjectProperty",
+      value: function getObjectProperty() {
+        return this.isObjectProperty() ? this.dimensions[0].value : null;
+      }
+
+      /**
+       * Get string representation
+       * @param {Object} options
+       * @return {string} str
+       */
+    }, {
+      key: "_toString",
+      value: function _toString(options) {
+        // format the parameters like "[1, 0:5]"
+        return this.dotNotation ? '.' + this.getObjectProperty() : '[' + this.dimensions.join(', ') + ']';
+      }
+
+      /**
+       * Get a JSON representation of the node
+       * @returns {Object}
+       */
+    }, {
+      key: "toJSON",
+      value: function toJSON() {
+        return {
+          mathjs: name,
+          dimensions: this.dimensions,
+          dotNotation: this.dotNotation
+        };
+      }
+
+      /**
+       * Instantiate an IndexNode from its JSON representation
+       * @param {Object} json
+       *     An object structured like
+       *     `{"mathjs": "IndexNode", dimensions: [...], dotNotation: false}`,
+       *     where mathjs is optional
+       * @returns {IndexNode}
+       */
+    }, {
+      key: "toHTML",
+      value:
+      /**
+       * Get HTML representation
+       * @param {Object} options
+       * @return {string} str
+       */
+      function toHTML(options) {
+        // format the parameters like "[1, 0:5]"
+        var dimensions = [];
+        for (var i = 0; i < this.dimensions.length; i++) {
+          dimensions[i] = this.dimensions[i].toHTML();
+        }
+        if (this.dotNotation) {
+          return '<span class="math-operator math-accessor-operator">.</span>' + '<span class="math-symbol math-property">' + (0, _string.escape)(this.getObjectProperty()) + '</span>';
+        } else {
+          return '<span class="math-parenthesis math-square-parenthesis">[</span>' + dimensions.join('<span class="math-separator">,</span>') + '<span class="math-parenthesis math-square-parenthesis">]</span>';
+        }
+      }
+
+      /**
+       * Get LaTeX representation
+       * @param {Object} options
+       * @return {string} str
+       */
+    }, {
+      key: "_toTex",
+      value: function _toTex(options) {
+        var dimensions = this.dimensions.map(function (range) {
+          return range.toTex(options);
+        });
+        return this.dotNotation ? '.' + this.getObjectProperty() + '' : '_{' + dimensions.join(',') + '}';
+      }
+    }], [{
+      key: "fromJSON",
+      value: function fromJSON(json) {
+        return new IndexNode(json.dimensions, json.dotNotation);
+      }
+    }]);
+    return IndexNode;
+  }(Node);
+  (0, _defineProperty2["default"])(IndexNode, "name", name);
+  return IndexNode;
+}, {
+  isClass: true,
+  isNode: true
+});
+exports.createIndexNode = createIndexNode;

package/lib/cjs/expression/node/Node.js

@@ -0,0 +1,423 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createNode = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _is = require("../../utils/is.js");
+var _keywords = require("../keywords.js");
+var _object = require("../../utils/object.js");
+var _factory = require("../../utils/factory.js");
+var _map = require("../../utils/map.js");
+var name = 'Node';
+var dependencies = ['mathWithTransform'];
+var createNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var mathWithTransform = _ref.mathWithTransform;
+  /**
+   * Validate the symbol names of a scope.
+   * Throws an error when the scope contains an illegal symbol.
+   * @param {Object} scope
+   */
+  function _validateScope(scope) {
+    for (var _i = 0, _arr = (0, _toConsumableArray2["default"])(_keywords.keywords); _i < _arr.length; _i++) {
+      var symbol = _arr[_i];
+      if (scope.has(symbol)) {
+        throw new Error('Scope contains an illegal symbol, "' + symbol + '" is a reserved keyword');
+      }
+    }
+  }
+  var Node = /*#__PURE__*/function () {
+    function Node() {
+      (0, _classCallCheck2["default"])(this, Node);
+    }
+    (0, _createClass2["default"])(Node, [{
+      key: "type",
+      get: function get() {
+        return 'Node';
+      }
+    }, {
+      key: "isNode",
+      get: function get() {
+        return true;
+      }
+
+      /**
+       * Evaluate the node
+       * @param {Object} [scope]  Scope to read/write variables
+       * @return {*}              Returns the result
+       */
+    }, {
+      key: "evaluate",
+      value: function evaluate(scope) {
+        return this.compile().evaluate(scope);
+      }
+
+      /**
+       * Compile the node into an optimized, evauatable JavaScript function
+       * @return {{evaluate: function([Object])}} object
+       *                Returns an object with a function 'evaluate',
+       *                which can be invoked as expr.evaluate([scope: Object]),
+       *                where scope is an optional object with
+       *                variables.
+       */
+    }, {
+      key: "compile",
+      value: function compile() {
+        var expr = this._compile(mathWithTransform, {});
+        var args = {};
+        var context = null;
+        function evaluate(scope) {
+          var s = (0, _map.createMap)(scope);
+          _validateScope(s);
+          return expr(s, args, context);
+        }
+        return {
+          evaluate: evaluate
+        };
+      }
+
+      /**
+       * Compile a node into a JavaScript function.
+       * This basically pre-calculates as much as possible and only leaves open
+       * calculations which depend on a dynamic scope with variables.
+       * @param {Object} math     Math.js namespace with functions and constants.
+       * @param {Object} argNames An object with argument names as key and `true`
+       *                          as value. Used in the SymbolNode to optimize
+       *                          for arguments from user assigned functions
+       *                          (see FunctionAssignmentNode) or special symbols
+       *                          like `end` (see IndexNode).
+       * @return {function} Returns a function which can be called like:
+       *                        evalNode(scope: Object, args: Object, context: *)
+       */
+    }, {
+      key: "_compile",
+      value: function _compile(math, argNames) {
+        throw new Error('Method _compile must be implemented by type ' + this.type);
+      }
+
+      /**
+       * Execute a callback for each of the child nodes of this node
+       * @param {function(child: Node, path: string, parent: Node)} callback
+       */
+    }, {
+      key: "forEach",
+      value: function forEach(callback) {
+        // must be implemented by each of the Node implementations
+        throw new Error('Cannot run forEach on a Node interface');
+      }
+
+      /**
+       * Create a new Node whose children are the results of calling the
+       * provided callback function for each child of the original node.
+       * @param {function(child: Node, path: string, parent: Node): Node} callback
+       * @returns {OperatorNode} Returns a transformed copy of the node
+       */
+    }, {
+      key: "map",
+      value: function map(callback) {
+        // must be implemented by each of the Node implementations
+        throw new Error('Cannot run map on a Node interface');
+      }
+
+      /**
+       * Validate whether an object is a Node, for use with map
+       * @param {Node} node
+       * @returns {Node} Returns the input if it's a node, else throws an Error
+       * @protected
+       */
+    }, {
+      key: "_ifNode",
+      value: function _ifNode(node) {
+        if (!(0, _is.isNode)(node)) {
+          throw new TypeError('Callback function must return a Node');
+        }
+        return node;
+      }
+
+      /**
+       * Recursively traverse all nodes in a node tree. Executes given callback for
+       * this node and each of its child nodes.
+       * @param {function(node: Node, path: string, parent: Node)} callback
+       *          A callback called for every node in the node tree.
+       */
+    }, {
+      key: "traverse",
+      value: function traverse(callback) {
+        // execute callback for itself
+        // eslint-disable-next-line
+        callback(this, null, null);
+
+        // recursively traverse over all children of a node
+        function _traverse(node, callback) {
+          node.forEach(function (child, path, parent) {
+            callback(child, path, parent);
+            _traverse(child, callback);
+          });
+        }
+        _traverse(this, callback);
+      }
+
+      /**
+       * Recursively transform a node tree via a transform function.
+       *
+       * For example, to replace all nodes of type SymbolNode having name 'x' with
+       * a ConstantNode with value 2:
+       *
+       *     const res = Node.transform(function (node, path, parent) {
+       *       if (node && node.isSymbolNode) && (node.name === 'x')) {
+       *         return new ConstantNode(2)
+       *       }
+       *       else {
+       *         return node
+       *       }
+       *     })
+       *
+       * @param {function(node: Node, path: string, parent: Node) : Node} callback
+       *          A mapping function accepting a node, and returning
+       *          a replacement for the node or the original node. The "signature"
+       *          of the callback must be:
+       *          callback(node: Node, index: string, parent: Node) : Node
+       * @return {Node} Returns the original node or its replacement
+       */
+    }, {
+      key: "transform",
+      value: function transform(callback) {
+        function _transform(child, path, parent) {
+          var replacement = callback(child, path, parent);
+          if (replacement !== child) {
+            // stop iterating when the node is replaced
+            return replacement;
+          }
+          return child.map(_transform);
+        }
+        return _transform(this, null, null);
+      }
+
+      /**
+       * Find any node in the node tree matching given filter function. For
+       * example, to find all nodes of type SymbolNode having name 'x':
+       *
+       *     const results = Node.filter(function (node) {
+       *       return (node && node.isSymbolNode) && (node.name === 'x')
+       *     })
+       *
+       * @param {function(node: Node, path: string, parent: Node) : Node} callback
+       *            A test function returning true when a node matches, and false
+       *            otherwise. Function signature:
+       *            callback(node: Node, index: string, parent: Node) : boolean
+       * @return {Node[]} nodes
+       *            An array with nodes matching given filter criteria
+       */
+    }, {
+      key: "filter",
+      value: function filter(callback) {
+        var nodes = [];
+        this.traverse(function (node, path, parent) {
+          if (callback(node, path, parent)) {
+            nodes.push(node);
+          }
+        });
+        return nodes;
+      }
+
+      /**
+       * Create a shallow clone of this node
+       * @return {Node}
+       */
+    }, {
+      key: "clone",
+      value: function clone() {
+        // must be implemented by each of the Node implementations
+        throw new Error('Cannot clone a Node interface');
+      }
+
+      /**
+       * Create a deep clone of this node
+       * @return {Node}
+       */
+    }, {
+      key: "cloneDeep",
+      value: function cloneDeep() {
+        return this.map(function (node) {
+          return node.cloneDeep();
+        });
+      }
+
+      /**
+       * Deep compare this node with another node.
+       * @param {Node} other
+       * @return {boolean} Returns true when both nodes are of the same type and
+       *                   contain the same values (as do their childs)
+       */
+    }, {
+      key: "equals",
+      value: function equals(other) {
+        return other ? this.type === other.type && (0, _object.deepStrictEqual)(this, other) : false;
+      }
+
+      /**
+       * Get string representation. (wrapper function)
+       *
+       * This function can get an object of the following form:
+       * {
+       *    handler: //This can be a callback function of the form
+       *             // "function callback(node, options)"or
+       *             // a map that maps function names (used in FunctionNodes)
+       *             // to callbacks
+       *    parenthesis: "keep" //the parenthesis option (This is optional)
+       * }
+       *
+       * @param {Object} [options]
+       * @return {string}
+       */
+    }, {
+      key: "toString",
+      value: function toString(options) {
+        var customString = this._getCustomString(options);
+        if (typeof customString !== 'undefined') {
+          return customString;
+        }
+        return this._toString(options);
+      }
+
+      /**
+       * Get a JSON representation of the node
+       * Both .toJSON() and the static .fromJSON(json) should be implemented by all
+       * implementations of Node
+       * @returns {Object}
+       */
+    }, {
+      key: "toJSON",
+      value: function toJSON() {
+        throw new Error('Cannot serialize object: toJSON not implemented by ' + this.type);
+      }
+
+      /**
+       * Get HTML representation. (wrapper function)
+       *
+       * This function can get an object of the following form:
+       * {
+       *    handler: //This can be a callback function of the form
+       *             // "function callback(node, options)" or
+       *             // a map that maps function names (used in FunctionNodes)
+       *             // to callbacks
+       *    parenthesis: "keep" //the parenthesis option (This is optional)
+       * }
+       *
+       * @param {Object} [options]
+       * @return {string}
+       */
+    }, {
+      key: "toHTML",
+      value: function toHTML(options) {
+        var customString = this._getCustomString(options);
+        if (typeof customString !== 'undefined') {
+          return customString;
+        }
+        return this.toHTML(options);
+      }
+
+      /**
+       * Internal function to generate the string output.
+       * This has to be implemented by every Node
+       *
+       * @throws {Error}
+       */
+    }, {
+      key: "_toString",
+      value: function _toString() {
+        // must be implemented by each of the Node implementations
+        throw new Error('_toString not implemented for ' + this.type);
+      }
+
+      /**
+       * Get LaTeX representation. (wrapper function)
+       *
+       * This function can get an object of the following form:
+       * {
+       *    handler: //This can be a callback function of the form
+       *             // "function callback(node, options)"or
+       *             // a map that maps function names (used in FunctionNodes)
+       *             // to callbacks
+       *    parenthesis: "keep" //the parenthesis option (This is optional)
+       * }
+       *
+       * @param {Object} [options]
+       * @return {string}
+       */
+    }, {
+      key: "toTex",
+      value: function toTex(options) {
+        var customString = this._getCustomString(options);
+        if (typeof customString !== 'undefined') {
+          return customString;
+        }
+        return this._toTex(options);
+      }
+
+      /**
+       * Internal function to generate the LaTeX output.
+       * This has to be implemented by every Node
+       *
+       * @param {Object} [options]
+       * @throws {Error}
+       */
+    }, {
+      key: "_toTex",
+      value: function _toTex(options) {
+        // must be implemented by each of the Node implementations
+        throw new Error('_toTex not implemented for ' + this.type);
+      }
+
+      /**
+       * Helper used by `to...` functions.
+       */
+    }, {
+      key: "_getCustomString",
+      value: function _getCustomString(options) {
+        if (options && (0, _typeof2["default"])(options) === 'object') {
+          switch ((0, _typeof2["default"])(options.handler)) {
+            case 'object':
+            case 'undefined':
+              return;
+            case 'function':
+              return options.handler(this, options);
+            default:
+              throw new TypeError('Object or function expected as callback');
+          }
+        }
+      }
+
+      /**
+       * Get identifier.
+       * @return {string}
+       */
+    }, {
+      key: "getIdentifier",
+      value: function getIdentifier() {
+        return this.type;
+      }
+
+      /**
+       * Get the content of the current Node.
+       * @return {Node} node
+       **/
+    }, {
+      key: "getContent",
+      value: function getContent() {
+        return this;
+      }
+    }]);
+    return Node;
+  }();
+  return Node;
+}, {
+  isClass: true,
+  isNode: true
+});
+exports.createNode = createNode;