226 lines
8.2 KiB
JavaScript
226 lines
8.2 KiB
JavaScript
"use strict";
|
|
|
|
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.createIndexNode = void 0;
|
|
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");
|
|
const name = 'IndexNode';
|
|
const dependencies = ['Node', 'size'];
|
|
const createIndexNode = exports.createIndexNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
|
|
let {
|
|
Node,
|
|
size
|
|
} = _ref;
|
|
class IndexNode extends Node {
|
|
/**
|
|
* @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.
|
|
*/
|
|
constructor(dimensions, dotNotation) {
|
|
super();
|
|
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');
|
|
}
|
|
}
|
|
get type() {
|
|
return name;
|
|
}
|
|
get isIndexNode() {
|
|
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: *)
|
|
*/
|
|
_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
|
|
const evalDimensions = (0, _array.map)(this.dimensions, function (dimension, i) {
|
|
const needsEnd = dimension.filter(node => node.isSymbolNode && node.name === 'end').length > 0;
|
|
if (needsEnd) {
|
|
// SymbolNode 'end' is used inside the index,
|
|
// like in `A[end]` or `A[end - 2]`
|
|
const childArgNames = Object.create(argNames);
|
|
childArgNames.end = true;
|
|
const _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));
|
|
}
|
|
const s = size(context).valueOf();
|
|
const childArgs = Object.create(args);
|
|
childArgs.end = s[i];
|
|
return _evalDimension(scope, childArgs, context);
|
|
};
|
|
} else {
|
|
// SymbolNode `end` not used
|
|
return dimension._compile(math, argNames);
|
|
}
|
|
});
|
|
const index = (0, _customs.getSafeProperty)(math, 'index');
|
|
return function evalIndexNode(scope, args, context) {
|
|
const dimensions = (0, _array.map)(evalDimensions, function (evalDimension) {
|
|
return evalDimension(scope, args, context);
|
|
});
|
|
return index(...dimensions);
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Execute a callback for each of the child nodes of this node
|
|
* @param {function(child: Node, path: string, parent: Node)} callback
|
|
*/
|
|
forEach(callback) {
|
|
for (let 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
|
|
*/
|
|
map(callback) {
|
|
const dimensions = [];
|
|
for (let 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}
|
|
*/
|
|
clone() {
|
|
return new IndexNode(this.dimensions.slice(0), this.dotNotation);
|
|
}
|
|
|
|
/**
|
|
* Test whether this IndexNode contains a single property name
|
|
* @return {boolean}
|
|
*/
|
|
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}
|
|
*/
|
|
getObjectProperty() {
|
|
return this.isObjectProperty() ? this.dimensions[0].value : null;
|
|
}
|
|
|
|
/**
|
|
* Get string representation
|
|
* @param {Object} options
|
|
* @return {string} str
|
|
*/
|
|
_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}
|
|
*/
|
|
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}
|
|
*/
|
|
static fromJSON(json) {
|
|
return new IndexNode(json.dimensions, json.dotNotation);
|
|
}
|
|
|
|
/**
|
|
* Get HTML representation
|
|
* @param {Object} options
|
|
* @return {string} str
|
|
*/
|
|
_toHTML(options) {
|
|
// format the parameters like "[1, 0:5]"
|
|
const dimensions = [];
|
|
for (let 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
|
|
*/
|
|
_toTex(options) {
|
|
const dimensions = this.dimensions.map(function (range) {
|
|
return range.toTex(options);
|
|
});
|
|
return this.dotNotation ? '.' + this.getObjectProperty() + '' : '_{' + dimensions.join(',') + '}';
|
|
}
|
|
}
|
|
(0, _defineProperty2.default)(IndexNode, "name", name);
|
|
return IndexNode;
|
|
}, {
|
|
isClass: true,
|
|
isNode: true
|
|
}); |