diff options
Diffstat (limited to 'mathjs/mathjs-expression-parser.js')
| -rw-r--r-- | mathjs/mathjs-expression-parser.js | 13005 |
1 files changed, 13005 insertions, 0 deletions
diff --git a/mathjs/mathjs-expression-parser.js b/mathjs/mathjs-expression-parser.js new file mode 100644 index 0000000..4d521b9 --- /dev/null +++ b/mathjs/mathjs-expression-parser.js @@ -0,0 +1,13005 @@ +(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.math = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){ +// Load the math.js core +var core = require('mathjs/core'); + +// Create a new, empty math.js instance +// It will only contain methods `import` and `config` +var math = core.create(); + +math.import(require('mathjs/lib/expression/function/parse')); +math.import(require('mathjs/lib/expression/function/compile')); +math.import(require('mathjs/lib/expression/function/eval')); + +math.import(require('mathjs/lib/function/string/format')); + +// create simple functions for all operators +math.import({ + // arithmetic + add: function (a, b) { return a + b }, + subtract: function (a, b) { return a - b }, + multiply: function (a, b) { return a * b }, + divide: function (a, b) { return a / b }, + mod: function (a, b) { return a % b }, + unaryPlus: function (a) { return a }, + unaryMinus: function (a) { return -a }, + + // bitwise + bitOr: function (a, b) { return a | b }, + bitXor: function (a, b) { return a ^ b }, + bitAnd: function (a, b) { return a & b }, + bitNot: function (a) { return ~a }, + leftShift: function (a, b) { return a << b }, + rightArithShift: function (a, b) { return a >> b }, + rightLogShift: function (a, b) { return a >>> b }, + + // logical + or: function (a, b) { return !!(a || b) }, + xor: function (a, b) { return !!a !== !!b }, + and: function (a, b) { return !!(a && b) }, + not: function (a) { return !a }, + + // relational + equal: function (a, b) { return a == b }, + unequal: function (a, b) { return a != b }, + smaller: function (a, b) { return a < b }, + larger: function (a, b) { return a > b }, + smallerEq: function (a, b) { return a <= b }, + largerEq: function (a, b) { return a >= b }, + + // matrix + // matrix: function (a) { return a }, + matrix: function () { + throw new Error('Matrices not supported') + }, + index: function () { + // TODO: create a simple index function + throw new Error('Matrix indexes not supported') + }, + + // add pi and e as lowercase + pi: Math.PI, + e: Math.E, + 'true': true, + 'false': false, + 'null': null +}) + +// import everything from Math (like trigonometric functions) +var allFromMath = {}; +Object.getOwnPropertyNames(Math).forEach(function (name) { + // filter out stuff like Firefox's "toSource" method. + if (!Object.prototype.hasOwnProperty(name)) { + allFromMath[name] = Math[name]; + } +}); +math.import(allFromMath); + +module.exports = math; + +},{"mathjs/core":3,"mathjs/lib/expression/function/compile":11,"mathjs/lib/expression/function/eval":12,"mathjs/lib/expression/function/parse":13,"mathjs/lib/function/string/format":37}],2:[function(require,module,exports){ +"use strict"; + +// Map the characters to escape to their escaped values. The list is derived +// from http://www.cespedes.org/blog/85/how-to-escape-latex-special-characters + +var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; + +var defaultEscapes = { + "{": "\\{", + "}": "\\}", + "\\": "\\textbackslash{}", + "#": "\\#", + $: "\\$", + "%": "\\%", + "&": "\\&", + "^": "\\textasciicircum{}", + _: "\\_", + "~": "\\textasciitilde{}" +}; +var formatEscapes = { + "\u2013": "\\--", + "\u2014": "\\---", + " ": "~", + "\t": "\\qquad{}", + "\r\n": "\\newline{}", + "\n": "\\newline{}" +}; + +var defaultEscapeMapFn = function defaultEscapeMapFn(defaultEscapes, formatEscapes) { + return _extends({}, defaultEscapes, formatEscapes); +}; + +/** + * Escape a string to be used in LaTeX documents. + * @param {string} str the string to be escaped. + * @param {boolean} params.preserveFormatting whether formatting escapes should + * be performed (default: false). + * @param {function} params.escapeMapFn the function to modify the escape maps. + * @return {string} the escaped string, ready to be used in LaTeX. + */ +module.exports = function (str) { + var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, + _ref$preserveFormatti = _ref.preserveFormatting, + preserveFormatting = _ref$preserveFormatti === undefined ? false : _ref$preserveFormatti, + _ref$escapeMapFn = _ref.escapeMapFn, + escapeMapFn = _ref$escapeMapFn === undefined ? defaultEscapeMapFn : _ref$escapeMapFn; + + var runningStr = String(str); + var result = ""; + + var escapes = escapeMapFn(_extends({}, defaultEscapes), preserveFormatting ? _extends({}, formatEscapes) : {}); + var escapeKeys = Object.keys(escapes); // as it is reused later on + + // Algorithm: Go through the string character by character, if it matches + // with one of the special characters then we'll replace it with the escaped + // version. + + var _loop = function _loop() { + var specialCharFound = false; + escapeKeys.forEach(function (key, index) { + if (specialCharFound) { + return; + } + if (runningStr.length >= key.length && runningStr.slice(0, key.length) === key) { + result += escapes[escapeKeys[index]]; + runningStr = runningStr.slice(key.length, runningStr.length); + specialCharFound = true; + } + }); + if (!specialCharFound) { + result += runningStr.slice(0, 1); + runningStr = runningStr.slice(1, runningStr.length); + } + }; + + while (runningStr) { + _loop(); + } + return result; +}; +},{}],3:[function(require,module,exports){ +module.exports = require('./lib/core/core') + +},{"./lib/core/core":4}],4:[function(require,module,exports){ +'use strict'; + +require('./../utils/polyfills'); + +var isFactory = require('./../utils/object').isFactory; + +var typedFactory = require('./typed'); + +var emitter = require('./../utils/emitter'); + +var importFactory = require('./function/import'); + +var configFactory = require('./function/config'); +/** + * Math.js core. Creates a new, empty math.js instance + * @param {Object} [options] Available options: + * {number} epsilon + * Minimum relative difference between two + * compared values, used by all comparison functions. + * {string} matrix + * A string 'Matrix' (default) or 'Array'. + * {string} number + * A string 'number' (default), 'BigNumber', or 'Fraction' + * {number} precision + * The number of significant digits for BigNumbers. + * Not applicable for Numbers. + * {boolean} predictable + * Predictable output type of functions. When true, + * output type depends only on the input types. When + * false (default), output type can vary depending + * on input values. For example `math.sqrt(-4)` + * returns `complex('2i')` when predictable is false, and + * returns `NaN` when true. + * {string} randomSeed + * Random seed for seeded pseudo random number generator. + * Set to null to randomly seed. + * @returns {Object} Returns a bare-bone math.js instance containing + * functions: + * - `import` to add new functions + * - `config` to change configuration + * - `on`, `off`, `once`, `emit` for events + */ + + +exports.create = function create(options) { + // simple test for ES5 support + if (typeof Object.create !== 'function') { + throw new Error('ES5 not supported by this JavaScript engine. ' + 'Please load the es5-shim and es5-sham library for compatibility.'); + } // cached factories and instances + + + var factories = []; + var instances = []; // create a namespace for the mathjs instance, and attach emitter functions + + var math = emitter.mixin({}); + math.type = {}; + math.expression = { + transform: {}, + mathWithTransform: {} // create a new typed instance + + }; + math.typed = typedFactory.create(math.type); // create configuration options. These are private + + var _config = { + // minimum relative difference between two compared values, + // used by all comparison functions + epsilon: 1e-12, + // type of default matrix output. Choose 'matrix' (default) or 'array' + matrix: 'Matrix', + // type of default number output. Choose 'number' (default) 'BigNumber', or 'Fraction + number: 'number', + // number of significant digits in BigNumbers + precision: 64, + // predictable output type of functions. When true, output type depends only + // on the input types. When false (default), output type can vary depending + // on input values. For example `math.sqrt(-4)` returns `complex('2i')` when + // predictable is false, and returns `NaN` when true. + predictable: false, + // random seed for seeded pseudo random number generation + // null = randomly seed + randomSeed: null + /** + * Load a function or data type from a factory. + * If the function or data type already exists, the existing instance is + * returned. + * @param {{type: string, name: string, factory: Function}} factory + * @returns {*} + */ + + }; + + function load(factory) { + if (!isFactory(factory)) { + throw new Error('Factory object with properties `type`, `name`, and `factory` expected'); + } + + var index = factories.indexOf(factory); + var instance; + + if (index === -1) { + // doesn't yet exist + if (factory.math === true) { + // pass with math namespace + instance = factory.factory(math.type, _config, load, math.typed, math); + } else { + instance = factory.factory(math.type, _config, load, math.typed); + } // append to the cache + + + factories.push(factory); + instances.push(instance); + } else { + // already existing function, return the cached instance + instance = instances[index]; + } + + return instance; + } // load the import and config functions + + + math['import'] = load(importFactory); + math['config'] = load(configFactory); + math.expression.mathWithTransform['config'] = math['config']; // apply options + + if (options) { + math.config(options); + } + + return math; +}; +},{"./../utils/emitter":52,"./../utils/object":55,"./../utils/polyfills":56,"./function/config":5,"./function/import":6,"./typed":7}],5:[function(require,module,exports){ +'use strict'; + +var object = require('../../utils/object'); + +function factory(type, config, load, typed, math) { + var MATRIX = ['Matrix', 'Array']; // valid values for option matrix + + var NUMBER = ['number', 'BigNumber', 'Fraction']; // valid values for option number + + /** + * Set configuration options for math.js, and get current options. + * Will emit a 'config' event, with arguments (curr, prev, changes). + * + * Syntax: + * + * math.config(config: Object): Object + * + * Examples: + * + * math.config().number // outputs 'number' + * math.eval('0.4') // outputs number 0.4 + * math.config({number: 'Fraction'}) + * math.eval('0.4') // outputs Fraction 2/5 + * + * @param {Object} [options] Available options: + * {number} epsilon + * Minimum relative difference between two + * compared values, used by all comparison functions. + * {string} matrix + * A string 'Matrix' (default) or 'Array'. + * {string} number + * A string 'number' (default), 'BigNumber', or 'Fraction' + * {number} precision + * The number of significant digits for BigNumbers. + * Not applicable for Numbers. + * {string} parenthesis + * How to display parentheses in LaTeX and string + * output. + * {string} randomSeed + * Random seed for seeded pseudo random number generator. + * Set to null to randomly seed. + * @return {Object} Returns the current configuration + */ + + function _config(options) { + if (options) { + var prev = object.map(config, object.clone); // validate some of the options + + validateOption(options, 'matrix', MATRIX); + validateOption(options, 'number', NUMBER); // merge options + + object.deepExtend(config, options); + var curr = object.map(config, object.clone); + var changes = object.map(options, object.clone); // emit 'config' event + + math.emit('config', curr, prev, changes); + return curr; + } else { + return object.map(config, object.clone); + } + } // attach the valid options to the function so they can be extended + + + _config.MATRIX = MATRIX; + _config.NUMBER = NUMBER; + return _config; +} +/** + * Test whether an Array contains a specific item. + * @param {Array.<string>} array + * @param {string} item + * @return {boolean} + */ + + +function contains(array, item) { + return array.indexOf(item) !== -1; +} +/** + * Find a string in an array. Case insensitive search + * @param {Array.<string>} array + * @param {string} item + * @return {number} Returns the index when found. Returns -1 when not found + */ + + +function findIndex(array, item) { + return array.map(function (i) { + return i.toLowerCase(); + }).indexOf(item.toLowerCase()); +} +/** + * Validate an option + * @param {Object} options Object with options + * @param {string} name Name of the option to validate + * @param {Array.<string>} values Array with valid values for this option + */ + + +function validateOption(options, name, values) { + if (options[name] !== undefined && !contains(values, options[name])) { + var index = findIndex(values, options[name]); + + if (index !== -1) { + // right value, wrong casing + // TODO: lower case values are deprecated since v3, remove this warning some day. + console.warn('Warning: Wrong casing for configuration option "' + name + '", should be "' + values[index] + '" instead of "' + options[name] + '".'); + options[name] = values[index]; // change the option to the right casing + } else { + // unknown value + console.warn('Warning: Unknown value "' + options[name] + '" for configuration option "' + name + '". Available options: ' + values.map(JSON.stringify).join(', ') + '.'); + } + } +} + +exports.name = 'config'; +exports.math = true; // request the math namespace as fifth argument + +exports.factory = factory; +},{"../../utils/object":55}],6:[function(require,module,exports){ +'use strict'; + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +var lazy = require('../../utils/object').lazy; + +var isFactory = require('../../utils/object').isFactory; + +var traverse = require('../../utils/object').traverse; + +var ArgumentsError = require('../../error/ArgumentsError'); + +function factory(type, config, load, typed, math) { + /** + * Import functions from an object or a module + * + * Syntax: + * + * math.import(object) + * math.import(object, options) + * + * Where: + * + * - `object: Object` + * An object with functions to be imported. + * - `options: Object` An object with import options. Available options: + * - `override: boolean` + * If true, existing functions will be overwritten. False by default. + * - `silent: boolean` + * If true, the function will not throw errors on duplicates or invalid + * types. False by default. + * - `wrap: boolean` + * If true, the functions will be wrapped in a wrapper function + * which converts data types like Matrix to primitive data types like Array. + * The wrapper is needed when extending math.js with libraries which do not + * support these data type. False by default. + * + * Examples: + * + * // define new functions and variables + * math.import({ + * myvalue: 42, + * hello: function (name) { + * return 'hello, ' + name + '!' + * } + * }) + * + * // use the imported function and variable + * math.myvalue * 2 // 84 + * math.hello('user') // 'hello, user!' + * + * // import the npm module 'numbers' + * // (must be installed first with `npm install numbers`) + * math.import(require('numbers'), {wrap: true}) + * + * math.fibonacci(7) // returns 13 + * + * @param {Object | Array} object Object with functions to be imported. + * @param {Object} [options] Import options. + */ + function mathImport(object, options) { + var num = arguments.length; + + if (num !== 1 && num !== 2) { + throw new ArgumentsError('import', num, 1, 2); + } + + if (!options) { + options = {}; + } // TODO: allow a typed-function with name too + + + if (isFactory(object)) { + _importFactory(object, options); + } else if (Array.isArray(object)) { + object.forEach(function (entry) { + mathImport(entry, options); + }); + } else if (_typeof(object) === 'object') { + // a map with functions + for (var name in object) { + if (object.hasOwnProperty(name)) { + var value = object[name]; + + if (isSupportedType(value)) { + _import(name, value, options); + } else if (isFactory(object)) { + _importFactory(object, options); + } else { + mathImport(value, options); + } + } + } + } else { + if (!options.silent) { + throw new TypeError('Factory, Object, or Array expected'); + } + } + } + /** + * Add a property to the math namespace and create a chain proxy for it. + * @param {string} name + * @param {*} value + * @param {Object} options See import for a description of the options + * @private + */ + + + function _import(name, value, options) { + // TODO: refactor this function, it's to complicated and contains duplicate code + if (options.wrap && typeof value === 'function') { + // create a wrapper around the function + value = _wrap(value); + } + + if (isTypedFunction(math[name]) && isTypedFunction(value)) { + if (options.override) { + // give the typed function the right name + value = typed(name, value.signatures); + } else { + // merge the existing and typed function + value = typed(math[name], value); + } + + math[name] = value; + + _importTransform(name, value); + + math.emit('import', name, function resolver() { + return value; + }); + return; + } + + if (math[name] === undefined || options.override) { + math[name] = value; + + _importTransform(name, value); + + math.emit('import', name, function resolver() { + return value; + }); + return; + } + + if (!options.silent) { + throw new Error('Cannot import "' + name + '": already exists'); + } + } + + function _importTransform(name, value) { + if (value && typeof value.transform === 'function') { + math.expression.transform[name] = value.transform; + + if (allowedInExpressions(name)) { + math.expression.mathWithTransform[name] = value.transform; + } + } else { + // remove existing transform + delete math.expression.transform[name]; + + if (allowedInExpressions(name)) { + math.expression.mathWithTransform[name] = value; + } + } + } + + function _deleteTransform(name) { + delete math.expression.transform[name]; + + if (allowedInExpressions(name)) { + math.expression.mathWithTransform[name] = math[name]; + } else { + delete math.expression.mathWithTransform[name]; + } + } + /** + * Create a wrapper a round an function which converts the arguments + * to their primitive values (like convert a Matrix to Array) + * @param {Function} fn + * @return {Function} Returns the wrapped function + * @private + */ + + + function _wrap(fn) { + var wrapper = function wrapper() { + var args = []; + + for (var i = 0, len = arguments.length; i < len; i++) { + var arg = arguments[i]; + args[i] = arg && arg.valueOf(); + } + + return fn.apply(math, args); + }; + + if (fn.transform) { + wrapper.transform = fn.transform; + } + + return wrapper; + } + /** + * Import an instance of a factory into math.js + * @param {{factory: Function, name: string, path: string, math: boolean}} factory + * @param {Object} options See import for a description of the options + * @private + */ + + + function _importFactory(factory, options) { + if (typeof factory.name === 'string') { + var name = factory.name; + var existingTransform = name in math.expression.transform; + var namespace = factory.path ? traverse(math, factory.path) : math; + var existing = namespace.hasOwnProperty(name) ? namespace[name] : undefined; + + var resolver = function resolver() { + var instance = load(factory); + + if (instance && typeof instance.transform === 'function') { + throw new Error('Transforms cannot be attached to factory functions. ' + 'Please create a separate function for it with exports.path="expression.transform"'); + } + + if (isTypedFunction(existing) && isTypedFunction(instance)) { + if (options.override) {// replace the existing typed function (nothing to do) + } else { + // merge the existing and new typed function + instance = typed(existing, instance); + } + + return instance; + } + + if (existing === undefined || options.override) { + return instance; + } + + if (!options.silent) { + throw new Error('Cannot import "' + name + '": already exists'); + } + }; + + if (factory.lazy !== false) { + lazy(namespace, name, resolver); + + if (existingTransform) { + _deleteTransform(name); + } else { + if (factory.path === 'expression.transform' || factoryAllowedInExpressions(factory)) { + lazy(math.expression.mathWithTransform, name, resolver); + } + } + } else { + namespace[name] = resolver(); + + if (existingTransform) { + _deleteTransform(name); + } else { + if (factory.path === 'expression.transform' || factoryAllowedInExpressions(factory)) { + math.expression.mathWithTransform[name] = resolver(); + } + } + } + + math.emit('import', name, resolver, factory.path); + } else { + // unnamed factory. + // no lazy loading + load(factory); + } + } + /** + * Check whether given object is a type which can be imported + * @param {Function | number | string | boolean | null | Unit | Complex} object + * @return {boolean} + * @private + */ + + + function isSupportedType(object) { + return typeof object === 'function' || typeof object === 'number' || typeof object === 'string' || typeof object === 'boolean' || object === null || object && type.isUnit(object) || object && type.isComplex(object) || object && type.isBigNumber(object) || object && type.isFraction(object) || object && type.isMatrix(object) || object && Array.isArray(object); + } + /** + * Test whether a given thing is a typed-function + * @param {*} fn + * @return {boolean} Returns true when `fn` is a typed-function + */ + + + function isTypedFunction(fn) { + return typeof fn === 'function' && _typeof(fn.signatures) === 'object'; + } + + function allowedInExpressions(name) { + return !unsafe.hasOwnProperty(name); + } + + function factoryAllowedInExpressions(factory) { + return factory.path === undefined && !unsafe.hasOwnProperty(factory.name); + } // namespaces and functions not available in the parser for safety reasons + + + var unsafe = { + 'expression': true, + 'type': true, + 'docs': true, + 'error': true, + 'json': true, + 'chain': true // chain method not supported. Note that there is a unit chain too. + + }; + return mathImport; +} + +exports.math = true; // request access to the math namespace as 5th argument of the factory function + +exports.name = 'import'; +exports.factory = factory; +exports.lazy = true; +},{"../../error/ArgumentsError":8,"../../utils/object":55}],7:[function(require,module,exports){ +'use strict'; + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +var typedFunction = require('typed-function'); + +var digits = require('./../utils/number').digits; + +var isBigNumber = require('./../utils/bignumber/isBigNumber'); + +var isMatrix = require('./../utils/collection/isMatrix'); // returns a new instance of typed-function + + +var _createTyped = function createTyped() { + // initially, return the original instance of typed-function + // consecutively, return a new instance from typed.create. + _createTyped = typedFunction.create; + return typedFunction; +}; +/** + * Factory function for creating a new typed instance + * @param {Object} type Object with data types like Complex and BigNumber + * @returns {Function} + */ + + +exports.create = function create(type) { + // TODO: typed-function must be able to silently ignore signatures with unknown data types + // type checks for all known types + // + // note that: + // + // - check by duck-typing on a property like `isUnit`, instead of checking instanceof. + // instanceof cannot be used because that would not allow to pass data from + // one instance of math.js to another since each has it's own instance of Unit. + // - check the `isUnit` property via the constructor, so there will be no + // matches for "fake" instances like plain objects with a property `isUnit`. + // That is important for security reasons. + // - It must not be possible to override the type checks used internally, + // for security reasons, so these functions are not exposed in the expression + // parser. + type.isNumber = function (x) { + return typeof x === 'number'; + }; + + type.isComplex = function (x) { + return type.Complex && x instanceof type.Complex || false; + }; + + type.isBigNumber = isBigNumber; + + type.isFraction = function (x) { + return type.Fraction && x instanceof type.Fraction || false; + }; + + type.isUnit = function (x) { + return x && x.constructor.prototype.isUnit || false; + }; + + type.isString = function (x) { + return typeof x === 'string'; + }; + + type.isArray = Array.isArray; + type.isMatrix = isMatrix; + + type.isDenseMatrix = function (x) { + return x && x.isDenseMatrix && x.constructor.prototype.isMatrix || false; + }; + + type.isSparseMatrix = function (x) { + return x && x.isSparseMatrix && x.constructor.prototype.isMatrix || false; + }; + + type.isRange = function (x) { + return x && x.constructor.prototype.isRange || false; + }; + + type.isIndex = function (x) { + return x && x.constructor.prototype.isIndex || false; + }; + + type.isBoolean = function (x) { + return typeof x === 'boolean'; + }; + + type.isResultSet = function (x) { + return x && x.constructor.prototype.isResultSet || false; + }; + + type.isHelp = function (x) { + return x && x.constructor.prototype.isHelp || false; + }; + + type.isFunction = function (x) { + return typeof x === 'function'; + }; + + type.isDate = function (x) { + return x instanceof Date; + }; + + type.isRegExp = function (x) { + return x instanceof RegExp; + }; + + type.isObject = function (x) { + return _typeof(x) === 'object' && x.constructor === Object && !type.isComplex(x) && !type.isFraction(x); + }; + + type.isNull = function (x) { + return x === null; + }; + + type.isUndefined = function (x) { + return x === undefined; + }; + + type.isAccessorNode = function (x) { + return x && x.isAccessorNode && x.constructor.prototype.isNode || false; + }; + + type.isArrayNode = function (x) { + return x && x.isArrayNode && x.constructor.prototype.isNode || false; + }; + + type.isAssignmentNode = function (x) { + return x && x.isAssignmentNode && x.constructor.prototype.isNode || false; + }; + + type.isBlockNode = function (x) { + return x && x.isBlockNode && x.constructor.prototype.isNode || false; + }; + + type.isConditionalNode = function (x) { + return x && x.isConditionalNode && x.constructor.prototype.isNode || false; + }; + + type.isConstantNode = function (x) { + return x && x.isConstantNode && x.constructor.prototype.isNode || false; + }; + + type.isFunctionAssignmentNode = function (x) { + return x && x.isFunctionAssignmentNode && x.constructor.prototype.isNode || false; + }; + + type.isFunctionNode = function (x) { + return x && x.isFunctionNode && x.constructor.prototype.isNode || false; + }; + + type.isIndexNode = function (x) { + return x && x.isIndexNode && x.constructor.prototype.isNode || false; + }; + + type.isNode = function (x) { + return x && x.isNode && x.constructor.prototype.isNode || false; + }; + + type.isObjectNode = function (x) { + return x && x.isObjectNode && x.constructor.prototype.isNode || false; + }; + + type.isOperatorNode = function (x) { + return x && x.isOperatorNode && x.constructor.prototype.isNode || false; + }; + + type.isParenthesisNode = function (x) { + return x && x.isParenthesisNode && x.constructor.prototype.isNode || false; + }; + + type.isRangeNode = function (x) { + return x && x.isRangeNode && x.constructor.prototype.isNode || false; + }; + + type.isSymbolNode = function (x) { + return x && x.isSymbolNode && x.constructor.prototype.isNode || false; + }; + + type.isChain = function (x) { + return x && x.constructor.prototype.isChain || false; + }; // get a new instance of typed-function + + + var typed = _createTyped(); // define all types. The order of the types determines in which order function + // arguments are type-checked (so for performance it's important to put the + // most used types first). + + + typed.types = [{ + name: 'number', + test: type.isNumber + }, { + name: 'Complex', + test: type.isComplex + }, { + name: 'BigNumber', + test: type.isBigNumber + }, { + name: 'Fraction', + test: type.isFraction + }, { + name: 'Unit', + test: type.isUnit + }, { + name: 'string', + test: type.isString + }, { + name: 'Array', + test: type.isArray + }, { + name: 'Matrix', + test: type.isMatrix + }, { + name: 'DenseMatrix', + test: type.isDenseMatrix + }, { + name: 'SparseMatrix', + test: type.isSparseMatrix + }, { + name: 'Range', + test: type.isRange + }, { + name: 'Index', + test: type.isIndex + }, { + name: 'boolean', + test: type.isBoolean + }, { + name: 'ResultSet', + test: type.isResultSet + }, { + name: 'Help', + test: type.isHelp + }, { + name: 'function', + test: type.isFunction + }, { + name: 'Date', + test: type.isDate + }, { + name: 'RegExp', + test: type.isRegExp + }, { + name: 'null', + test: type.isNull + }, { + name: 'undefined', + test: type.isUndefined + }, { + name: 'OperatorNode', + test: type.isOperatorNode + }, { + name: 'ConstantNode', + test: type.isConstantNode + }, { + name: 'SymbolNode', + test: type.isSymbolNode + }, { + name: 'ParenthesisNode', + test: type.isParenthesisNode + }, { + name: 'FunctionNode', + test: type.isFunctionNode + }, { + name: 'FunctionAssignmentNode', + test: type.isFunctionAssignmentNode + }, { + name: 'ArrayNode', + test: type.isArrayNode + }, { + name: 'AssignmentNode', + test: type.isAssignmentNode + }, { + name: 'BlockNode', + test: type.isBlockNode + }, { + name: 'ConditionalNode', + test: type.isConditionalNode + }, { + name: 'IndexNode', + test: type.isIndexNode + }, { + name: 'RangeNode', + test: type.isRangeNode + }, { + name: 'Node', + test: type.isNode + }, { + name: 'Object', + test: type.isObject // order 'Object' last, it matches on other classes too + + }]; // TODO: add conversion from BigNumber to number? + + typed.conversions = [{ + from: 'number', + to: 'BigNumber', + convert: function convert(x) { + // note: conversion from number to BigNumber can fail if x has >15 digits + if (digits(x) > 15) { + throw new TypeError('Cannot implicitly convert a number with >15 significant digits to BigNumber ' + '(value: ' + x + '). ' + 'Use function bignumber(x) to convert to BigNumber.'); + } + + return new type.BigNumber(x); + } + }, { + from: 'number', + to: 'Complex', + convert: function convert(x) { + return new type.Complex(x, 0); + } + }, { + from: 'number', + to: 'string', + convert: function convert(x) { + return x + ''; + } + }, { + from: 'BigNumber', + to: 'Complex', + convert: function convert(x) { + return new type.Complex(x.toNumber(), 0); + } + }, { + from: 'Fraction', + to: 'BigNumber', + convert: function convert(x) { + throw new TypeError('Cannot implicitly convert a Fraction to BigNumber or vice versa. ' + 'Use function bignumber(x) to convert to BigNumber or fraction(x) to convert to Fraction.'); + } + }, { + from: 'Fraction', + to: 'Complex', + convert: function convert(x) { + return new type.Complex(x.valueOf(), 0); + } + }, { + from: 'number', + to: 'Fraction', + convert: function convert(x) { + var f = new type.Fraction(x); + + if (f.valueOf() !== x) { + throw new TypeError('Cannot implicitly convert a number to a Fraction when there will be a loss of precision ' + '(value: ' + x + '). ' + 'Use function fraction(x) to convert to Fraction.'); + } + + return new type.Fraction(x); + } + }, { + // FIXME: add conversion from Fraction to number, for example for `sqrt(fraction(1,3))` + // from: 'Fraction', + // to: 'number', + // convert: function (x) { + // return x.valueOf() + // } + // }, { + from: 'string', + to: 'number', + convert: function convert(x) { + var n = Number(x); + + if (isNaN(n)) { + throw new Error('Cannot convert "' + x + '" to a number'); + } + + return n; + } + }, { + from: 'string', + to: 'BigNumber', + convert: function convert(x) { + try { + return new type.BigNumber(x); + } catch (err) { + throw new Error('Cannot convert "' + x + '" to BigNumber'); + } + } + }, { + from: 'string', + to: 'Fraction', + convert: function convert(x) { + try { + return new type.Fraction(x); + } catch (err) { + throw new Error('Cannot convert "' + x + '" to Fraction'); + } + } + }, { + from: 'string', + to: 'Complex', + convert: function convert(x) { + try { + return new type.Complex(x); + } catch (err) { + throw new Error('Cannot convert "' + x + '" to Complex'); + } + } + }, { + from: 'boolean', + to: 'number', + convert: function convert(x) { + return +x; + } + }, { + from: 'boolean', + to: 'BigNumber', + convert: function convert(x) { + return new type.BigNumber(+x); + } + }, { + from: 'boolean', + to: 'Fraction', + convert: function convert(x) { + return new type.Fraction(+x); + } + }, { + from: 'boolean', + to: 'string', + convert: function convert(x) { + return +x; + } + }, { + from: 'Array', + to: 'Matrix', + convert: function convert(array) { + return new type.DenseMatrix(array); + } + }, { + from: 'Matrix', + to: 'Array', + convert: function convert(matrix) { + return matrix.valueOf(); + } + }]; + return typed; +}; +},{"./../utils/bignumber/isBigNumber":48,"./../utils/collection/isMatrix":50,"./../utils/number":54,"typed-function":59}],8:[function(require,module,exports){ +'use strict'; +/** + * Create a syntax error with the message: + * 'Wrong number of arguments in function <fn> (<count> provided, <min>-<max> expected)' + * @param {string} fn Function name + * @param {number} count Actual argument count + * @param {number} min Minimum required argument count + * @param {number} [max] Maximum required argument count + * @extends Error + */ + +function ArgumentsError(fn, count, min, max) { + if (!(this instanceof ArgumentsError)) { + throw new SyntaxError('Constructor must be called with the new operator'); + } + + this.fn = fn; + this.count = count; + this.min = min; + this.max = max; + this.message = 'Wrong number of arguments in function ' + fn + ' (' + count + ' provided, ' + min + (max !== undefined && max !== null ? '-' + max : '') + ' expected)'; + this.stack = new Error().stack; +} + +ArgumentsError.prototype = new Error(); +ArgumentsError.prototype.constructor = Error; +ArgumentsError.prototype.name = 'ArgumentsError'; +ArgumentsError.prototype.isArgumentsError = true; +module.exports = ArgumentsError; +},{}],9:[function(require,module,exports){ +'use strict'; +/** + * Create a range error with the message: + * 'Dimension mismatch (<actual size> != <expected size>)' + * @param {number | number[]} actual The actual size + * @param {number | number[]} expected The expected size + * @param {string} [relation='!='] Optional relation between actual + * and expected size: '!=', '<', etc. + * @extends RangeError + */ + +function DimensionError(actual, expected, relation) { + if (!(this instanceof DimensionError)) { + throw new SyntaxError('Constructor must be called with the new operator'); + } + + this.actual = actual; + this.expected = expected; + this.relation = relation; + this.message = 'Dimension mismatch (' + (Array.isArray(actual) ? '[' + actual.join(', ') + ']' : actual) + ' ' + (this.relation || '!=') + ' ' + (Array.isArray(expected) ? '[' + expected.join(', ') + ']' : expected) + ')'; + this.stack = new Error().stack; +} + +DimensionError.prototype = new RangeError(); +DimensionError.prototype.constructor = RangeError; +DimensionError.prototype.name = 'DimensionError'; +DimensionError.prototype.isDimensionError = true; +module.exports = DimensionError; +},{}],10:[function(require,module,exports){ +'use strict'; +/** + * Create a range error with the message: + * 'Index out of range (index < min)' + * 'Index out of range (index < max)' + * + * @param {number} index The actual index + * @param {number} [min=0] Minimum index (included) + * @param {number} [max] Maximum index (excluded) + * @extends RangeError + */ + +function IndexError(index, min, max) { + if (!(this instanceof IndexError)) { + throw new SyntaxError('Constructor must be called with the new operator'); + } + + this.index = index; + + if (arguments.length < 3) { + this.min = 0; + this.max = min; + } else { + this.min = min; + this.max = max; + } + + if (this.min !== undefined && this.index < this.min) { + this.message = 'Index out of range (' + this.index + ' < ' + this.min + ')'; + } else if (this.max !== undefined && this.index >= this.max) { + this.message = 'Index out of range (' + this.index + ' > ' + (this.max - 1) + ')'; + } else { + this.message = 'Index out of range (' + this.index + ')'; + } + + this.stack = new Error().stack; +} + +IndexError.prototype = new RangeError(); +IndexError.prototype.constructor = RangeError; +IndexError.prototype.name = 'IndexError'; +IndexError.prototype.isIndexError = true; +module.exports = IndexError; +},{}],11:[function(require,module,exports){ +'use strict'; + +var deepMap = require('../../utils/collection/deepMap'); + +function factory(type, config, load, typed) { + var parse = load(require('../parse')); + /** + * Parse and compile an expression. + * Returns a an object with a function `eval([scope])` to evaluate the + * compiled expression. + * + * Syntax: + * + * math.compile(expr) // returns one node + * math.compile([expr1, expr2, expr3, ...]) // returns an array with nodes + * + * Examples: + * + * const code1 = math.compile('sqrt(3^2 + 4^2)') + * code1.eval() // 5 + * + * let scope = {a: 3, b: 4} + * const code2 = math.compile('a * b') // 12 + * code2.eval(scope) // 12 + * scope.a = 5 + * code2.eval(scope) // 20 + * + * const nodes = math.compile(['a = 3', 'b = 4', 'a * b']) + * nodes[2].eval() // 12 + * + * See also: + * + * parse, eval + * + * @param {string | string[] | Array | Matrix} expr + * The expression to be compiled + * @return {{eval: Function} | Array.<{eval: Function}>} code + * An object with the compiled expression + * @throws {Error} + */ + + return typed('compile', { + 'string': function string(expr) { + return parse(expr).compile(); + }, + 'Array | Matrix': function ArrayMatrix(expr) { + return deepMap(expr, function (entry) { + return parse(entry).compile(); + }); + } + }); +} + +exports.name = 'compile'; +exports.factory = factory; +},{"../../utils/collection/deepMap":49,"../parse":34}],12:[function(require,module,exports){ +'use strict'; + +var deepMap = require('../../utils/collection/deepMap'); + +function factory(type, config, load, typed) { + var parse = load(require('../parse')); + /** + * Evaluate an expression. + * + * Note the evaluating arbitrary expressions may involve security risks, + * see [http://mathjs.org/docs/expressions/security.html](http://mathjs.org/docs/expressions/security.html) for more information. + * + * Syntax: + * + * math.eval(expr) + * math.eval(expr, scope) + * math.eval([expr1, expr2, expr3, ...]) + * math.eval([expr1, expr2, expr3, ...], scope) + * + * Example: + * + * math.eval('(2+3)/4') // 1.25 + * math.eval('sqrt(3^2 + 4^2)') // 5 + * math.eval('sqrt(-4)') // 2i + * math.eval(['a=3', 'b=4', 'a*b']) // [3, 4, 12] + * + * let scope = {a:3, b:4} + * math.eval('a * b', scope) // 12 + * + * See also: + * + * parse, compile + * + * @param {string | string[] | Matrix} expr The expression to be evaluated + * @param {Object} [scope] Scope to read/write variables + * @return {*} The result of the expression + * @throws {Error} + */ + + return typed('compile', { + 'string': function string(expr) { + var scope = {}; + return parse(expr).compile().eval(scope); + }, + 'string, Object': function stringObject(expr, scope) { + return parse(expr).compile().eval(scope); + }, + 'Array | Matrix': function ArrayMatrix(expr) { + var scope = {}; + return deepMap(expr, function (entry) { + return parse(entry).compile().eval(scope); + }); + }, + 'Array | Matrix, Object': function ArrayMatrixObject(expr, scope) { + return deepMap(expr, function (entry) { + return parse(entry).compile().eval(scope); + }); + } + }); +} + +exports.name = 'eval'; +exports.factory = factory; +},{"../../utils/collection/deepMap":49,"../parse":34}],13:[function(require,module,exports){ +'use strict'; + +function factory(type, config, load, typed) { + var parse = load(require('../parse')); + /** + * Parse an expression. Returns a node tree, which can be evaluated by + * invoking node.eval(). + * + * Note the evaluating arbitrary expressions may involve security risks, + * see [http://mathjs.org/docs/expressions/security.html](http://mathjs.org/docs/expressions/security.html) for more information. + * + * Syntax: + * + * math.parse(expr) + * math.parse(expr, options) + * math.parse([expr1, expr2, expr3, ...]) + * math.parse([expr1, expr2, expr3, ...], options) + * + * Example: + * + * const node1 = math.parse('sqrt(3^2 + 4^2)') + * node1.compile().eval() // 5 + * + * let scope = {a:3, b:4} + * const node2 = math.parse('a * b') // 12 + * const code2 = node2.compile() + * code2.eval(scope) // 12 + * scope.a = 5 + * code2.eval(scope) // 20 + * + * const nodes = math.parse(['a = 3', 'b = 4', 'a * b']) + * nodes[2].compile().eval() // 12 + * + * See also: + * + * eval, compile + * + * @param {string | string[] | Matrix} expr Expression to be parsed + * @param {{nodes: Object<string, Node>}} [options] Available options: + * - `nodes` a set of custom nodes + * @return {Node | Node[]} node + * @throws {Error} + */ + + return typed('parse', { + 'string | Array | Matrix': parse, + 'string | Array | Matrix, Object': parse + }); +} + +exports.name = 'parse'; +exports.factory = factory; +},{"../parse":34}],14:[function(require,module,exports){ +'use strict'; // Reserved keywords not allowed to use in the parser + +module.exports = { + end: true +}; +},{}],15:[function(require,module,exports){ +'use strict'; + +var getSafeProperty = require('../../utils/customs').getSafeProperty; + +function factory(type, config, load, typed) { + var Node = load(require('./Node')); + var access = load(require('./utils/access')); + /** + * @constructor AccessorNode + * @extends {Node} + * Access an object property or get a matrix subset + * + * @param {Node} object The object from which to retrieve + * a property or subset. + * @param {IndexNode} index IndexNode containing ranges + */ + + function AccessorNode(object, index) { + if (!(this instanceof AccessorNode)) { + throw new SyntaxError('Constructor must be called with the new operator'); + } + + if (!type.isNode(object)) { + throw new TypeError('Node expected for parameter "object"'); + } + + if (!type.isIndexNode(index)) { + throw new TypeError('IndexNode expected for parameter "index"'); + } + + this.object = object || null; + this.index = index; // readonly property name + + Object.defineProperty(this, 'name', { + get: function () { + if (this.index) { + return this.index.isObjectProperty() ? this.index.getObjectProperty() : ''; + } else { + return this.object.name || ''; + } + }.bind(this), + set: function set() { + throw new Error('Cannot assign a new name, name is read-only'); + } + }); + } + + AccessorNode.prototype = new Node(); + AccessorNode.prototype.type = 'AccessorNode'; + AccessorNode.prototype.isAccessorNode = 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: *) + */ + + AccessorNode.prototype._compile = function (math, argNames) { + var evalObject = this.object._compile(math, argNames); + + var evalIndex = this.index._compile(math, argNames); + + if (this.index.isObjectProperty()) { + var prop = this.index.getObjectProperty(); + return function evalAccessorNode(scope, args, context) { + return getSafeProperty(evalObject(scope, args, context), prop); + }; + } else { + return function evalAccessorNode(scope, args, context) { + var object = evalObject(scope, args, context); + var index = evalIndex(scope, args, object); // we pass object here instead of context + + return access(object, index); + }; + } + }; + /** + * Execute a callback for each of the child nodes of this node + * @param {function(child: Node, path: string, parent: Node)} callback + */ + + + AccessorNode.prototype.forEach = function (callback) { + callback(this.object, 'object', this); + callback(this.index, 'index', this); + }; + /** + * Create a new AccessorNode having it's childs be the results of calling + * the provided callback function for each of the childs of the original node. + * @param {function(child: Node, path: string, parent: Node): Node} callback + * @returns {AccessorNode} Returns a transformed copy of the node + */ + + + AccessorNode.prototype.map = function (callback) { + return new AccessorNode(this._ifNode(callback(this.object, 'object', this)), this._ifNode(callback(this.index, 'index', this))); + }; + /** + * Create a clone of this node, a shallow copy + * @return {AccessorNode} + */ + + + AccessorNode.prototype.clone = function () { + return new AccessorNode(this.object, this.index); + }; + /** + * Get string representation + * @param {Object} options + * @return {string} + */ + + + AccessorNode.prototype._toString = function (options) { + var object = this.object.toString(options); + + if (needParenthesis(this.object)) { + object = '(' + object + ')'; + } + + return object + this.index.toString(options); + }; + /** + * Get HTML representation + * @param {Object} options + * @return {string} + */ + + + AccessorNode.prototype.toHTML = function (options) { + var object = this.object.toHTML(options); + + if (needParenthesis(this.object)) { + object = '<span class="math-parenthesis math-round-parenthesis">(</span>' + object + '<span class="math-parenthesis math-round-parenthesis">)</span>'; + } + + return object + this.index.toHTML(options); + }; + /** + * Get LaTeX representation + * @param {Object} options + * @return {string} + */ + + + AccessorNode.prototype._toTex = function (options) { + var object = this.object.toTex(options); + + if (needParenthesis(this.object)) { + object = "\\left(' + object + '\\right)"; + } + + return object + this.index.toTex(options); + }; + /** + * Get a JSON representation of the node + * @returns {Object} + */ + + + AccessorNode.prototype.toJSON = function () { + return { + mathjs: 'AccessorNode', + object: this.object, + index: this.index + }; + }; + /** + * Instantiate an AccessorNode from its JSON representation + * @param {Object} json An object structured like + * `{"mathjs": "AccessorNode", object: ..., index: ...}`, + * where mathjs is optional + * @returns {AccessorNode} + */ + + + AccessorNode.fromJSON = function (json) { + return new AccessorNode(json.object, json.index); + }; + /** + * Are parenthesis needed? + * @private + */ + + + function needParenthesis(node) { + // TODO: maybe make a method on the nodes which tells whether they need parenthesis? + return !(type.isAccessorNode(node) || type.isArrayNode(node) || type.isConstantNode(node) || type.isFunctionNode(node) || type.isObjectNode(node) || type.isParenthesisNode(node) || type.isSymbolNode(node)); + } + + return AccessorNode; +} + +exports.name = 'AccessorNode'; +exports.path = 'expression.node'; +exports.factory = factory; +},{"../../utils/customs":51,"./Node":24,"./utils/access":31}],16:[function(require,module,exports){ +'use strict'; + +var map = require('../../utils/array').map; + +function factory(type, config, load, typed) { + var Node = load(require('./Node')); + /** + * @constructor ArrayNode + * @extends {Node} + * Holds an 1-dimensional array with items + * @param {Node[]} [items] 1 dimensional array with items + */ + + function ArrayNode(items) { + if (!(this instanceof ArrayNode)) { + throw new SyntaxError('Constructor must be called with the new operator'); + } + + this.items = items || []; // validate input + + if (!Array.isArray(this.items) || !this.items.every(type.isNode)) { + throw new TypeError('Array containing Nodes expected'); + } // TODO: deprecated since v3, remove some day + + + var deprecated = function deprecated() { + throw new Error('Property `ArrayNode.nodes` is deprecated, use `ArrayNode.items` instead'); + }; + + Object.defineProperty(this, 'nodes', { + get: deprecated, + set: deprecated + }); + } + + ArrayNode.prototype = new Node(); + ArrayNode.prototype.type = 'ArrayNode'; + ArrayNode.prototype.isArrayNode = 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: *) + */ + + ArrayNode.prototype._compile = function (math, argNames) { + var evalItems = map(this.items, function (item) { + return item._compile(math, argNames); + }); + var asMatrix = math.config().matrix !== 'Array'; + + if (asMatrix) { + var matrix = math.matrix; + return function evalArrayNode(scope, args, context) { + return matrix(map(evalItems, function (evalItem) { + return evalItem(scope, args, context); + })); + }; + } else { + return function evalArrayNode(scope, args, context) { + return map(evalItems, function (evalItem) { + return evalItem(scope, args, context); + }); + }; + } + }; + /** + * Execute a callback for each of the child nodes of this node + * @param {function(child: Node, path: string, parent: Node)} callback + */ + + + ArrayNode.prototype.forEach = function (callback) { + for (var i = 0; i < this.items.length; i++) { + var node = this.items[i]; + callback(node, 'items[' + i + ']', this); + } + }; + /** + * Create a new ArrayNode having it's childs be the results of calling + * the provided callback function for each of the childs of the original node. + * @param {function(child: Node, path: string, parent: Node): Node} callback + * @returns {ArrayNode} Returns a transformed copy of the node + */ + + + ArrayNode.prototype.map = function (callback) { + var items = []; + + for (var i = 0; i < this.items.length; i++) { + items[i] = this._ifNode(callback(this.items[i], 'items[' + i + ']', this)); + } + + return new ArrayNode(items); + }; + /** + * Create a clone of this node, a shallow copy + * @return {ArrayNode} + */ + + + ArrayNode.prototype.clone = function () { + return new ArrayNode(this.items.slice(0)); + }; + /** + * Get string representation + * @param {Object} options + * @return {string} str + * @override + */ + + + ArrayNode.prototype._toString = function (options) { + var items = this.items.map(function (node) { + return node.toString(options); + }); + return '[' + items.join(', ') + ']'; + }; + /** + * Get a JSON representation of the node + * @returns {Object} + */ + + + ArrayNode.prototype.toJSON = function () { + return { + mathjs: 'ArrayNode', + items: this.items + }; + }; + /** + * Instantiate an ArrayNode from its JSON representation + * @param {Object} json An object structured like + * `{"mathjs": "ArrayNode", items: [...]}`, + * where mathjs is optional + * @returns {ArrayNode} + */ + + + ArrayNode.fromJSON = function (json) { + return new ArrayNode(json.items); + }; + /** + * Get HTML representation + * @param {Object} options + * @return {string} str + * @override + */ + + + ArrayNode.prototype.toHTML = function (options) { + var items = this.items.map(function (node) { + return node.toHTML(options); + }); + return '<span class="math-parenthesis math-square-parenthesis">[</span>' + items.join('<span class="math-separator">,</span>') + '<span class="math-parenthesis math-square-parenthesis">]</span>'; + }; + /** + * Get LaTeX representation + * @param {Object} options + * @return {string} str + */ + + + ArrayNode.prototype._toTex = function (options) { + var s = '\\begin{bmatrix}'; + this.items.forEach(function (node) { + if (node.items) { + s += node.items.map(function (childNode) { + return childNode.toTex(options); + }).join('&'); + } else { + s += node.toTex(options); + } // new line + + + s += '\\\\'; + }); + s += '\\end{bmatrix}'; + return s; + }; + + return ArrayNode; +} + +exports.name = 'ArrayNode'; +exports.path = 'expression.node'; +exports.factory = factory; +},{"../../utils/array":46,"./Node":24}],17:[function(require,module,exports){ +'use strict'; + +var getSafeProperty = require('../../utils/customs').getSafeProperty; + +var setSafeProperty = require('../../utils/customs').setSafeProperty; + +function factory(type, config, load, typed) { + var Node = load(require('./Node')); + var assign = load(require('./utils/assign')); + var access = load(require('./utils/access')); + + var operators = require('../operators'); + /** + * @constructor AssignmentNode + * @extends {Node} + * + * Define a symbol, like `a=3.2`, update a property like `a.b=3.2`, or + * replace a subset of a matrix like `A[2,2]=42`. + * + * Syntax: + * + * new AssignmentNode(symbol, value) + * new AssignmentNode(object, index, value) + * + * Usage: + * + * new AssignmentNode(new SymbolNode('a'), new ConstantNode(2)) // a=2 + * new AssignmentNode(new SymbolNode('a'), new IndexNode('b'), new ConstantNode(2)) // a.b=2 + * new AssignmentNode(new SymbolNode('a'), new IndexNode(1, 2), new ConstantNode(3)) // a[1,2]=3 + * + * @param {SymbolNode | AccessorNode} object Object on which to assign a value + * @param {IndexNode} [index=null] Index, property name or matrix + * index. Optional. If not provided + * and `object` is a SymbolNode, + * the property is assigned to the + * global scope. + * @param {Node} value The value to be assigned + */ + + + function AssignmentNode(object, index, value) { + if (!(this instanceof AssignmentNode)) { + throw new SyntaxError('Constructor must be called with the new operator'); + } + + this.object = object; + this.index = value ? index : null; + this.value = value || index; // validate input + + if (!type.isSymbolNode(object) && !type.isAccessorNode(object)) { + throw new TypeError('SymbolNode or AccessorNode expected as "object"'); + } + + if (type.isSymbolNode(object) && object.name === 'end') { + throw new Error('Cannot assign to symbol "end"'); + } + + if (this.index && !type.isIndexNode(this.index)) { + // index is optional + throw new TypeError('IndexNode expected as "index"'); + } + + if (!type.isNode(this.value)) { + throw new TypeError('Node expected as "value"'); + } // readonly property name + + + Object.defineProperty(this, 'name', { + get: function () { + if (this.index) { + return this.index.isObjectProperty() ? this.index.getObjectProperty() : ''; + } else { + return this.object.name || ''; + } + }.bind(this), + set: function set() { + throw new Error('Cannot assign a new name, name is read-only'); + } + }); + } + + AssignmentNode.prototype = new Node(); + AssignmentNode.prototype.type = 'AssignmentNode'; + AssignmentNode.prototype.isAssignmentNode = 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: *) + */ + + AssignmentNode.prototype._compile = function (math, argNames) { + var evalObject = this.object._compile(math, argNames); + + var evalIndex = this.index ? this.index._compile(math, argNames) : null; + + var evalValue = this.value._compile(math, argNames); + + var name = this.object.name; + + if (!this.index) { + // apply a variable to the scope, for example `a=2` + if (!type.isSymbolNode(this.object)) { + throw new TypeError('SymbolNode expected as object'); + } + + return function evalAssignmentNode(scope, args, context) { + return setSafeProperty(scope, name, evalValue(scope, args, context)); + }; + } else if (this.index.isObjectProperty()) { + // apply an object property for example `a.b=2` + var prop = this.index.getObjectProperty(); + return function evalAssignmentNode(scope, args, context) { + var object = evalObject(scope, args, context); + var value = evalValue(scope, args, context); + return setSafeProperty(object, prop, value); + }; + } else if (type.isSymbolNode(this.object)) { + // update a matrix subset, for example `a[2]=3` + return function evalAssignmentNode(scope, args, context) { + var childObject = evalObject(scope, args, context); + var value = evalValue(scope, args, context); + var index = evalIndex(scope, args, childObject); // Important: we pass childObject instead of context + + setSafeProperty(scope, name, assign(childObject, index, value)); + return value; + }; + } else { + // type.isAccessorNode(node.object) === true + // update a matrix subset, for example `a.b[2]=3` + // we will not use the compile function of the AccessorNode, but compile it + // ourselves here as we need the parent object of the AccessorNode: + // wee need to apply the updated object to parent object + var evalParentObject = this.object.object._compile(math, argNames); + + if (this.object.index.isObjectProperty()) { + var parentProp = this.object.index.getObjectProperty(); + return function evalAssignmentNode(scope, args, context) { + var parent = evalParentObject(scope, args, context); + var childObject = getSafeProperty(parent, parentProp); + var index = evalIndex(scope, args, childObject); // Important: we pass childObject instead of context + + var value = evalValue(scope, args, context); + setSafeProperty(parent, parentProp, assign(childObject, index, value)); + return value; + }; + } else { + // if some parameters use the 'end' parameter, we need to calculate the size + var evalParentIndex = this.object.index._compile(math, argNames); + + return function evalAssignmentNode(scope, args, context) { + var parent = evalParentObject(scope, args, context); + var parentIndex = evalParentIndex(scope, args, parent); // Important: we pass parent instead of context + + var childObject = access(parent, parentIndex); + var index = evalIndex(scope, args, childObject); // Important: we pass childObject instead of context + + var value = evalValue(scope, args, context); + assign(parent, parentIndex, assign(childObject, index, value)); + return value; + }; + } + } + }; + /** + * Execute a callback for each of the child nodes of this node + * @param {function(child: Node, path: string, parent: Node)} callback + */ + + + AssignmentNode.prototype.forEach = function (callback) { + callback(this.object, 'object', this); + + if (this.index) { + callback(this.index, 'index', this); + } + + callback(this.value, 'value', this); + }; + /** + * Create a new AssignmentNode having it's childs be the results of calling + * the provided callback function for each of the childs of the original node. + * @param {function(child: Node, path: string, parent: Node): Node} callback + * @returns {AssignmentNode} Returns a transformed copy of the node + */ + + + AssignmentNode.prototype.map = function (callback) { + var object = this._ifNode(callback(this.object, 'object', this)); + + var index = this.index ? this._ifNode(callback(this.index, 'index', this)) : null; + + var value = this._ifNode(callback(this.value, 'value', this)); + + return new AssignmentNode(object, index, value); + }; + /** + * Create a clone of this node, a shallow copy + * @return {AssignmentNode} + */ + + + AssignmentNode.prototype.clone = function () { + return new AssignmentNode(this.object, this.index, this.value); + }; + /* + * Is parenthesis needed? + * @param {node} node + * @param {string} [parenthesis='keep'] + * @private + */ + + + function needParenthesis(node, parenthesis) { + if (!parenthesis) { + parenthesis = 'keep'; + } + + var precedence = operators.getPrecedence(node, parenthesis); + var exprPrecedence = operators.getPrecedence(node.value, parenthesis); + return parenthesis === 'all' || exprPrecedence !== null && exprPrecedence <= precedence; + } + /** + * Get string representation + * @param {Object} options + * @return {string} + */ + + + AssignmentNode.prototype._toString = function (options) { + var object = this.object.toString(options); + var index = this.index ? this.index.toString(options) : ''; + var value = this.value.toString(options); + + if (needParenthesis(this, options && options.parenthesis)) { + value = '(' + value + ')'; + } + + return object + index + ' = ' + value; + }; + /** + * Get a JSON representation of the node + * @returns {Object} + */ + + + AssignmentNode.prototype.toJSON = function () { + return { + mathjs: 'AssignmentNode', + object: this.object, + index: this.index, + value: this.value + }; + }; + /** + * Instantiate an AssignmentNode from its JSON representation + * @param {Object} json An object structured like + * `{"mathjs": "AssignmentNode", object: ..., index: ..., value: ...}`, + * where mathjs is optional + * @returns {AssignmentNode} + */ + + + AssignmentNode.fromJSON = function (json) { + return new AssignmentNode(json.object, json.index, json.value); + }; + /** + * Get HTML representation + * @param {Object} options + * @return {string} + */ + + + AssignmentNode.prototype.toHTML = function (options) { + var object = this.object.toHTML(options); + var index = this.index ? this.index.toHTML(options) : ''; + var value = this.value.toHTML(options); + + if (needParenthesis(this, options && options.parenthesis)) { + value = '<span class="math-paranthesis math-round-parenthesis">(</span>' + value + '<span class="math-paranthesis math-round-parenthesis">)</span>'; + } + + return object + index + '<span class="math-operator math-assignment-operator math-variable-assignment-operator math-binary-operator">=</span>' + value; + }; + /** + * Get LaTeX representation + * @param {Object} options + * @return {string} + */ + + + AssignmentNode.prototype._toTex = function (options) { + var object = this.object.toTex(options); + var index = this.index ? this.index.toTex(options) : ''; + var value = this.value.toTex(options); + + if (needParenthesis(this, options && options.parenthesis)) { + value = "\\left(".concat(value, "\\right)"); + } + + return object + index + ':=' + value; + }; + + return AssignmentNode; +} + +exports.name = 'AssignmentNode'; +exports.path = 'expression.node'; +exports.factory = factory; +},{"../../utils/customs":51,"../operators":33,"./Node":24,"./utils/access":31,"./utils/assign":32}],18:[function(require,module,exports){ +'use strict'; + +var forEach = require('../../utils/array').forEach; + +var map = require('../../utils/array').map; + +function factory(type, config, load, typed) { + var Node = load(require('./Node')); + var ResultSet = load(require('../../type/resultset/ResultSet')); + /** + * @constructor BlockNode + * @extends {Node} + * Holds a set with blocks + * @param {Array.<{node: Node} | {node: Node, visible: boolean}>} blocks + * An array with blocks, where a block is constructed as an Object + * with properties block, which is a Node, and visible, which is + * a boolean. The property visible is optional and is true by default + */ + + function BlockNode(blocks) { + if (!(this instanceof BlockNode)) { + throw new SyntaxError('Constructor must be called with the new operator'); + } // validate input, copy blocks + + + if (!Array.isArray(blocks)) throw new Error('Array expected'); + this.blocks = blocks.map(function (block) { + var node = block && block.node; + var visible = block && block.visible !== undefined ? block.visible : true; + if (!type.isNode(node)) throw new TypeError('Property "node" must be a Node'); + if (typeof visible !== 'boolean') throw new TypeError('Property "visible" must be a boolean'); + return { + node: node, + visible: visible + }; + }); + } + + BlockNode.prototype = new Node(); + BlockNode.prototype.type = 'BlockNode'; + BlockNode.prototype.isBlockNode = 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: *) + */ + + BlockNode.prototype._compile = function (math, argNames) { + var evalBlocks = map(this.blocks, function (block) { + return { + eval: block.node._compile(math, argNames), + visible: block.visible + }; + }); + return function evalBlockNodes(scope, args, context) { + var results = []; + forEach(evalBlocks, function evalBlockNode(block) { + var result = block.eval(scope, args, context); + + if (block.visible) { + results.push(result); + } + }); + return new ResultSet(results); + }; + }; + /** + * Execute a callback for each of the child blocks of this node + * @param {function(child: Node, path: string, parent: Node)} callback + */ + + + BlockNode.prototype.forEach = function (callback) { + for (var i = 0; i < this.blocks.length; i++) { + callback(this.blocks[i].node, 'blocks[' + i + '].node', this); + } + }; + /** + * Create a new BlockNode having it's childs be the results of calling + * the provided callback function for each of the childs of the original node. + * @param {function(child: Node, path: string, parent: Node): Node} callback + * @returns {BlockNode} Returns a transformed copy of the node + */ + + + BlockNode.prototype.map = function (callback) { + var blocks = []; + + for (var i = 0; i < this.blocks.length; i++) { + var block = this.blocks[i]; + + var node = this._ifNode(callback(block.node, 'blocks[' + i + '].node', this)); + + blocks[i] = { + node: node, + visible: block.visible + }; + } + + return new BlockNode(blocks); + }; + /** + * Create a clone of this node, a shallow copy + * @return {BlockNode} + */ + + + BlockNode.prototype.clone = function () { + var blocks = this.blocks.map(function (block) { + return { + node: block.node, + visible: block.visible + }; + }); + return new BlockNode(blocks); + }; + /** + * Get string representation + * @param {Object} options + * @return {string} str + * @override + */ + + + BlockNode.prototype._toString = function (options) { + return this.blocks.map(function (param) { + return param.node.toString(options) + (param.visible ? '' : ';'); + }).join('\n'); + }; + /** + * Get a JSON representation of the node + * @returns {Object} + */ + + + BlockNode.prototype.toJSON = function () { + return { + mathjs: 'BlockNode', + blocks: this.blocks + }; + }; + /** + * Instantiate an BlockNode from its JSON representation + * @param {Object} json An object structured like + * `{"mathjs": "BlockNode", blocks: [{node: ..., visible: false}, ...]}`, + * where mathjs is optional + * @returns {BlockNode} + */ + + + BlockNode.fromJSON = function (json) { + return new BlockNode(json.blocks); + }; + /** + * Get HTML representation + * @param {Object} options + * @return {string} str + * @override + */ + + + BlockNode.prototype.toHTML = function (options) { + return this.blocks.map(function (param) { + return param.node.toHTML(options) + (param.visible ? '' : '<span class="math-separator">;</span>'); + }).join('<span class="math-separator"><br /></span>'); + }; + /** + * Get LaTeX representation + * @param {Object} options + * @return {string} str + */ + + + BlockNode.prototype._toTex = function (options) { + return this.blocks.map(function (param) { + return param.node.toTex(options) + (param.visible ? '' : ';'); + }).join('\\;\\;\n'); + }; + + return BlockNode; +} + +exports.name = 'BlockNode'; +exports.path = 'expression.node'; +exports.factory = factory; +},{"../../type/resultset/ResultSet":45,"../../utils/array":46,"./Node":24}],19:[function(require,module,exports){ +'use strict'; + +var operators = require('../operators'); + +function factory(type, config, load, typed) { + var Node = load(require('./Node')); + var mathTypeOf = load(require('../../function/utils/typeof')); + /** + * A lazy evaluating conditional operator: 'condition ? trueExpr : falseExpr' + * + * @param {Node} condition Condition, must result in a boolean + * @param {Node} trueExpr Expression evaluated when condition is true + * @param {Node} falseExpr Expression evaluated when condition is true + * + * @constructor ConditionalNode + * @extends {Node} + */ + + function ConditionalNode(condition, trueExpr, falseExpr) { + if (!(this instanceof ConditionalNode)) { + throw new SyntaxError('Constructor must be called with the new operator'); + } + + if (!type.isNode(condition)) throw new TypeError('Parameter condition must be a Node'); + if (!type.isNode(trueExpr)) throw new TypeError('Parameter trueExpr must be a Node'); + if (!type.isNode(falseExpr)) throw new TypeError('Parameter falseExpr must be a Node'); + this.condition = condition; + this.trueExpr = trueExpr; + this.falseExpr = falseExpr; + } + + ConditionalNode.prototype = new Node(); + ConditionalNode.prototype.type = 'ConditionalNode'; + ConditionalNode.prototype.isConditionalNode = 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: *) + */ + + ConditionalNode.prototype._compile = function (math, argNames) { + var evalCondition = this.condition._compile(math, argNames); + + var evalTrueExpr = this.trueExpr._compile(math, argNames); + + var evalFalseExpr = this.falseExpr._compile(math, argNames); + + return function evalConditionalNode(scope, args, context) { + return testCondition(evalCondition(scope, args, context)) ? evalTrueExpr(scope, args, context) : evalFalseExpr(scope, args, context); + }; + }; + /** + * Execute a callback for each of the child nodes of this node + * @param {function(child: Node, path: string, parent: Node)} callback + */ + + + ConditionalNode.prototype.forEach = function (callback) { + callback(this.condition, 'condition', this); + callback(this.trueExpr, 'trueExpr', this); + callback(this.falseExpr, 'falseExpr', this); + }; + /** + * Create a new ConditionalNode having it's childs be the results of calling + * the provided callback function for each of the childs of the original node. + * @param {function(child: Node, path: string, parent: Node): Node} callback + * @returns {ConditionalNode} Returns a transformed copy of the node + */ + + + ConditionalNode.prototype.map = function (callback) { + return new ConditionalNode(this._ifNode(callback(this.condition, 'condition', this)), this._ifNode(callback(this.trueExpr, 'trueExpr', this)), this._ifNode(callback(this.falseExpr, 'falseExpr', this))); + }; + /** + * Create a clone of this node, a shallow copy + * @return {ConditionalNode} + */ + + + ConditionalNode.prototype.clone = function () { + return new ConditionalNode(this.condition, this.trueExpr, this.falseExpr); + }; + /** + * Get string representation + * @param {Object} options + * @return {string} str + */ + + + ConditionalNode.prototype._toString = function (options) { + var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep'; + var precedence = operators.getPrecedence(this, parenthesis); // Enclose Arguments in parentheses if they are an OperatorNode + // or have lower or equal precedence + // NOTE: enclosing all OperatorNodes in parentheses is a decision + // purely based on aesthetics and readability + + var condition = this.condition.toString(options); + var conditionPrecedence = operators.getPrecedence(this.condition, parenthesis); + + if (parenthesis === 'all' || this.condition.type === 'OperatorNode' || conditionPrecedence !== null && conditionPrecedence <= precedence) { + condition = '(' + condition + ')'; + } + + var trueExpr = this.trueExpr.toString(options); + var truePrecedence = operators.getPrecedence(this.trueExpr, parenthesis); + + if (parenthesis === 'all' || this.trueExpr.type === 'OperatorNode' || truePrecedence !== null && truePrecedence <= precedence) { + trueExpr = '(' + trueExpr + ')'; + } + + var falseExpr = this.falseExpr.toString(options); + var falsePrecedence = operators.getPrecedence(this.falseExpr, parenthesis); + + if (parenthesis === 'all' || this.falseExpr.type === 'OperatorNode' || falsePrecedence !== null && falsePrecedence <= precedence) { + falseExpr = '(' + falseExpr + ')'; + } + + return condition + ' ? ' + trueExpr + ' : ' + falseExpr; + }; + /** + * Get a JSON representation of the node + * @returns {Object} + */ + + + ConditionalNode.prototype.toJSON = function () { + return { + mathjs: 'ConditionalNode', + condition: this.condition, + trueExpr: this.trueExpr, + falseExpr: this.falseExpr + }; + }; + /** + * Instantiate an ConditionalNode from its JSON representation + * @param {Object} json An object structured like + * `{"mathjs": "ConditionalNode", "condition": ..., "trueExpr": ..., "falseExpr": ...}`, + * where mathjs is optional + * @returns {ConditionalNode} + */ + + + ConditionalNode.fromJSON = function (json) { + return new ConditionalNode(json.condition, json.trueExpr, json.falseExpr); + }; + /** + * Get HTML representation + * @param {Object} options + * @return {string} str + */ + + + ConditionalNode.prototype.toHTML = function (options) { + var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep'; + var precedence = operators.getPrecedence(this, parenthesis); // Enclose Arguments in parentheses if they are an OperatorNode + // or have lower or equal precedence + // NOTE: enclosing all OperatorNodes in parentheses is a decision + // purely based on aesthetics and readability + + var condition = this.condition.toHTML(options); + var conditionPrecedence = operators.getPrecedence(this.condition, parenthesis); + + if (parenthesis === 'all' || this.condition.type === 'OperatorNode' || conditionPrecedence !== null && conditionPrecedence <= precedence) { + condition = '<span class="math-parenthesis math-round-parenthesis">(</span>' + condition + '<span class="math-parenthesis math-round-parenthesis">)</span>'; + } + + var trueExpr = this.trueExpr.toHTML(options); + var truePrecedence = operators.getPrecedence(this.trueExpr, parenthesis); + + if (parenthesis === 'all' || this.trueExpr.type === 'OperatorNode' || truePrecedence !== null && truePrecedence <= precedence) { + trueExpr = '<span class="math-parenthesis math-round-parenthesis">(</span>' + trueExpr + '<span class="math-parenthesis math-round-parenthesis">)</span>'; + } + + var falseExpr = this.falseExpr.toHTML(options); + var falsePrecedence = operators.getPrecedence(this.falseExpr, parenthesis); + + if (parenthesis === 'all' || this.falseExpr.type === 'OperatorNode' || falsePrecedence !== null && falsePrecedence <= precedence) { + falseExpr = '<span class="math-parenthesis math-round-parenthesis">(</span>' + falseExpr + '<span class="math-parenthesis math-round-parenthesis">)</span>'; + } + + return condition + '<span class="math-operator math-conditional-operator">?</span>' + trueExpr + '<span class="math-operator math-conditional-operator">:</span>' + falseExpr; + }; + /** + * Get LaTeX representation + * @param {Object} options + * @return {string} str + */ + + + ConditionalNode.prototype._toTex = function (options) { + return '\\begin{cases} {' + this.trueExpr.toTex(options) + '}, &\\quad{\\text{if }\\;' + this.condition.toTex(options) + '}\\\\{' + this.falseExpr.toTex(options) + '}, &\\quad{\\text{otherwise}}\\end{cases}'; + }; + /** + * Test whether a condition is met + * @param {*} condition + * @returns {boolean} true if condition is true or non-zero, else false + */ + + + function testCondition(condition) { + if (typeof condition === 'number' || typeof condition === 'boolean' || typeof condition === 'string') { + return !!condition; + } + + if (condition) { + if (type.isBigNumber(condition)) { + return !condition.isZero(); + } + + if (type.isComplex(condition)) { + return !!(condition.re || condition.im); + } + + if (type.isUnit(condition)) { + return !!condition.value; + } + } + + if (condition === null || condition === undefined) { + return false; + } + + throw new TypeError('Unsupported type of condition "' + mathTypeOf(condition) + '"'); + } + + return ConditionalNode; +} + +exports.name = 'ConditionalNode'; +exports.path = 'expression.node'; +exports.factory = factory; +},{"../../function/utils/typeof":38,"../operators":33,"./Node":24}],20:[function(require,module,exports){ +'use strict'; + +var format = require('../../utils/string').format; + +var escapeLatex = require('../../utils/latex').escape; + +function factory(type, config, load, typed) { + var Node = load(require('./Node')); + var getType = load(require('../../function/utils/typeof')); + /** + * A ConstantNode holds a constant value like a number or string. + * + * Usage: + * + * new ConstantNode(2.3) + * new ConstantNode('hello') + * + * @param {*} value Value can be any type (number, BigNumber, string, ...) + * @constructor ConstantNode + * @extends {Node} + */ + + function ConstantNode(value) { + if (!(this instanceof ConstantNode)) { + throw new SyntaxError('Constructor must be called with the new operator'); + } + + if (arguments.length === 2) { + // TODO: remove deprecation error some day (created 2018-01-23) + throw new SyntaxError('new ConstantNode(valueStr, valueType) is not supported anymore since math v4.0.0. Use new ConstantNode(value) instead, where value is a non-stringified value.'); + } + + this.value = value; + } + + ConstantNode.prototype = new Node(); + ConstantNode.prototype.type = 'ConstantNode'; + ConstantNode.prototype.isConstantNode = 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: *) + */ + + ConstantNode.prototype._compile = function (math, argNames) { + var value = this.value; + return function evalConstantNode() { + return value; + }; + }; + /** + * Execute a callback for each of the child nodes of this node + * @param {function(child: Node, path: string, parent: Node)} callback + */ + + + ConstantNode.prototype.forEach = function (callback) {} // nothing to do, we don't have childs + + /** + * Create a new ConstantNode having it's childs be the results of calling + * the provided callback function for each of the childs of the original node. + * @param {function(child: Node, path: string, parent: Node) : Node} callback + * @returns {ConstantNode} Returns a clone of the node + */ + ; + + ConstantNode.prototype.map = function (callback) { + return this.clone(); + }; + /** + * Create a clone of this node, a shallow copy + * @return {ConstantNode} + */ + + + ConstantNode.prototype.clone = function () { + return new ConstantNode(this.value); + }; + /** + * Get string representation + * @param {Object} options + * @return {string} str + */ + + + ConstantNode.prototype._toString = function (options) { + return format(this.value, options); + }; + /** + * Get HTML representation + * @param {Object} options + * @return {string} str + */ + + + ConstantNode.prototype.toHTML = function (options) { + var value = this._toString(options); + + switch (getType(this.value)) { + case 'number': + case 'BigNumber': + case 'Fraction': + return '<span class="math-number">' + value + '</span>'; + + case 'string': + return '<span class="math-string">' + value + '</span>'; + + case 'boolean': + return '<span class="math-boolean">' + value + '</span>'; + + case 'null': + return '<span class="math-null-symbol">' + value + '</span>'; + + case 'undefined': + return '<span class="math-undefined">' + value + '</span>'; + + default: + return '<span class="math-symbol">' + value + '</span>'; + } + }; + /** + * Get a JSON representation of the node + * @returns {Object} + */ + + + ConstantNode.prototype.toJSON = function () { + return { + mathjs: 'ConstantNode', + value: this.value + }; + }; + /** + * Instantiate a ConstantNode from its JSON representation + * @param {Object} json An object structured like + * `{"mathjs": "SymbolNode", value: 2.3}`, + * where mathjs is optional + * @returns {ConstantNode} + */ + + + ConstantNode.fromJSON = function (json) { + return new ConstantNode(json.value); + }; + /** + * Get LaTeX representation + * @param {Object} options + * @return {string} str + */ + + + ConstantNode.prototype._toTex = function (options) { + var value = this._toString(options); + + switch (getType(this.value)) { + case 'string': + return '\\mathtt{' + escapeLatex(value) + '}'; + + case 'number': + case 'BigNumber': + var index = value.toLowerCase().indexOf('e'); + + if (index !== -1) { + return value.substring(0, index) + '\\cdot10^{' + value.substring(index + 1) + '}'; + } + + return value; + + case 'Fraction': + return this.value.toLatex(); + + default: + return value; + } + }; + + return ConstantNode; +} + +exports.name = 'ConstantNode'; +exports.path = 'expression.node'; +exports.factory = factory; +},{"../../function/utils/typeof":38,"../../utils/latex":53,"../../utils/string":57,"./Node":24}],21:[function(require,module,exports){ +'use strict'; + +var keywords = require('../keywords'); + +var escape = require('../../utils/string').escape; + +var forEach = require('../../utils/array').forEach; + +var join = require('../../utils/array').join; + +var latex = require('../../utils/latex'); + +var operators = require('../operators'); + +var setSafeProperty = require('../../utils/customs').setSafeProperty; + +function factory(type, config, load, typed) { + var Node = load(require('./Node')); + /** + * @constructor FunctionAssignmentNode + * @extends {Node} + * Function assignment + * + * @param {string} name Function name + * @param {string[] | Array.<{name: string, type: string}>} params + * Array with function parameter names, or an + * array with objects containing the name + * and type of the parameter + * @param {Node} expr The function expression + */ + + function FunctionAssignmentNode(name, params, expr) { + if (!(this instanceof FunctionAssignmentNode)) { + throw new SyntaxError('Constructor must be called with the new operator'); + } // validate input + + + if (typeof name !== 'string') throw new TypeError('String expected for parameter "name"'); + if (!Array.isArray(params)) throw new TypeError('Array containing strings or objects expected for parameter "params"'); + if (!type.isNode(expr)) throw new TypeError('Node expected for parameter "expr"'); + if (name in keywords) throw new Error('Illegal function name, "' + name + '" is a reserved keyword'); + this.name = name; + this.params = params.map(function (param) { + return param && param.name || param; + }); + this.types = params.map(function (param) { + return param && param.type || 'any'; + }); + this.expr = expr; + } + + FunctionAssignmentNode.prototype = new Node(); + FunctionAssignmentNode.prototype.type = 'FunctionAssignmentNode'; + FunctionAssignmentNode.prototype.isFunctionAssignmentNode = 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: *) + */ + + FunctionAssignmentNode.prototype._compile = function (math, argNames) { + var childArgNames = Object.create(argNames); + forEach(this.params, function (param) { + childArgNames[param] = true; + }); // compile the function expression with the child args + + var evalExpr = this.expr._compile(math, childArgNames); + + var name = this.name; + var params = this.params; + var signature = join(this.types, ','); + var syntax = name + '(' + join(this.params, ', ') + ')'; + return function evalFunctionAssignmentNode(scope, args, context) { + var signatures = {}; + + signatures[signature] = function () { + var childArgs = Object.create(args); + + for (var i = 0; i < params.length; i++) { + childArgs[params[i]] = arguments[i]; + } + + return evalExpr(scope, childArgs, context); + }; + + var fn = typed(name, signatures); + fn.syntax = syntax; + setSafeProperty(scope, name, fn); + return fn; + }; + }; + /** + * Execute a callback for each of the child nodes of this node + * @param {function(child: Node, path: string, parent: Node)} callback + */ + + + FunctionAssignmentNode.prototype.forEach = function (callback) { + callback(this.expr, 'expr', this); + }; + /** + * Create a new FunctionAssignmentNode having it's childs be the results of calling + * the provided callback function for each of the childs of the original node. + * @param {function(child: Node, path: string, parent: Node): Node} callback + * @returns {FunctionAssignmentNode} Returns a transformed copy of the node + */ + + + FunctionAssignmentNode.prototype.map = function (callback) { + var expr = this._ifNode(callback(this.expr, 'expr', this)); + + return new FunctionAssignmentNode(this.name, this.params.slice(0), expr); + }; + /** + * Create a clone of this node, a shallow copy + * @return {FunctionAssignmentNode} + */ + + + FunctionAssignmentNode.prototype.clone = function () { + return new FunctionAssignmentNode(this.name, this.params.slice(0), this.expr); + }; + /** + * Is parenthesis needed? + * @param {Node} node + * @param {Object} parenthesis + * @private + */ + + + function needParenthesis(node, parenthesis) { + var precedence = operators.getPrecedence(node, parenthesis); + var exprPrecedence = operators.getPrecedence(node.expr, parenthesis); + return parenthesis === 'all' || exprPrecedence !== null && exprPrecedence <= precedence; + } + /** + * get string representation + * @param {Object} options + * @return {string} str + */ + + + FunctionAssignmentNode.prototype._toString = function (options) { + var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep'; + var expr = this.expr.toString(options); + + if (needParenthesis(this, parenthesis)) { + expr = '(' + expr + ')'; + } + + return this.name + '(' + this.params.join(', ') + ') = ' + expr; + }; + /** + * Get a JSON representation of the node + * @returns {Object} + */ + + + FunctionAssignmentNode.prototype.toJSON = function () { + var types = this.types; + return { + mathjs: 'FunctionAssignmentNode', + name: this.name, + params: this.params.map(function (param, index) { + return { + name: param, + type: types[index] + }; + }), + expr: this.expr + }; + }; + /** + * Instantiate an FunctionAssignmentNode from its JSON representation + * @param {Object} json An object structured like + * `{"mathjs": "FunctionAssignmentNode", name: ..., params: ..., expr: ...}`, + * where mathjs is optional + * @returns {FunctionAssignmentNode} + */ + + + FunctionAssignmentNode.fromJSON = function (json) { + return new FunctionAssignmentNode(json.name, json.params, json.expr); + }; + /** + * get HTML representation + * @param {Object} options + * @return {string} str + */ + + + FunctionAssignmentNode.prototype.toHTML = function (options) { + var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep'; + var params = []; + + for (var i = 0; i < this.params.length; i++) { + params.push('<span class="math-symbol math-parameter">' + escape(this.params[i]) + '</span>'); + } + + var expr = this.expr.toHTML(options); + + if (needParenthesis(this, parenthesis)) { + expr = '<span class="math-parenthesis math-round-parenthesis">(</span>' + expr + '<span class="math-parenthesis math-round-parenthesis">)</span>'; + } + + return '<span class="math-function">' + escape(this.name) + '</span>' + '<span class="math-parenthesis math-round-parenthesis">(</span>' + params.join('<span class="math-separator">,</span>') + '<span class="math-parenthesis math-round-parenthesis">)</span><span class="math-operator math-assignment-operator math-variable-assignment-operator math-binary-operator">=</span>' + expr; + }; + /** + * get LaTeX representation + * @param {Object} options + * @return {string} str + */ + + + FunctionAssignmentNode.prototype._toTex = function (options) { + var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep'; + var expr = this.expr.toTex(options); + + if (needParenthesis(this, parenthesis)) { + expr = "\\left(".concat(expr, "\\right)"); + } + + return '\\mathrm{' + this.name + '}\\left(' + this.params.map(latex.toSymbol).join(',') + '\\right):=' + expr; + }; + + return FunctionAssignmentNode; +} + +exports.name = 'FunctionAssignmentNode'; +exports.path = 'expression.node'; +exports.factory = factory; +},{"../../utils/array":46,"../../utils/customs":51,"../../utils/latex":53,"../../utils/string":57,"../keywords":14,"../operators":33,"./Node":24}],22:[function(require,module,exports){ +'use strict'; + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); } + +var latex = require('../../utils/latex'); + +var escape = require('../../utils/string').escape; + +var hasOwnProperty = require('../../utils/object').hasOwnProperty; + +var map = require('../../utils/array').map; + +var validateSafeMethod = require('../../utils/customs').validateSafeMethod; + +var getSafeProperty = require('../../utils/customs').getSafeProperty; + +function factory(type, config, load, typed, math) { + var Node = load(require('./Node')); + var SymbolNode = load(require('./SymbolNode')); + /** + * @constructor FunctionNode + * @extends {./Node} + * invoke a list with arguments on a node + * @param {./Node | string} fn Node resolving with a function on which to invoke + * the arguments, typically a SymboNode or AccessorNode + * @param {./Node[]} args + */ + + function FunctionNode(fn, args) { + if (!(this instanceof FunctionNode)) { + throw new SyntaxError('Constructor must be called with the new operator'); + } + + if (typeof fn === 'string') { + fn = new SymbolNode(fn); + } // validate input + + + if (!type.isNode(fn)) throw new TypeError('Node expected as parameter "fn"'); + + if (!Array.isArray(args) || !args.every(type.isNode)) { + throw new TypeError('Array containing Nodes expected for parameter "args"'); + } + + this.fn = fn; + this.args = args || []; // readonly property name + + Object.defineProperty(this, 'name', { + get: function () { + return this.fn.name || ''; + }.bind(this), + set: function set() { + throw new Error('Cannot assign a new name, name is read-only'); + } + }); // TODO: deprecated since v3, remove some day + + var deprecated = function deprecated() { + throw new Error('Property `FunctionNode.object` is deprecated, use `FunctionNode.fn` instead'); + }; + + Object.defineProperty(this, 'object', { + get: deprecated, + set: deprecated + }); + } + + FunctionNode.prototype = new Node(); + FunctionNode.prototype.type = 'FunctionNode'; + FunctionNode.prototype.isFunctionNode = 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: *) + */ + + FunctionNode.prototype._compile = function (math, argNames) { + if (!(this instanceof FunctionNode)) { + throw new TypeError('No valid FunctionNode'); + } // compile arguments + + + var evalArgs = map(this.args, function (arg) { + return arg._compile(math, argNames); + }); + + if (type.isSymbolNode(this.fn)) { + // we can statically determine whether the function has an rawArgs property + var name = this.fn.name; + var fn = name in math ? getSafeProperty(math, name) : undefined; + var isRaw = typeof fn === 'function' && fn.rawArgs === true; + + if (isRaw) { + // pass unevaluated parameters (nodes) to the function + // "raw" evaluation + var rawArgs = this.args; + return function evalFunctionNode(scope, args, context) { + return (name in scope ? getSafeProperty(scope, name) : fn)(rawArgs, math, _extends({}, scope, args)); + }; + } else { + // "regular" evaluation + if (evalArgs.length === 1) { + var evalArg0 = evalArgs[0]; + return function evalFunctionNode(scope, args, context) { + return (name in scope ? getSafeProperty(scope, name) : fn)(evalArg0(scope, args, context)); + }; + } else if (evalArgs.length === 2) { + var _evalArg = evalArgs[0]; + var evalArg1 = evalArgs[1]; + return function evalFunctionNode(scope, args, context) { + return (name in scope ? getSafeProperty(scope, name) : fn)(_evalArg(scope, args, context), evalArg1(scope, args, context)); + }; + } else { + return function evalFunctionNode(scope, args, context) { + return (name in scope ? getSafeProperty(scope, name) : fn).apply(null, map(evalArgs, function (evalArg) { + return evalArg(scope, args, context); + })); + }; + } + } + } else if (type.isAccessorNode(this.fn) && type.isIndexNode(this.fn.index) && this.fn.index.isObjectProperty()) { + // execute the function with the right context: the object of the AccessorNode + var evalObject = this.fn.object._compile(math, argNames); + + var prop = this.fn.index.getObjectProperty(); + var _rawArgs = this.args; + return function evalFunctionNode(scope, args, context) { + var object = evalObject(scope, args, context); + validateSafeMethod(object, prop); + var isRaw = object[prop] && object[prop].rawArgs; + return isRaw ? object[prop](_rawArgs, math, _extends({}, scope, args)) // "raw" evaluation + : object[prop].apply(object, map(evalArgs, function (evalArg) { + // "regular" evaluation + return evalArg(scope, args, context); + })); + }; + } else { + // node.fn.isAccessorNode && !node.fn.index.isObjectProperty() + // we have to dynamically determine whether the function has a rawArgs property + var evalFn = this.fn._compile(math, argNames); + + var _rawArgs2 = this.args; + return function evalFunctionNode(scope, args, context) { + var fn = evalFn(scope, args, context); + var isRaw = fn && fn.rawArgs; + return isRaw ? fn(_rawArgs2, math, _extends({}, scope, args)) // "raw" evaluation + : fn.apply(fn, map(evalArgs, function (evalArg) { + // "regular" evaluation + return evalArg(scope, args, context); + })); + }; + } + }; + /** + * Execute a callback for each of the child nodes of this node + * @param {function(child: Node, path: string, parent: Node)} callback + */ + + + FunctionNode.prototype.forEach = function (callback) { + for (var i = 0; i < this.args.length; i++) { + callback(this.args[i], 'args[' + i + ']', this); + } + }; + /** + * Create a new FunctionNode having it's childs be the results of calling + * the provided callback function for each of the childs of the original node. + * @param {function(child: Node, path: string, parent: Node): Node} callback + * @returns {FunctionNode} Returns a transformed copy of the node + */ + + + FunctionNode.prototype.map = function (callback) { + var fn = this.fn.map(callback); + var args = []; + + for (var i = 0; i < this.args.length; i++) { + args[i] = this._ifNode(callback(this.args[i], 'args[' + i + ']', this)); + } + + return new FunctionNode(fn, args); + }; + /** + * Create a clone of this node, a shallow copy + * @return {FunctionNode} + */ + + + FunctionNode.prototype.clone = function () { + return new FunctionNode(this.fn, this.args.slice(0)); + }; // backup Node's toString function + // @private + + + var nodeToString = FunctionNode.prototype.toString; + /** + * Get string representation. (wrapper function) + * This overrides parts of Node's toString function. + * If callback is an object containing callbacks, it + * calls the correct callback for the current node, + * otherwise it falls back to calling Node's toString + * function. + * + * @param {Object} options + * @return {string} str + * @override + */ + + FunctionNode.prototype.toString = function (options) { + var customString; + var name = this.fn.toString(options); + + if (options && _typeof(options.handler) === 'object' && hasOwnProperty(options.handler, name)) { + // callback is a map of callback functions + customString = options.handler[name](this, options); + } + + if (typeof customString !== 'undefined') { + return customString; + } // fall back to Node's toString + + + return nodeToString.call(this, options); + }; + /** + * Get string representation + * @param {Object} options + * @return {string} str + */ + + + FunctionNode.prototype._toString = function (options) { + var args = this.args.map(function (arg) { + return arg.toString(options); + }); + var fn = type.isFunctionAssignmentNode(this.fn) ? '(' + this.fn.toString(options) + ')' : this.fn.toString(options); // format the arguments like "add(2, 4.2)" + + return fn + '(' + args.join(', ') + ')'; + }; + /** + * Get a JSON representation of the node + * @returns {Object} + */ + + + FunctionNode.prototype.toJSON = function () { + return { + mathjs: 'FunctionNode', + fn: this.fn, + args: this.args + }; + }; + /** + * Instantiate an AssignmentNode from its JSON representation + * @param {Object} json An object structured like + * `{"mathjs": "FunctionNode", fn: ..., args: ...}`, + * where mathjs is optional + * @returns {FunctionNode} + */ + + + FunctionNode.fromJSON = function (json) { + return new FunctionNode(json.fn, json.args); + }; + /** + * Get HTML representation + * @param {Object} options + * @return {string} str + */ + + + FunctionNode.prototype.toHTML = function (options) { + var args = this.args.map(function (arg) { + return arg.toHTML(options); + }); // format the arguments like "add(2, 4.2)" + + return '<span class="math-function">' + escape(this.fn) + '</span><span class="math-paranthesis math-round-parenthesis">(</span>' + args.join('<span class="math-separator">,</span>') + '<span class="math-paranthesis math-round-parenthesis">)</span>'; + }; + /* + * Expand a LaTeX template + * + * @param {string} template + * @param {Node} node + * @param {Object} options + * @private + **/ + + + function expandTemplate(template, node, options) { + var latex = ''; // Match everything of the form ${identifier} or ${identifier[2]} or $$ + // while submatching identifier and 2 (in the second case) + + var regex = new RegExp('\\$(?:\\{([a-z_][a-z_0-9]*)(?:\\[([0-9]+)\\])?\\}|\\$)', 'ig'); + var inputPos = 0; // position in the input string + + var match; + + while ((match = regex.exec(template)) !== null) { + // go through all matches + // add everything in front of the match to the LaTeX string + latex += template.substring(inputPos, match.index); + inputPos = match.index; + + if (match[0] === '$$') { + // escaped dollar sign + latex += '$'; + inputPos++; + } else { + // template parameter + inputPos += match[0].length; + var property = node[match[1]]; + + if (!property) { + throw new ReferenceError('Template: Property ' + match[1] + ' does not exist.'); + } + + if (match[2] === undefined) { + // no square brackets + switch (_typeof(property)) { + case 'string': + latex += property; + break; + + case 'object': + if (type.isNode(property)) { + latex += property.toTex(options); + } else if (Array.isArray(property)) { + // make array of Nodes into comma separated list + latex += property.map(function (arg, index) { + if (type.isNode(arg)) { + return arg.toTex(options); + } + + throw new TypeError('Template: ' + match[1] + '[' + index + '] is not a Node.'); + }).join(','); + } else { + throw new TypeError('Template: ' + match[1] + ' has to be a Node, String or array of Nodes'); + } + + break; + + default: + throw new TypeError('Template: ' + match[1] + ' has to be a Node, String or array of Nodes'); + } + } else { + // with square brackets + if (type.isNode(property[match[2]] && property[match[2]])) { + latex += property[match[2]].toTex(options); + } else { + throw new TypeError('Template: ' + match[1] + '[' + match[2] + '] is not a Node.'); + } + } + } + } + + latex += template.slice(inputPos); // append rest of the template + + return latex; + } // backup Node's toTex function + // @private + + + var nodeToTex = FunctionNode.prototype.toTex; + /** + * Get LaTeX representation. (wrapper function) + * This overrides parts of Node's toTex function. + * If callback is an object containing callbacks, it + * calls the correct callback for the current node, + * otherwise it falls back to calling Node's toTex + * function. + * + * @param {Object} options + * @return {string} + */ + + FunctionNode.prototype.toTex = function (options) { + var customTex; + + if (options && _typeof(options.handler) === 'object' && hasOwnProperty(options.handler, this.name)) { + // callback is a map of callback functions + customTex = options.handler[this.name](this, options); + } + + if (typeof customTex !== 'undefined') { + return customTex; + } // fall back to Node's toTex + + + return nodeToTex.call(this, options); + }; + /** + * Get LaTeX representation + * @param {Object} options + * @return {string} str + */ + + + FunctionNode.prototype._toTex = function (options) { + var args = this.args.map(function (arg) { + // get LaTeX of the arguments + return arg.toTex(options); + }); + var latexConverter; + + if (math[this.name] && (typeof math[this.name].toTex === 'function' || _typeof(math[this.name].toTex) === 'object' || typeof math[this.name].toTex === 'string')) { + // .toTex is a callback function + latexConverter = math[this.name].toTex; + } + + var customToTex; + + switch (_typeof(latexConverter)) { + case 'function': + // a callback function + customToTex = latexConverter(this, options); + break; + + case 'string': + // a template string + customToTex = expandTemplate(latexConverter, this, options); + break; + + case 'object': + // an object with different "converters" for different numbers of arguments + switch (_typeof(latexConverter[args.length])) { + case 'function': + customToTex = latexConverter[args.length](this, options); + break; + + case 'string': + customToTex = expandTemplate(latexConverter[args.length], this, options); + break; + } + + } + + if (typeof customToTex !== 'undefined') { + return customToTex; + } + + return expandTemplate(latex.defaultTemplate, this, options); + }; + /** + * Get identifier. + * @return {string} + */ + + + FunctionNode.prototype.getIdentifier = function () { + return this.type + ':' + this.name; + }; + + return FunctionNode; +} + +exports.name = 'FunctionNode'; +exports.path = 'expression.node'; +exports.math = true; // request access to the math namespace as 5th argument of the factory function + +exports.factory = factory; +},{"../../utils/array":46,"../../utils/customs":51,"../../utils/latex":53,"../../utils/object":55,"../../utils/string":57,"./Node":24,"./SymbolNode":30}],23:[function(require,module,exports){ +'use strict'; + +var map = require('../../utils/array').map; + +var escape = require('../../utils/string').escape; + +function factory(type, config, load, typed) { + var Node = load(require('./Node')); + var Range = load(require('../../type/matrix/Range')); + var isArray = Array.isArray; + /** + * @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"]` (default). + * Used to stringify an IndexNode. + */ + + function IndexNode(dimensions, dotNotation) { + if (!(this instanceof IndexNode)) { + throw new SyntaxError('Constructor must be called with the new operator'); + } + + this.dimensions = dimensions; + this.dotNotation = dotNotation || false; // validate input + + if (!isArray(dimensions) || !dimensions.every(type.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'); + } // TODO: deprecated since v3, remove some day + + + var deprecated = function deprecated() { + throw new Error('Property `IndexNode.object` is deprecated, use `IndexNode.fn` instead'); + }; + + Object.defineProperty(this, 'object', { + get: deprecated, + set: deprecated + }); + } + + IndexNode.prototype = new Node(); + IndexNode.prototype.type = 'IndexNode'; + IndexNode.prototype.isIndexNode = 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: *) + */ + + IndexNode.prototype._compile = function (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 = map(this.dimensions, function (range, i) { + if (type.isRangeNode(range)) { + if (range.needsEnd()) { + // create a range containing end (like '4:end') + var childArgNames = Object.create(argNames); + childArgNames['end'] = true; + + var evalStart = range.start._compile(math, childArgNames); + + var evalEnd = range.end._compile(math, childArgNames); + + var evalStep = range.step ? range.step._compile(math, childArgNames) : function () { + return 1; + }; + return function evalDimension(scope, args, context) { + var size = math.size(context).valueOf(); + var childArgs = Object.create(args); + childArgs['end'] = size[i]; + return createRange(evalStart(scope, childArgs, context), evalEnd(scope, childArgs, context), evalStep(scope, childArgs, context)); + }; + } else { + // create range + var _evalStart = range.start._compile(math, argNames); + + var _evalEnd = range.end._compile(math, argNames); + + var _evalStep = range.step ? range.step._compile(math, argNames) : function () { + return 1; + }; + + return function evalDimension(scope, args, context) { + return createRange(_evalStart(scope, args, context), _evalEnd(scope, args, context), _evalStep(scope, args, context)); + }; + } + } else if (type.isSymbolNode(range) && range.name === 'end') { + // SymbolNode 'end' + var _childArgNames = Object.create(argNames); + + _childArgNames['end'] = true; + + var evalRange = range._compile(math, _childArgNames); + + return function evalDimension(scope, args, context) { + var size = math.size(context).valueOf(); + var childArgs = Object.create(args); + childArgs['end'] = size[i]; + return evalRange(scope, childArgs, context); + }; + } else { + // ConstantNode + var _evalRange = range._compile(math, argNames); + + return function evalDimension(scope, args, context) { + return _evalRange(scope, args, context); + }; + } + }); + return function evalIndexNode(scope, args, context) { + var dimensions = map(evalDimensions, function (evalDimension) { + return evalDimension(scope, args, context); + }); + return math.index.apply(math, dimensions); + }; + }; + /** + * Execute a callback for each of the child nodes of this node + * @param {function(child: Node, path: string, parent: Node)} callback + */ + + + IndexNode.prototype.forEach = function (callback) { + for (var i = 0; i < this.dimensions.length; i++) { + callback(this.dimensions[i], 'dimensions[' + i + ']', this); + } + }; + /** + * Create a new IndexNode having it's childs be the results of calling + * the provided callback function for each of the childs of the original node. + * @param {function(child: Node, path: string, parent: Node): Node} callback + * @returns {IndexNode} Returns a transformed copy of the node + */ + + + IndexNode.prototype.map = function (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); + }; + /** + * Create a clone of this node, a shallow copy + * @return {IndexNode} + */ + + + IndexNode.prototype.clone = function () { + return new IndexNode(this.dimensions.slice(0)); + }; + /** + * Test whether this IndexNode contains a single property name + * @return {boolean} + */ + + + IndexNode.prototype.isObjectProperty = function () { + return this.dimensions.length === 1 && type.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} + */ + + + IndexNode.prototype.getObjectProperty = function () { + return this.isObjectProperty() ? this.dimensions[0].value : null; + }; + /** + * Get string representation + * @param {Object} options + * @return {string} str + */ + + + IndexNode.prototype._toString = function (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} + */ + + + IndexNode.prototype.toJSON = function () { + return { + mathjs: 'IndexNode', + 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} + */ + + + IndexNode.fromJSON = function (json) { + return new IndexNode(json.dimensions, json.dotNotation); + }; + /** + * Get HTML representation + * @param {Object} options + * @return {string} str + */ + + + IndexNode.prototype.toHTML = function (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">' + 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 + */ + + + IndexNode.prototype._toTex = function (options) { + var dimensions = this.dimensions.map(function (range) { + return range.toTex(options); + }); + return this.dotNotation ? '.' + this.getObjectProperty() + '' : '_{' + dimensions.join(',') + '}'; + }; // helper function to create a Range from start, step and end + + + function createRange(start, end, step) { + return new Range(type.isBigNumber(start) ? start.toNumber() : start, type.isBigNumber(end) ? end.toNumber() : end, type.isBigNumber(step) ? step.toNumber() : step); + } + + return IndexNode; +} + +exports.name = 'IndexNode'; +exports.path = 'expression.node'; +exports.factory = factory; +},{"../../type/matrix/Range":41,"../../utils/array":46,"../../utils/string":57,"./Node":24}],24:[function(require,module,exports){ +'use strict'; + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +var keywords = require('../keywords'); + +var deepEqual = require('../../utils/object').deepEqual; + +var hasOwnProperty = require('../../utils/object').hasOwnProperty; + +function factory(type, config, load, typed, math) { + /** + * Node + */ + function Node() { + if (!(this instanceof Node)) { + throw new SyntaxError('Constructor must be called with the new operator'); + } + } + /** + * Evaluate the node + * @param {Object} [scope] Scope to read/write variables + * @return {*} Returns the result + */ + + + Node.prototype.eval = function (scope) { + return this.compile().eval(scope); + }; + + Node.prototype.type = 'Node'; + Node.prototype.isNode = true; + Node.prototype.comment = ''; + /** + * Compile the node into an optimized, evauatable JavaScript function + * @return {{eval: function([Object])}} expr Returns an object with a function 'eval', + * which can be invoked as expr.eval([scope: Object]), + * where scope is an optional object with + * variables. + */ + + Node.prototype.compile = function () { + var expr = this._compile(math.expression.mathWithTransform, {}); + + var args = {}; + var context = null; + return { + eval: function evalNode(scope) { + var s = scope || {}; + + _validateScope(s); + + return expr(s, args, context); + } + }; + }; + /** + * 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: *) + */ + + + Node.prototype._compile = function (math, argNames) { + throw new Error('Method _compile should 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 + */ + + + Node.prototype.forEach = function (callback) { + // must be implemented by each of the Node implementations + throw new Error('Cannot run forEach on a Node interface'); + }; + /** + * Create a new Node having it's childs be the results of calling + * the provided callback function for each of the childs of the original node. + * @param {function(child: Node, path: string, parent: Node): Node} callback + * @returns {OperatorNode} Returns a transformed copy of the node + */ + + + Node.prototype.map = function (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 + */ + + + Node.prototype._ifNode = function (node) { + if (!type.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. + */ + + + Node.prototype.traverse = function (callback) { + // execute callback for itself + callback(this, null, null); // eslint-disable-line standard/no-callback-literal + // recursively traverse over all childs 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. + * Signature: callback(node: Node, index: string, parent: Node) : Node + * @return {Node} Returns the original node or its replacement + */ + + + Node.prototype.transform = function (callback) { + // traverse over all childs + function _transform(node, callback) { + return node.map(function (child, path, parent) { + var replacement = callback(child, path, parent); + return _transform(replacement, callback); + }); + } + + var replacement = callback(this, null, null); // eslint-disable-line standard/no-callback-literal + + return _transform(replacement, callback); + }; + /** + * 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 + */ + + + Node.prototype.filter = function (callback) { + var nodes = []; + this.traverse(function (node, path, parent) { + if (callback(node, path, parent)) { + nodes.push(node); + } + }); + return nodes; + }; // TODO: deprecated since version 1.1.0, remove this some day + + + Node.prototype.find = function () { + throw new Error('Function Node.find is deprecated. Use Node.filter instead.'); + }; // TODO: deprecated since version 1.1.0, remove this some day + + + Node.prototype.match = function () { + throw new Error('Function Node.match is deprecated. See functions Node.filter, Node.transform, Node.traverse.'); + }; + /** + * Create a shallow clone of this node + * @return {Node} + */ + + + Node.prototype.clone = function () { + // 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} + */ + + + Node.prototype.cloneDeep = function () { + 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) + */ + + + Node.prototype.equals = function (other) { + return other ? deepEqual(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} + */ + + + Node.prototype.toString = function (options) { + var customString; + + if (options && _typeof(options) === 'object') { + switch (_typeof(options.handler)) { + case 'object': + case 'undefined': + break; + + case 'function': + customString = options.handler(this, options); + break; + + default: + throw new TypeError('Object or function expected as callback'); + } + } + + 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} + */ + + + Node.prototype.toJSON = function () { + 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} + */ + + + Node.prototype.toHTML = function (options) { + var customString; + + if (options && _typeof(options) === 'object') { + switch (_typeof(options.handler)) { + case 'object': + case 'undefined': + break; + + case 'function': + customString = options.handler(this, options); + break; + + default: + throw new TypeError('Object or function expected as callback'); + } + } + + 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} + */ + + + Node.prototype._toString = function () { + // 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} + */ + + + Node.prototype.toTex = function (options) { + var customTex; + + if (options && _typeof(options) === 'object') { + switch (_typeof(options.handler)) { + case 'object': + case 'undefined': + break; + + case 'function': + customTex = options.handler(this, options); + break; + + default: + throw new TypeError('Object or function expected as callback'); + } + } + + if (typeof customTex !== 'undefined') { + return customTex; + } + + return this._toTex(options); + }; + /** + * Internal function to generate the LaTeX output. + * This has to be implemented by every Node + * + * @param {Object} [options] + * @throws {Error} + */ + + + Node.prototype._toTex = function (options) { + // must be implemented by each of the Node implementations + throw new Error('_toTex not implemented for ' + this.type); + }; + /** + * Get identifier. + * @return {string} + */ + + + Node.prototype.getIdentifier = function () { + return this.type; + }; + /** + * Get the content of the current Node. + * @return {Node} node + **/ + + + Node.prototype.getContent = function () { + return this; + }; + /** + * 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 symbol in scope) { + if (hasOwnProperty(scope, symbol)) { + if (symbol in keywords) { + throw new Error('Scope contains an illegal symbol, "' + symbol + '" is a reserved keyword'); + } + } + } + } + + return Node; +} + +exports.name = 'Node'; +exports.path = 'expression.node'; +exports.math = true; // request access to the math namespace as 5th argument of the factory function + +exports.factory = factory; +},{"../../utils/object":55,"../keywords":14}],25:[function(require,module,exports){ +'use strict'; + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +var stringify = require('../../utils/string').stringify; + +var escape = require('../../utils/string').escape; + +var isSafeProperty = require('../../utils/customs').isSafeProperty; + +var hasOwnProperty = require('../../utils/object').hasOwnProperty; + +function factory(type, config, load, typed) { + var Node = load(require('./Node')); + /** + * @constructor ObjectNode + * @extends {Node} + * Holds an object with keys/values + * @param {Object.<string, Node>} [properties] object with key/value pairs + */ + + function ObjectNode(properties) { + if (!(this instanceof ObjectNode)) { + throw new SyntaxError('Constructor must be called with the new operator'); + } + + this.properties = properties || {}; // validate input + + if (properties) { + if (!(_typeof(properties) === 'object') || !Object.keys(properties).every(function (key) { + return type.isNode(properties[key]); + })) { + throw new TypeError('Object containing Nodes expected'); + } + } + } + + ObjectNode.prototype = new Node(); + ObjectNode.prototype.type = 'ObjectNode'; + ObjectNode.prototype.isObjectNode = 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: *) + */ + + ObjectNode.prototype._compile = function (math, argNames) { + var evalEntries = {}; + + for (var key in this.properties) { + if (hasOwnProperty(this.properties, key)) { + // we stringify/parse the key here to resolve unicode characters, + // so you cannot create a key like {"co\\u006Estructor": null} + var stringifiedKey = stringify(key); + var parsedKey = JSON.parse(stringifiedKey); + + if (!isSafeProperty(this.properties, parsedKey)) { + throw new Error('No access to property "' + parsedKey + '"'); + } + + evalEntries[parsedKey] = this.properties[key]._compile(math, argNames); + } + } + + return function evalObjectNode(scope, args, context) { + var obj = {}; + + for (var _key in evalEntries) { + if (hasOwnProperty(evalEntries, _key)) { + obj[_key] = evalEntries[_key](scope, args, context); + } + } + + return obj; + }; + }; + /** + * Execute a callback for each of the child nodes of this node + * @param {function(child: Node, path: string, parent: Node)} callback + */ + + + ObjectNode.prototype.forEach = function (callback) { + for (var key in this.properties) { + if (this.properties.hasOwnProperty(key)) { + callback(this.properties[key], 'properties[' + stringify(key) + ']', this); + } + } + }; + /** + * Create a new ObjectNode having it's childs be the results of calling + * the provided callback function for each of the childs of the original node. + * @param {function(child: Node, path: string, parent: Node): Node} callback + * @returns {ObjectNode} Returns a transformed copy of the node + */ + + + ObjectNode.prototype.map = function (callback) { + var properties = {}; + + for (var key in this.properties) { + if (this.properties.hasOwnProperty(key)) { + properties[key] = this._ifNode(callback(this.properties[key], 'properties[' + stringify(key) + ']', this)); + } + } + + return new ObjectNode(properties); + }; + /** + * Create a clone of this node, a shallow copy + * @return {ObjectNode} + */ + + + ObjectNode.prototype.clone = function () { + var properties = {}; + + for (var key in this.properties) { + if (this.properties.hasOwnProperty(key)) { + properties[key] = this.properties[key]; + } + } + + return new ObjectNode(properties); + }; + /** + * Get string representation + * @param {Object} options + * @return {string} str + * @override + */ + + + ObjectNode.prototype._toString = function (options) { + var entries = []; + + for (var key in this.properties) { + if (this.properties.hasOwnProperty(key)) { + entries.push(stringify(key) + ': ' + this.properties[key].toString(options)); + } + } + + return '{' + entries.join(', ') + '}'; + }; + /** + * Get a JSON representation of the node + * @returns {Object} + */ + + + ObjectNode.prototype.toJSON = function () { + return { + mathjs: 'ObjectNode', + properties: this.properties + }; + }; + /** + * Instantiate an OperatorNode from its JSON representation + * @param {Object} json An object structured like + * `{"mathjs": "ObjectNode", "properties": {...}}`, + * where mathjs is optional + * @returns {ObjectNode} + */ + + + ObjectNode.fromJSON = function (json) { + return new ObjectNode(json.properties); + }; + /** + * Get HTML representation + * @param {Object} options + * @return {string} str + * @override + */ + + + ObjectNode.prototype.toHTML = function (options) { + var entries = []; + + for (var key in this.properties) { + if (this.properties.hasOwnProperty(key)) { + entries.push('<span class="math-symbol math-property">' + escape(key) + '</span>' + '<span class="math-operator math-assignment-operator math-property-assignment-operator math-binary-operator">:</span>' + this.properties[key].toHTML(options)); + } + } + + return '<span class="math-parenthesis math-curly-parenthesis">{</span>' + entries.join('<span class="math-separator">,</span>') + '<span class="math-parenthesis math-curly-parenthesis">}</span>'; + }; + /** + * Get LaTeX representation + * @param {Object} options + * @return {string} str + */ + + + ObjectNode.prototype._toTex = function (options) { + var entries = []; + + for (var key in this.properties) { + if (this.properties.hasOwnProperty(key)) { + entries.push('\\mathbf{' + key + ':} & ' + this.properties[key].toTex(options) + '\\\\'); + } + } + + return "\\left\\{\\begin{array}{ll}".concat(entries.join('\n'), "\\end{array}\\right\\}"); + }; + + return ObjectNode; +} + +exports.name = 'ObjectNode'; +exports.path = 'expression.node'; +exports.factory = factory; +},{"../../utils/customs":51,"../../utils/object":55,"../../utils/string":57,"./Node":24}],26:[function(require,module,exports){ +'use strict'; + +var latex = require('../../utils/latex'); + +var map = require('../../utils/array').map; + +var escape = require('../../utils/string').escape; + +var isSafeMethod = require('../../utils/customs').isSafeMethod; + +var getSafeProperty = require('../../utils/customs').getSafeProperty; + +var operators = require('../operators'); + +function factory(type, config, load, typed) { + var Node = load(require('./Node')); + /** + * @constructor OperatorNode + * @extends {Node} + * An operator with two arguments, like 2+3 + * + * @param {string} op Operator name, for example '+' + * @param {string} fn Function name, for example 'add' + * @param {Node[]} args Operator arguments + * @param {boolean} [implicit] Is this an implicit multiplication? + */ + + function OperatorNode(op, fn, args, implicit) { + if (!(this instanceof OperatorNode)) { + throw new SyntaxError('Constructor must be called with the new operator'); + } // validate input + + + if (typeof op !== 'string') { + throw new TypeError('string expected for parameter "op"'); + } + + if (typeof fn !== 'string') { + throw new TypeError('string expected for parameter "fn"'); + } + + if (!Array.isArray(args) || !args.every(type.isNode)) { + throw new TypeError('Array containing Nodes expected for parameter "args"'); + } + + this.implicit = implicit === true; + this.op = op; + this.fn = fn; + this.args = args || []; + } + + OperatorNode.prototype = new Node(); + OperatorNode.prototype.type = 'OperatorNode'; + OperatorNode.prototype.isOperatorNode = 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: *) + */ + + OperatorNode.prototype._compile = function (math, argNames) { + // validate fn + if (typeof this.fn !== 'string' || !isSafeMethod(math, this.fn)) { + if (!math[this.fn]) { + throw new Error('Function ' + this.fn + ' missing in provided namespace "math"'); + } else { + throw new Error('No access to function "' + this.fn + '"'); + } + } + + var fn = getSafeProperty(math, this.fn); + var evalArgs = map(this.args, function (arg) { + return arg._compile(math, argNames); + }); + + if (evalArgs.length === 1) { + var evalArg0 = evalArgs[0]; + return function evalOperatorNode(scope, args, context) { + return fn(evalArg0(scope, args, context)); + }; + } else if (evalArgs.length === 2) { + var _evalArg = evalArgs[0]; + var evalArg1 = evalArgs[1]; + return function evalOperatorNode(scope, args, context) { + return fn(_evalArg(scope, args, context), evalArg1(scope, args, context)); + }; + } else { + return function evalOperatorNode(scope, args, context) { + return fn.apply(null, map(evalArgs, function (evalArg) { + return evalArg(scope, args, context); + })); + }; + } + }; + /** + * Execute a callback for each of the child nodes of this node + * @param {function(child: Node, path: string, parent: Node)} callback + */ + + + OperatorNode.prototype.forEach = function (callback) { + for (var i = 0; i < this.args.length; i++) { + callback(this.args[i], 'args[' + i + ']', this); + } + }; + /** + * Create a new OperatorNode having it's childs be the results of calling + * the provided callback function for each of the childs of the original node. + * @param {function(child: Node, path: string, parent: Node): Node} callback + * @returns {OperatorNode} Returns a transformed copy of the node + */ + + + OperatorNode.prototype.map = function (callback) { + var args = []; + + for (var i = 0; i < this.args.length; i++) { + args[i] = this._ifNode(callback(this.args[i], 'args[' + i + ']', this)); + } + + return new OperatorNode(this.op, this.fn, args, this.implicit); + }; + /** + * Create a clone of this node, a shallow copy + * @return {OperatorNode} + */ + + + OperatorNode.prototype.clone = function () { + return new OperatorNode(this.op, this.fn, this.args.slice(0), this.implicit); + }; + /** + * Check whether this is an unary OperatorNode: + * has exactly one argument, like `-a`. + * @return {boolean} Returns true when an unary operator node, false otherwise. + */ + + + OperatorNode.prototype.isUnary = function () { + return this.args.length === 1; + }; + /** + * Check whether this is a binary OperatorNode: + * has exactly two arguments, like `a + b`. + * @return {boolean} Returns true when a binary operator node, false otherwise. + */ + + + OperatorNode.prototype.isBinary = function () { + return this.args.length === 2; + }; + /** + * Calculate which parentheses are necessary. Gets an OperatorNode + * (which is the root of the tree) and an Array of Nodes + * (this.args) and returns an array where 'true' means that an argument + * has to be enclosed in parentheses whereas 'false' means the opposite. + * + * @param {OperatorNode} root + * @param {string} parenthesis + * @param {Node[]} args + * @param {boolean} latex + * @return {boolean[]} + * @private + */ + + + function calculateNecessaryParentheses(root, parenthesis, implicit, args, latex) { + // precedence of the root OperatorNode + var precedence = operators.getPrecedence(root, parenthesis); + var associativity = operators.getAssociativity(root, parenthesis); + + if (parenthesis === 'all' || args.length > 2 && root.getIdentifier() !== 'OperatorNode:add' && root.getIdentifier() !== 'OperatorNode:multiply') { + var parens = args.map(function (arg) { + switch (arg.getContent().type) { + // Nodes that don't need extra parentheses + case 'ArrayNode': + case 'ConstantNode': + case 'SymbolNode': + case 'ParenthesisNode': + return false; + + default: + return true; + } + }); + return parens; + } + + var result; + + switch (args.length) { + case 0: + result = []; + break; + + case 1: + // unary operators + // precedence of the operand + var operandPrecedence = operators.getPrecedence(args[0], parenthesis); // handle special cases for LaTeX, where some of the parentheses aren't needed + + if (latex && operandPrecedence !== null) { + var operandIdentifier; + var rootIdentifier; + + if (parenthesis === 'keep') { + operandIdentifier = args[0].getIdentifier(); + rootIdentifier = root.getIdentifier(); + } else { + // Ignore Parenthesis Nodes when not in 'keep' mode + operandIdentifier = args[0].getContent().getIdentifier(); + rootIdentifier = root.getContent().getIdentifier(); + } + + if (operators.properties[precedence][rootIdentifier].latexLeftParens === false) { + result = [false]; + break; + } + + if (operators.properties[operandPrecedence][operandIdentifier].latexParens === false) { + result = [false]; + break; + } + } + + if (operandPrecedence === null) { + // if the operand has no defined precedence, no parens are needed + result = [false]; + break; + } + + if (operandPrecedence <= precedence) { + // if the operands precedence is lower, parens are needed + result = [true]; + break; + } // otherwise, no parens needed + + + result = [false]; + break; + + case 2: + // binary operators + var lhsParens; // left hand side needs parenthesis? + // precedence of the left hand side + + var lhsPrecedence = operators.getPrecedence(args[0], parenthesis); // is the root node associative with the left hand side + + var assocWithLhs = operators.isAssociativeWith(root, args[0], parenthesis); + + if (lhsPrecedence === null) { + // if the left hand side has no defined precedence, no parens are needed + // FunctionNode for example + lhsParens = false; + } else if (lhsPrecedence === precedence && associativity === 'right' && !assocWithLhs) { + // In case of equal precedence, if the root node is left associative + // parens are **never** necessary for the left hand side. + // If it is right associative however, parens are necessary + // if the root node isn't associative with the left hand side + lhsParens = true; + } else if (lhsPrecedence < precedence) { + lhsParens = true; + } else { + lhsParens = false; + } + + var rhsParens; // right hand side needs parenthesis? + // precedence of the right hand side + + var rhsPrecedence = operators.getPrecedence(args[1], parenthesis); // is the root node associative with the right hand side? + + var assocWithRhs = operators.isAssociativeWith(root, args[1], parenthesis); + + if (rhsPrecedence === null) { + // if the right hand side has no defined precedence, no parens are needed + // FunctionNode for example + rhsParens = false; + } else if (rhsPrecedence === precedence && associativity === 'left' && !assocWithRhs) { + // In case of equal precedence, if the root node is right associative + // parens are **never** necessary for the right hand side. + // If it is left associative however, parens are necessary + // if the root node isn't associative with the right hand side + rhsParens = true; + } else if (rhsPrecedence < precedence) { + rhsParens = true; + } else { + rhsParens = false; + } // handle special cases for LaTeX, where some of the parentheses aren't needed + + + if (latex) { + var _rootIdentifier; + + var lhsIdentifier; + var rhsIdentifier; + + if (parenthesis === 'keep') { + _rootIdentifier = root.getIdentifier(); + lhsIdentifier = root.args[0].getIdentifier(); + rhsIdentifier = root.args[1].getIdentifier(); + } else { + // Ignore ParenthesisNodes when not in 'keep' mode + _rootIdentifier = root.getContent().getIdentifier(); + lhsIdentifier = root.args[0].getContent().getIdentifier(); + rhsIdentifier = root.args[1].getContent().getIdentifier(); + } + + if (lhsPrecedence !== null) { + if (operators.properties[precedence][_rootIdentifier].latexLeftParens === false) { + lhsParens = false; + } + + if (operators.properties[lhsPrecedence][lhsIdentifier].latexParens === false) { + lhsParens = false; + } + } + + if (rhsPrecedence !== null) { + if (operators.properties[precedence][_rootIdentifier].latexRightParens === false) { + rhsParens = false; + } + + if (operators.properties[rhsPrecedence][rhsIdentifier].latexParens === false) { + rhsParens = false; + } + } + } + + result = [lhsParens, rhsParens]; + break; + + default: + if (root.getIdentifier() === 'OperatorNode:add' || root.getIdentifier() === 'OperatorNode:multiply') { + result = args.map(function (arg) { + var argPrecedence = operators.getPrecedence(arg, parenthesis); + var assocWithArg = operators.isAssociativeWith(root, arg, parenthesis); + var argAssociativity = operators.getAssociativity(arg, parenthesis); + + if (argPrecedence === null) { + // if the argument has no defined precedence, no parens are needed + return false; + } else if (precedence === argPrecedence && associativity === argAssociativity && !assocWithArg) { + return true; + } else if (argPrecedence < precedence) { + return true; + } + + return false; + }); + } + + break; + } // handles an edge case of 'auto' parentheses with implicit multiplication of ConstantNode + // In that case print parentheses for ParenthesisNodes even though they normally wouldn't be + // printed. + + + if (args.length >= 2 && root.getIdentifier() === 'OperatorNode:multiply' && root.implicit && parenthesis === 'auto' && implicit === 'hide') { + result = args.map(function (arg, index) { + var isParenthesisNode = arg.getIdentifier() === 'ParenthesisNode'; + + if (result[index] || isParenthesisNode) { + // put in parenthesis? + return true; + } + + return false; + }); + } + + return result; + } + /** + * Get string representation. + * @param {Object} options + * @return {string} str + */ + + + OperatorNode.prototype._toString = function (options) { + var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep'; + var implicit = options && options.implicit ? options.implicit : 'hide'; + var args = this.args; + var parens = calculateNecessaryParentheses(this, parenthesis, implicit, args, false); + + if (args.length === 1) { + // unary operators + var assoc = operators.getAssociativity(this, parenthesis); + var operand = args[0].toString(options); + + if (parens[0]) { + operand = '(' + operand + ')'; + } + + if (assoc === 'right') { + // prefix operator + return this.op + operand; + } else if (assoc === 'left') { + // postfix + return operand + this.op; + } // fall back to postfix + + + return operand + this.op; + } else if (args.length === 2) { + var lhs = args[0].toString(options); // left hand side + + var rhs = args[1].toString(options); // right hand side + + if (parens[0]) { + // left hand side in parenthesis? + lhs = '(' + lhs + ')'; + } + + if (parens[1]) { + // right hand side in parenthesis? + rhs = '(' + rhs + ')'; + } + + if (this.implicit && this.getIdentifier() === 'OperatorNode:multiply' && implicit === 'hide') { + return lhs + ' ' + rhs; + } + + return lhs + ' ' + this.op + ' ' + rhs; + } else if (args.length > 2 && (this.getIdentifier() === 'OperatorNode:add' || this.getIdentifier() === 'OperatorNode:multiply')) { + var stringifiedArgs = args.map(function (arg, index) { + arg = arg.toString(options); + + if (parens[index]) { + // put in parenthesis? + arg = '(' + arg + ')'; + } + + return arg; + }); + + if (this.implicit && this.getIdentifier() === 'OperatorNode:multiply' && implicit === 'hide') { + return stringifiedArgs.join(' '); + } + + return stringifiedArgs.join(' ' + this.op + ' '); + } else { + // fallback to formatting as a function call + return this.fn + '(' + this.args.join(', ') + ')'; + } + }; + /** + * Get a JSON representation of the node + * @returns {Object} + */ + + + OperatorNode.prototype.toJSON = function () { + return { + mathjs: 'OperatorNode', + op: this.op, + fn: this.fn, + args: this.args, + implicit: this.implicit + }; + }; + /** + * Instantiate an OperatorNode from its JSON representation + * @param {Object} json An object structured like + * `{"mathjs": "OperatorNode", "op": "+", "fn": "add", "args": [...], "implicit": false}`, + * where mathjs is optional + * @returns {OperatorNode} + */ + + + OperatorNode.fromJSON = function (json) { + return new OperatorNode(json.op, json.fn, json.args, json.implicit); + }; + /** + * Get HTML representation. + * @param {Object} options + * @return {string} str + */ + + + OperatorNode.prototype.toHTML = function (options) { + var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep'; + var implicit = options && options.implicit ? options.implicit : 'hide'; + var args = this.args; + var parens = calculateNecessaryParentheses(this, parenthesis, implicit, args, false); + + if (args.length === 1) { + // unary operators + var assoc = operators.getAssociativity(this, parenthesis); + var operand = args[0].toHTML(options); + + if (parens[0]) { + operand = '<span class="math-parenthesis math-round-parenthesis">(</span>' + operand + '<span class="math-parenthesis math-round-parenthesis">)</span>'; + } + + if (assoc === 'right') { + // prefix operator + return '<span class="math-operator math-unary-operator math-lefthand-unary-operator">' + escape(this.op) + '</span>' + operand; + } else if (assoc === 'left') { + // postfix + return '<span class="math-operator math-unary-operator math-righthand-unary-operator">' + escape(this.op) + '</span>' + operand; + } // fall back to postfix + + + return '<span class="math-operator math-unary-operator math-righthand-unary-operator">' + escape(this.op) + '</span>' + operand; + } else if (args.length === 2) { + // binary operatoes + var lhs = args[0].toHTML(options); // left hand side + + var rhs = args[1].toHTML(options); // right hand side + + if (parens[0]) { + // left hand side in parenthesis? + lhs = '<span class="math-parenthesis math-round-parenthesis">(</span>' + lhs + '<span class="math-parenthesis math-round-parenthesis">)</span>'; + } + + if (parens[1]) { + // right hand side in parenthesis? + rhs = '<span class="math-parenthesis math-round-parenthesis">(</span>' + rhs + '<span class="math-parenthesis math-round-parenthesis">)</span>'; + } + + if (this.implicit && this.getIdentifier() === 'OperatorNode:multiply' && implicit === 'hide') { + return lhs + '<span class="math-operator math-binary-operator math-implicit-binary-operator"></span>' + rhs; + } + + return lhs + '<span class="math-operator math-binary-operator math-explicit-binary-operator">' + escape(this.op) + '</span>' + rhs; + } else { + var stringifiedArgs = args.map(function (arg, index) { + arg = arg.toHTML(options); + + if (parens[index]) { + // put in parenthesis? + arg = '<span class="math-parenthesis math-round-parenthesis">(</span>' + arg + '<span class="math-parenthesis math-round-parenthesis">)</span>'; + } + + return arg; + }); + + if (args.length > 2 && (this.getIdentifier() === 'OperatorNode:add' || this.getIdentifier() === 'OperatorNode:multiply')) { + if (this.implicit && this.getIdentifier() === 'OperatorNode:multiply' && implicit === 'hide') { + return stringifiedArgs.join('<span class="math-operator math-binary-operator math-implicit-binary-operator"></span>'); + } + + return stringifiedArgs.join('<span class="math-operator math-binary-operator math-explicit-binary-operator">' + escape(this.op) + '</span>'); + } else { + // fallback to formatting as a function call + return '<span class="math-function">' + escape(this.fn) + '</span><span class="math-paranthesis math-round-parenthesis">(</span>' + stringifiedArgs.join('<span class="math-separator">,</span>') + '<span class="math-paranthesis math-round-parenthesis">)</span>'; + } + } + }; + /** + * Get LaTeX representation + * @param {Object} options + * @return {string} str + */ + + + OperatorNode.prototype._toTex = function (options) { + var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep'; + var implicit = options && options.implicit ? options.implicit : 'hide'; + var args = this.args; + var parens = calculateNecessaryParentheses(this, parenthesis, implicit, args, true); + var op = latex.operators[this.fn]; + op = typeof op === 'undefined' ? this.op : op; // fall back to using this.op + + if (args.length === 1) { + // unary operators + var assoc = operators.getAssociativity(this, parenthesis); + var operand = args[0].toTex(options); + + if (parens[0]) { + operand = "\\left(".concat(operand, "\\right)"); + } + + if (assoc === 'right') { + // prefix operator + return op + operand; + } else if (assoc === 'left') { + // postfix operator + return operand + op; + } // fall back to postfix + + + return operand + op; + } else if (args.length === 2) { + // binary operators + var lhs = args[0]; // left hand side + + var lhsTex = lhs.toTex(options); + + if (parens[0]) { + lhsTex = "\\left(".concat(lhsTex, "\\right)"); + } + + var rhs = args[1]; // right hand side + + var rhsTex = rhs.toTex(options); + + if (parens[1]) { + rhsTex = "\\left(".concat(rhsTex, "\\right)"); + } // handle some exceptions (due to the way LaTeX works) + + + var lhsIdentifier; + + if (parenthesis === 'keep') { + lhsIdentifier = lhs.getIdentifier(); + } else { + // Ignore ParenthesisNodes if in 'keep' mode + lhsIdentifier = lhs.getContent().getIdentifier(); + } + + switch (this.getIdentifier()) { + case 'OperatorNode:divide': + // op contains '\\frac' at this point + return op + '{' + lhsTex + '}' + '{' + rhsTex + '}'; + + case 'OperatorNode:pow': + lhsTex = '{' + lhsTex + '}'; + rhsTex = '{' + rhsTex + '}'; + + switch (lhsIdentifier) { + case 'ConditionalNode': // + + case 'OperatorNode:divide': + lhsTex = "\\left(".concat(lhsTex, "\\right)"); + } + + break; + + case 'OperatorNode:multiply': + if (this.implicit && implicit === 'hide') { + return lhsTex + '~' + rhsTex; + } + + } + + return lhsTex + op + rhsTex; + } else if (args.length > 2 && (this.getIdentifier() === 'OperatorNode:add' || this.getIdentifier() === 'OperatorNode:multiply')) { + var texifiedArgs = args.map(function (arg, index) { + arg = arg.toTex(options); + + if (parens[index]) { + arg = "\\left(".concat(arg, "\\right)"); + } + + return arg; + }); + + if (this.getIdentifier() === 'OperatorNode:multiply' && this.implicit) { + return texifiedArgs.join('~'); + } + + return texifiedArgs.join(op); + } else { + // fall back to formatting as a function call + // as this is a fallback, it doesn't use + // fancy function names + return '\\mathrm{' + this.fn + '}\\left(' + args.map(function (arg) { + return arg.toTex(options); + }).join(',') + '\\right)'; + } + }; + /** + * Get identifier. + * @return {string} + */ + + + OperatorNode.prototype.getIdentifier = function () { + return this.type + ':' + this.fn; + }; + + return OperatorNode; +} + +exports.name = 'OperatorNode'; +exports.path = 'expression.node'; +exports.factory = factory; +},{"../../utils/array":46,"../../utils/customs":51,"../../utils/latex":53,"../../utils/string":57,"../operators":33,"./Node":24}],27:[function(require,module,exports){ +'use strict'; + +function factory(type, config, load, typed) { + var Node = load(require('./Node')); + /** + * @constructor ParenthesisNode + * @extends {Node} + * A parenthesis node describes manual parenthesis from the user input + * @param {Node} content + * @extends {Node} + */ + + function ParenthesisNode(content) { + if (!(this instanceof ParenthesisNode)) { + throw new SyntaxError('Constructor must be called with the new operator'); + } // validate input + + + if (!type.isNode(content)) { + throw new TypeError('Node expected for parameter "content"'); + } + + this.content = content; + } + + ParenthesisNode.prototype = new Node(); + ParenthesisNode.prototype.type = 'ParenthesisNode'; + ParenthesisNode.prototype.isParenthesisNode = 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: *) + */ + + ParenthesisNode.prototype._compile = function (math, argNames) { + return this.content._compile(math, argNames); + }; + /** + * Get the content of the current Node. + * @return {Node} content + * @override + **/ + + + ParenthesisNode.prototype.getContent = function () { + return this.content.getContent(); + }; + /** + * Execute a callback for each of the child nodes of this node + * @param {function(child: Node, path: string, parent: Node)} callback + */ + + + ParenthesisNode.prototype.forEach = function (callback) { + callback(this.content, 'content', this); + }; + /** + * Create a new ParenthesisNode having it's childs be the results of calling + * the provided callback function for each of the childs of the original node. + * @param {function(child: Node, path: string, parent: Node) : Node} callback + * @returns {ParenthesisNode} Returns a clone of the node + */ + + + ParenthesisNode.prototype.map = function (callback) { + var content = callback(this.content, 'content', this); + return new ParenthesisNode(content); + }; + /** + * Create a clone of this node, a shallow copy + * @return {ParenthesisNode} + */ + + + ParenthesisNode.prototype.clone = function () { + return new ParenthesisNode(this.content); + }; + /** + * Get string representation + * @param {Object} options + * @return {string} str + * @override + */ + + + ParenthesisNode.prototype._toString = function (options) { + if (!options || options && !options.parenthesis || options && options.parenthesis === 'keep') { + return '(' + this.content.toString(options) + ')'; + } + + return this.content.toString(options); + }; + /** + * Get a JSON representation of the node + * @returns {Object} + */ + + + ParenthesisNode.prototype.toJSON = function () { + return { + mathjs: 'ParenthesisNode', + content: this.content + }; + }; + /** + * Instantiate an ParenthesisNode from its JSON representation + * @param {Object} json An object structured like + * `{"mathjs": "ParenthesisNode", "content": ...}`, + * where mathjs is optional + * @returns {ParenthesisNode} + */ + + + ParenthesisNode.fromJSON = function (json) { + return new ParenthesisNode(json.content); + }; + /** + * Get HTML representation + * @param {Object} options + * @return {string} str + * @override + */ + + + ParenthesisNode.prototype.toHTML = function (options) { + if (!options || options && !options.parenthesis || options && options.parenthesis === 'keep') { + return '<span class="math-parenthesis math-round-parenthesis">(</span>' + this.content.toHTML(options) + '<span class="math-parenthesis math-round-parenthesis">)</span>'; + } + + return this.content.toHTML(options); + }; + /** + * Get LaTeX representation + * @param {Object} options + * @return {string} str + * @override + */ + + + ParenthesisNode.prototype._toTex = function (options) { + if (!options || options && !options.parenthesis || options && options.parenthesis === 'keep') { + return "\\left(".concat(this.content.toTex(options), "\\right)"); + } + + return this.content.toTex(options); + }; + + return ParenthesisNode; +} + +exports.name = 'ParenthesisNode'; +exports.path = 'expression.node'; +exports.factory = factory; +},{"./Node":24}],28:[function(require,module,exports){ +'use strict'; + +var operators = require('../operators'); + +function factory(type, config, load, typed) { + var Node = load(require('./Node')); + /** + * @constructor RangeNode + * @extends {Node} + * create a range + * @param {Node} start included lower-bound + * @param {Node} end included upper-bound + * @param {Node} [step] optional step + */ + + function RangeNode(start, end, step) { + if (!(this instanceof RangeNode)) { + throw new SyntaxError('Constructor must be called with the new operator'); + } // validate inputs + + + if (!type.isNode(start)) throw new TypeError('Node expected'); + if (!type.isNode(end)) throw new TypeError('Node expected'); + if (step && !type.isNode(step)) throw new TypeError('Node expected'); + if (arguments.length > 3) throw new Error('Too many arguments'); + this.start = start; // included lower-bound + + this.end = end; // included upper-bound + + this.step = step || null; // optional step + } + + RangeNode.prototype = new Node(); + RangeNode.prototype.type = 'RangeNode'; + RangeNode.prototype.isRangeNode = true; + /** + * Check whether the RangeNode needs the `end` symbol to be defined. + * This end is the size of the Matrix in current dimension. + * @return {boolean} + */ + + RangeNode.prototype.needsEnd = function () { + // find all `end` symbols in this RangeNode + var endSymbols = this.filter(function (node) { + return type.isSymbolNode(node) && node.name === 'end'; + }); + return endSymbols.length > 0; + }; + /** + * 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: *) + */ + + + RangeNode.prototype._compile = function (math, argNames) { + var range = math.range; + + var evalStart = this.start._compile(math, argNames); + + var evalEnd = this.end._compile(math, argNames); + + if (this.step) { + var evalStep = this.step._compile(math, argNames); + + return function evalRangeNode(scope, args, context) { + return range(evalStart(scope, args, context), evalEnd(scope, args, context), evalStep(scope, args, context)); + }; + } else { + return function evalRangeNode(scope, args, context) { + return range(evalStart(scope, args, context), evalEnd(scope, args, context)); + }; + } + }; + /** + * Execute a callback for each of the child nodes of this node + * @param {function(child: Node, path: string, parent: Node)} callback + */ + + + RangeNode.prototype.forEach = function (callback) { + callback(this.start, 'start', this); + callback(this.end, 'end', this); + + if (this.step) { + callback(this.step, 'step', this); + } + }; + /** + * Create a new RangeNode having it's childs be the results of calling + * the provided callback function for each of the childs of the original node. + * @param {function(child: Node, path: string, parent: Node): Node} callback + * @returns {RangeNode} Returns a transformed copy of the node + */ + + + RangeNode.prototype.map = function (callback) { + return new RangeNode(this._ifNode(callback(this.start, 'start', this)), this._ifNode(callback(this.end, 'end', this)), this.step && this._ifNode(callback(this.step, 'step', this))); + }; + /** + * Create a clone of this node, a shallow copy + * @return {RangeNode} + */ + + + RangeNode.prototype.clone = function () { + return new RangeNode(this.start, this.end, this.step && this.step); + }; + /** + * Calculate the necessary parentheses + * @param {Node} node + * @param {string} parenthesis + * @return {Object} parentheses + * @private + */ + + + function calculateNecessaryParentheses(node, parenthesis) { + var precedence = operators.getPrecedence(node, parenthesis); + var parens = {}; + var startPrecedence = operators.getPrecedence(node.start, parenthesis); + parens.start = startPrecedence !== null && startPrecedence <= precedence || parenthesis === 'all'; + + if (node.step) { + var stepPrecedence = operators.getPrecedence(node.step, parenthesis); + parens.step = stepPrecedence !== null && stepPrecedence <= precedence || parenthesis === 'all'; + } + + var endPrecedence = operators.getPrecedence(node.end, parenthesis); + parens.end = endPrecedence !== null && endPrecedence <= precedence || parenthesis === 'all'; + return parens; + } + /** + * Get string representation + * @param {Object} options + * @return {string} str + */ + + + RangeNode.prototype._toString = function (options) { + var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep'; + var parens = calculateNecessaryParentheses(this, parenthesis); // format string as start:step:stop + + var str; + var start = this.start.toString(options); + + if (parens.start) { + start = '(' + start + ')'; + } + + str = start; + + if (this.step) { + var step = this.step.toString(options); + + if (parens.step) { + step = '(' + step + ')'; + } + + str += ':' + step; + } + + var end = this.end.toString(options); + + if (parens.end) { + end = '(' + end + ')'; + } + + str += ':' + end; + return str; + }; + /** + * Get a JSON representation of the node + * @returns {Object} + */ + + + RangeNode.prototype.toJSON = function () { + return { + mathjs: 'RangeNode', + start: this.start, + end: this.end, + step: this.step + }; + }; + /** + * Instantiate an RangeNode from its JSON representation + * @param {Object} json An object structured like + * `{"mathjs": "RangeNode", "start": ..., "end": ..., "step": ...}`, + * where mathjs is optional + * @returns {RangeNode} + */ + + + RangeNode.fromJSON = function (json) { + return new RangeNode(json.start, json.end, json.step); + }; + /** + * Get HTML representation + * @param {Object} options + * @return {string} str + */ + + + RangeNode.prototype.toHTML = function (options) { + var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep'; + var parens = calculateNecessaryParentheses(this, parenthesis); // format string as start:step:stop + + var str; + var start = this.start.toHTML(options); + + if (parens.start) { + start = '<span class="math-parenthesis math-round-parenthesis">(</span>' + start + '<span class="math-parenthesis math-round-parenthesis">)</span>'; + } + + str = start; + + if (this.step) { + var step = this.step.toHTML(options); + + if (parens.step) { + step = '<span class="math-parenthesis math-round-parenthesis">(</span>' + step + '<span class="math-parenthesis math-round-parenthesis">)</span>'; + } + + str += '<span class="math-operator math-range-operator">:</span>' + step; + } + + var end = this.end.toHTML(options); + + if (parens.end) { + end = '<span class="math-parenthesis math-round-parenthesis">(</span>' + end + '<span class="math-parenthesis math-round-parenthesis">)</span>'; + } + + str += '<span class="math-operator math-range-operator">:</span>' + end; + return str; + }; + /** + * Get LaTeX representation + * @params {Object} options + * @return {string} str + */ + + + RangeNode.prototype._toTex = function (options) { + var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep'; + var parens = calculateNecessaryParentheses(this, parenthesis); + var str = this.start.toTex(options); + + if (parens.start) { + str = "\\left(".concat(str, "\\right)"); + } + + if (this.step) { + var step = this.step.toTex(options); + + if (parens.step) { + step = "\\left(".concat(step, "\\right)"); + } + + str += ':' + step; + } + + var end = this.end.toTex(options); + + if (parens.end) { + end = "\\left(".concat(end, "\\right)"); + } + + str += ':' + end; + return str; + }; + + return RangeNode; +} + +exports.name = 'RangeNode'; +exports.path = 'expression.node'; +exports.factory = factory; +},{"../operators":33,"./Node":24}],29:[function(require,module,exports){ +'use strict'; + +var operators = require('../operators'); + +var latex = require('../../utils/latex'); + +var escape = require('../../utils/string').escape; + +function factory(type, config, load, typed) { + var Node = load(require('./Node')); + + var getSafeProperty = require('../../utils/customs').getSafeProperty; + /** + * A node representing a chained conditional expression, such as 'x > y > z' + * + * @param {String[]} conditionals An array of conditional operators used to compare the parameters + * @param {Node[]} params The parameters that will be compared + * + * @constructor RelationalNode + * @extends {Node} + */ + + + function RelationalNode(conditionals, params) { + if (!(this instanceof RelationalNode)) { + throw new SyntaxError('Constructor must be called with the new operator'); + } + + if (!Array.isArray(conditionals)) throw new TypeError('Parameter conditionals must be an array'); + if (!Array.isArray(params)) throw new TypeError('Parameter params must be an array'); + if (conditionals.length !== params.length - 1) throw new TypeError('Parameter params must contain exactly one more element than parameter conditionals'); + this.conditionals = conditionals; + this.params = params; + } + + RelationalNode.prototype = new Node(); + RelationalNode.prototype.type = 'RelationalNode'; + RelationalNode.prototype.isRelationalNode = 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: *) + */ + + RelationalNode.prototype._compile = function (math, argNames) { + var self = this; + var compiled = this.params.map(function (p) { + return p._compile(math, argNames); + }); + return function evalRelationalNode(scope, args, context) { + var evalLhs; + var evalRhs = compiled[0](scope, args, context); + + for (var i = 0; i < self.conditionals.length; i++) { + evalLhs = evalRhs; + evalRhs = compiled[i + 1](scope, args, context); + var condFn = getSafeProperty(math, self.conditionals[i]); + + if (!condFn(evalLhs, evalRhs)) { + return false; + } + } + + return true; + }; + }; + /** + * Execute a callback for each of the child nodes of this node + * @param {function(child: Node, path: string, parent: Node)} callback + */ + + + RelationalNode.prototype.forEach = function (callback) { + var _this = this; + + this.params.forEach(function (n, i) { + return callback(n, 'params[' + i + ']', _this); + }, this); + }; + /** + * Create a new RelationalNode having its childs be the results of calling + * the provided callback function for each of the childs of the original node. + * @param {function(child: Node, path: string, parent: Node): Node} callback + * @returns {RelationalNode} Returns a transformed copy of the node + */ + + + RelationalNode.prototype.map = function (callback) { + var _this2 = this; + + return new RelationalNode(this.conditionals.slice(), this.params.map(function (n, i) { + return _this2._ifNode(callback(n, 'params[' + i + ']', _this2)); + }, this)); + }; + /** + * Create a clone of this node, a shallow copy + * @return {RelationalNode} + */ + + + RelationalNode.prototype.clone = function () { + return new RelationalNode(this.conditionals, this.params); + }; + /** + * Get string representation. + * @param {Object} options + * @return {string} str + */ + + + RelationalNode.prototype._toString = function (options) { + var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep'; + var precedence = operators.getPrecedence(this, parenthesis); + var paramStrings = this.params.map(function (p, index) { + var paramPrecedence = operators.getPrecedence(p, parenthesis); + return parenthesis === 'all' || paramPrecedence !== null && paramPrecedence <= precedence ? '(' + p.toString(options) + ')' : p.toString(options); + }); + var operatorMap = { + 'equal': '==', + 'unequal': '!=', + 'smaller': '<', + 'larger': '>', + 'smallerEq': '<=', + 'largerEq': '>=' + }; + var ret = paramStrings[0]; + + for (var i = 0; i < this.conditionals.length; i++) { + ret += ' ' + operatorMap[this.conditionals[i]] + ' ' + paramStrings[i + 1]; + } + + return ret; + }; + /** + * Get a JSON representation of the node + * @returns {Object} + */ + + + RelationalNode.prototype.toJSON = function () { + return { + mathjs: 'RelationalNode', + conditionals: this.conditionals, + params: this.params + }; + }; + /** + * Instantiate a RelationalNode from its JSON representation + * @param {Object} json An object structured like + * `{"mathjs": "RelationalNode", "condition": ..., "trueExpr": ..., "falseExpr": ...}`, + * where mathjs is optional + * @returns {RelationalNode} + */ + + + RelationalNode.fromJSON = function (json) { + return new RelationalNode(json.conditionals, json.params); + }; + /** + * Get HTML representation + * @param {Object} options + * @return {string} str + */ + + + RelationalNode.prototype.toHTML = function (options) { + var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep'; + var precedence = operators.getPrecedence(this, parenthesis); + var paramStrings = this.params.map(function (p, index) { + var paramPrecedence = operators.getPrecedence(p, parenthesis); + return parenthesis === 'all' || paramPrecedence !== null && paramPrecedence <= precedence ? '<span class="math-parenthesis math-round-parenthesis">(</span>' + p.toHTML(options) + '<span class="math-parenthesis math-round-parenthesis">)</span>' : p.toHTML(options); + }); + var operatorMap = { + 'equal': '==', + 'unequal': '!=', + 'smaller': '<', + 'larger': '>', + 'smallerEq': '<=', + 'largerEq': '>=' + }; + var ret = paramStrings[0]; + + for (var i = 0; i < this.conditionals.length; i++) { + ret += '<span class="math-operator math-binary-operator math-explicit-binary-operator">' + escape(operatorMap[this.conditionals[i]]) + '</span>' + paramStrings[i + 1]; + } + + return ret; + }; + /** + * Get LaTeX representation + * @param {Object} options + * @return {string} str + */ + + + RelationalNode.prototype._toTex = function (options) { + var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep'; + var precedence = operators.getPrecedence(this, parenthesis); + var paramStrings = this.params.map(function (p, index) { + var paramPrecedence = operators.getPrecedence(p, parenthesis); + return parenthesis === 'all' || paramPrecedence !== null && paramPrecedence <= precedence ? '\\left(' + p.toString(options) + '\right)' : p.toString(options); + }); + var ret = paramStrings[0]; + + for (var i = 0; i < this.conditionals.length; i++) { + ret += latex.operators[this.conditionals[i]] + paramStrings[i + 1]; + } + + return ret; + }; + + return RelationalNode; +} + +exports.name = 'RelationalNode'; +exports.path = 'expression.node'; +exports.factory = factory; +},{"../../utils/customs":51,"../../utils/latex":53,"../../utils/string":57,"../operators":33,"./Node":24}],30:[function(require,module,exports){ +'use strict'; + +var latex = require('../../utils/latex'); + +var escape = require('../../utils/string').escape; + +var hasOwnProperty = require('../../utils/object').hasOwnProperty; + +var getSafeProperty = require('../../utils/customs').getSafeProperty; + +function factory(type, config, load, typed, math) { + var Node = load(require('./Node')); + /** + * Check whether some name is a valueless unit like "inch". + * @param {string} name + * @return {boolean} + */ + + function isValuelessUnit(name) { + return type.Unit ? type.Unit.isValuelessUnit(name) : false; + } + /** + * @constructor SymbolNode + * @extends {Node} + * A symbol node can hold and resolve a symbol + * @param {string} name + * @extends {Node} + */ + + + function SymbolNode(name) { + if (!(this instanceof SymbolNode)) { + throw new SyntaxError('Constructor must be called with the new operator'); + } // validate input + + + if (typeof name !== 'string') throw new TypeError('String expected for parameter "name"'); + this.name = name; + } + + SymbolNode.prototype = new Node(); + SymbolNode.prototype.type = 'SymbolNode'; + SymbolNode.prototype.isSymbolNode = 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: *) + */ + + SymbolNode.prototype._compile = function (math, argNames) { + var name = this.name; + + if (hasOwnProperty(argNames, name)) { + // this is a FunctionAssignment argument + // (like an x when inside the expression of a function assignment `f(x) = ...`) + return function (scope, args, context) { + return args[name]; + }; + } else if (name in math) { + return function (scope, args, context) { + return name in scope ? getSafeProperty(scope, name) : getSafeProperty(math, name); + }; + } else { + var isUnit = isValuelessUnit(name); + return function (scope, args, context) { + return name in scope ? getSafeProperty(scope, name) : isUnit ? new type.Unit(null, name) : undef(name); + }; + } + }; + /** + * Execute a callback for each of the child nodes of this node + * @param {function(child: Node, path: string, parent: Node)} callback + */ + + + SymbolNode.prototype.forEach = function (callback) {} // nothing to do, we don't have childs + + /** + * Create a new SymbolNode having it's childs be the results of calling + * the provided callback function for each of the childs of the original node. + * @param {function(child: Node, path: string, parent: Node) : Node} callback + * @returns {SymbolNode} Returns a clone of the node + */ + ; + + SymbolNode.prototype.map = function (callback) { + return this.clone(); + }; + /** + * Throws an error 'Undefined symbol {name}' + * @param {string} name + */ + + + function undef(name) { + throw new Error('Undefined symbol ' + name); + } + /** + * Create a clone of this node, a shallow copy + * @return {SymbolNode} + */ + + + SymbolNode.prototype.clone = function () { + return new SymbolNode(this.name); + }; + /** + * Get string representation + * @param {Object} options + * @return {string} str + * @override + */ + + + SymbolNode.prototype._toString = function (options) { + return this.name; + }; + /** + * Get HTML representation + * @param {Object} options + * @return {string} str + * @override + */ + + + SymbolNode.prototype.toHTML = function (options) { + var name = escape(this.name); + + if (name === 'true' || name === 'false') { + return '<span class="math-symbol math-boolean">' + name + '</span>'; + } else if (name === 'i') { + return '<span class="math-symbol math-imaginary-symbol">' + name + '</span>'; + } else if (name === 'Infinity') { + return '<span class="math-symbol math-infinity-symbol">' + name + '</span>'; + } else if (name === 'NaN') { + return '<span class="math-symbol math-nan-symbol">' + name + '</span>'; + } else if (name === 'null') { + return '<span class="math-symbol math-null-symbol">' + name + '</span>'; + } else if (name === 'undefined') { + return '<span class="math-symbol math-undefined-symbol">' + name + '</span>'; + } + + return '<span class="math-symbol">' + name + '</span>'; + }; + /** + * Get a JSON representation of the node + * @returns {Object} + */ + + + SymbolNode.prototype.toJSON = function () { + return { + mathjs: 'SymbolNode', + name: this.name + }; + }; + /** + * Instantiate a SymbolNode from its JSON representation + * @param {Object} json An object structured like + * `{"mathjs": "SymbolNode", name: "x"}`, + * where mathjs is optional + * @returns {SymbolNode} + */ + + + SymbolNode.fromJSON = function (json) { + return new SymbolNode(json.name); + }; + /** + * Get LaTeX representation + * @param {Object} options + * @return {string} str + * @override + */ + + + SymbolNode.prototype._toTex = function (options) { + var isUnit = false; + + if (typeof math[this.name] === 'undefined' && isValuelessUnit(this.name)) { + isUnit = true; + } + + var symbol = latex.toSymbol(this.name, isUnit); + + if (symbol[0] === '\\') { + // no space needed if the symbol starts with '\' + return symbol; + } // the space prevents symbols from breaking stuff like '\cdot' if it's written right before the symbol + + + return ' ' + symbol; + }; + + return SymbolNode; +} + +exports.name = 'SymbolNode'; +exports.path = 'expression.node'; +exports.math = true; // request access to the math namespace as 5th argument of the factory function + +exports.factory = factory; +},{"../../utils/customs":51,"../../utils/latex":53,"../../utils/object":55,"../../utils/string":57,"./Node":24}],31:[function(require,module,exports){ +'use strict'; + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +var errorTransform = require('../../transform/error.transform').transform; + +var getSafeProperty = require('../../../utils/customs').getSafeProperty; + +function factory(type, config, load, typed) { + var subset = load(require('../../../function/matrix/subset')); + /** + * Retrieve part of an object: + * + * - Retrieve a property from an object + * - Retrieve a part of a string + * - Retrieve a matrix subset + * + * @param {Object | Array | Matrix | string} object + * @param {Index} index + * @return {Object | Array | Matrix | string} Returns the subset + */ + + return function access(object, index) { + try { + if (Array.isArray(object)) { + return subset(object, index); + } else if (object && typeof object.subset === 'function') { + // Matrix + return object.subset(index); + } else if (typeof object === 'string') { + // TODO: move getStringSubset into a separate util file, use that + return subset(object, index); + } else if (_typeof(object) === 'object') { + if (!index.isObjectProperty()) { + throw new TypeError('Cannot apply a numeric index as object property'); + } + + return getSafeProperty(object, index.getObjectProperty()); + } else { + throw new TypeError('Cannot apply index: unsupported type of object'); + } + } catch (err) { + throw errorTransform(err); + } + }; +} + +exports.factory = factory; +},{"../../../function/matrix/subset":36,"../../../utils/customs":51,"../../transform/error.transform":35}],32:[function(require,module,exports){ +'use strict'; + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +var errorTransform = require('../../transform/error.transform').transform; + +var setSafeProperty = require('../../../utils/customs').setSafeProperty; + +function factory(type, config, load, typed) { + var subset = load(require('../../../function/matrix/subset')); + var matrix = load(require('../../../type/matrix/function/matrix')); + /** + * Replace part of an object: + * + * - Assign a property to an object + * - Replace a part of a string + * - Replace a matrix subset + * + * @param {Object | Array | Matrix | string} object + * @param {Index} index + * @param {*} value + * @return {Object | Array | Matrix | string} Returns the original object + * except in case of a string + */ + // TODO: change assign to return the value instead of the object + + return function assign(object, index, value) { + try { + if (Array.isArray(object)) { + return matrix(object).subset(index, value).valueOf(); + } else if (object && typeof object.subset === 'function') { + // Matrix + return object.subset(index, value); + } else if (typeof object === 'string') { + // TODO: move setStringSubset into a separate util file, use that + return subset(object, index, value); + } else if (_typeof(object) === 'object') { + if (!index.isObjectProperty()) { + throw TypeError('Cannot apply a numeric index as object property'); + } + + setSafeProperty(object, index.getObjectProperty(), value); + return object; + } else { + throw new TypeError('Cannot apply index: unsupported type of object'); + } + } catch (err) { + throw errorTransform(err); + } + }; +} + +exports.factory = factory; +},{"../../../function/matrix/subset":36,"../../../type/matrix/function/matrix":42,"../../../utils/customs":51,"../../transform/error.transform":35}],33:[function(require,module,exports){ +'use strict'; // 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 properties = [{ + // assignment + 'AssignmentNode': {}, + 'FunctionAssignmentNode': {} +}, { + // conditional expression + 'ConditionalNode': { + latexLeftParens: false, + latexRightParens: false, + latexParens: false // conditionals don't need parentheses in LaTeX because + // they are 2 dimensional + + } +}, { + // logical or + 'OperatorNode:or': { + associativity: 'left', + associativeWith: [] + } +}, { + // logical xor + 'OperatorNode:xor': { + associativity: 'left', + associativeWith: [] + } +}, { + // logical and + 'OperatorNode:and': { + associativity: 'left', + associativeWith: [] + } +}, { + // bitwise or + 'OperatorNode:bitOr': { + associativity: 'left', + associativeWith: [] + } +}, { + // bitwise xor + 'OperatorNode:bitXor': { + associativity: 'left', + associativeWith: [] + } +}, { + // bitwise and + 'OperatorNode:bitAnd': { + associativity: 'left', + associativeWith: [] + } +}, { + // relational operators + 'OperatorNode:equal': { + associativity: 'left', + associativeWith: [] + }, + 'OperatorNode:unequal': { + associativity: 'left', + associativeWith: [] + }, + 'OperatorNode:smaller': { + associativity: 'left', + associativeWith: [] + }, + 'OperatorNode:larger': { + associativity: 'left', + associativeWith: [] + }, + 'OperatorNode:smallerEq': { + associativity: 'left', + associativeWith: [] + }, + 'OperatorNode:largerEq': { + associativity: 'left', + associativeWith: [] + }, + 'RelationalNode': { + associativity: 'left', + associativeWith: [] + } +}, { + // bitshift operators + 'OperatorNode:leftShift': { + associativity: 'left', + associativeWith: [] + }, + 'OperatorNode:rightArithShift': { + associativity: 'left', + associativeWith: [] + }, + 'OperatorNode:rightLogShift': { + associativity: 'left', + associativeWith: [] + } +}, { + // unit conversion + 'OperatorNode:to': { + associativity: 'left', + associativeWith: [] + } +}, { + // range + 'RangeNode': {} +}, { + // addition, subtraction + 'OperatorNode:add': { + associativity: 'left', + associativeWith: ['OperatorNode:add', 'OperatorNode:subtract'] + }, + 'OperatorNode:subtract': { + associativity: 'left', + associativeWith: [] + } +}, { + // multiply, divide, modulus + 'OperatorNode:multiply': { + associativity: 'left', + associativeWith: ['OperatorNode:multiply', 'OperatorNode:divide', 'Operator:dotMultiply', 'Operator:dotDivide'] + }, + 'OperatorNode:divide': { + associativity: 'left', + associativeWith: [], + latexLeftParens: false, + latexRightParens: false, + latexParens: false // fractions don't require parentheses because + // they're 2 dimensional, so parens aren't needed + // in LaTeX + + }, + 'OperatorNode:dotMultiply': { + associativity: 'left', + associativeWith: ['OperatorNode:multiply', 'OperatorNode:divide', 'OperatorNode:dotMultiply', 'OperatorNode:doDivide'] + }, + 'OperatorNode:dotDivide': { + associativity: 'left', + associativeWith: [] + }, + 'OperatorNode:mod': { + associativity: 'left', + associativeWith: [] + } +}, { + // unary prefix operators + 'OperatorNode:unaryPlus': { + associativity: 'right' + }, + 'OperatorNode:unaryMinus': { + associativity: 'right' + }, + 'OperatorNode:bitNot': { + associativity: 'right' + }, + 'OperatorNode:not': { + associativity: 'right' + } +}, { + // exponentiation + 'OperatorNode:pow': { + associativity: 'right', + associativeWith: [], + latexRightParens: false // the exponent doesn't need parentheses in + // LaTeX because it's 2 dimensional + // (it's on top) + + }, + 'OperatorNode:dotPow': { + associativity: 'right', + associativeWith: [] + } +}, { + // factorial + 'OperatorNode:factorial': { + associativity: 'left' + } +}, { + // matrix transpose + 'OperatorNode:transpose': { + associativity: 'left' + } +}]; +/** + * Get the precedence of a Node. + * Higher number for higher precedence, starting with 0. + * Returns null if the precedence is undefined. + * + * @param {Node} + * @param {string} parenthesis + * @return {number|null} + */ + +function getPrecedence(_node, parenthesis) { + var node = _node; + + if (parenthesis !== 'keep') { + // ParenthesisNodes are only ignored when not in 'keep' mode + node = _node.getContent(); + } + + var identifier = node.getIdentifier(); + + for (var i = 0; i < properties.length; i++) { + if (identifier in properties[i]) { + return i; + } + } + + return null; +} +/** + * Get the associativity of an operator (left or right). + * Returns a string containing 'left' or 'right' or null if + * the associativity is not defined. + * + * @param {Node} + * @param {string} parenthesis + * @return {string|null} + * @throws {Error} + */ + + +function getAssociativity(_node, parenthesis) { + var node = _node; + + if (parenthesis !== 'keep') { + // ParenthesisNodes are only ignored when not in 'keep' mode + node = _node.getContent(); + } + + var identifier = node.getIdentifier(); + var index = getPrecedence(node, parenthesis); + + if (index === null) { + // node isn't in the list + return null; + } + + var property = properties[index][identifier]; + + if (property.hasOwnProperty('associativity')) { + if (property.associativity === 'left') { + return 'left'; + } + + if (property.associativity === 'right') { + return 'right'; + } // associativity is invalid + + + throw Error('\'' + identifier + '\' has the invalid associativity \'' + property.associativity + '\'.'); + } // associativity is undefined + + + return null; +} +/** + * Check if an operator is associative with another operator. + * Returns either true or false or null if not defined. + * + * @param {Node} nodeA + * @param {Node} nodeB + * @param {string} parenthesis + * @return {bool|null} + */ + + +function isAssociativeWith(nodeA, nodeB, parenthesis) { + // ParenthesisNodes are only ignored when not in 'keep' mode + var a = parenthesis !== 'keep' ? nodeA.getContent() : nodeA; + var b = parenthesis !== 'keep' ? nodeA.getContent() : nodeB; + var identifierA = a.getIdentifier(); + var identifierB = b.getIdentifier(); + var index = getPrecedence(a, parenthesis); + + if (index === null) { + // node isn't in the list + return null; + } + + var property = properties[index][identifierA]; + + if (property.hasOwnProperty('associativeWith') && property.associativeWith instanceof Array) { + for (var i = 0; i < property.associativeWith.length; i++) { + if (property.associativeWith[i] === identifierB) { + return true; + } + } + + return false; + } // associativeWith is not defined + + + return null; +} + +module.exports.properties = properties; +module.exports.getPrecedence = getPrecedence; +module.exports.getAssociativity = getAssociativity; +module.exports.isAssociativeWith = isAssociativeWith; +},{}],34:[function(require,module,exports){ +'use strict'; + +function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); } + +var ArgumentsError = require('../error/ArgumentsError'); + +var deepMap = require('../utils/collection/deepMap'); + +function factory(type, config, load, typed) { + var numeric = load(require('../type/numeric')); + var AccessorNode = load(require('./node/AccessorNode')); + var ArrayNode = load(require('./node/ArrayNode')); + var AssignmentNode = load(require('./node/AssignmentNode')); + var BlockNode = load(require('./node/BlockNode')); + var ConditionalNode = load(require('./node/ConditionalNode')); + var ConstantNode = load(require('./node/ConstantNode')); + var FunctionAssignmentNode = load(require('./node/FunctionAssignmentNode')); + var IndexNode = load(require('./node/IndexNode')); + var ObjectNode = load(require('./node/ObjectNode')); + var OperatorNode = load(require('./node/OperatorNode')); + var ParenthesisNode = load(require('./node/ParenthesisNode')); + var FunctionNode = load(require('./node/FunctionNode')); + var RangeNode = load(require('./node/RangeNode')); + var RelationalNode = load(require('./node/RelationalNode')); + var SymbolNode = load(require('./node/SymbolNode')); + /** + * Parse an expression. Returns a node tree, which can be evaluated by + * invoking node.eval(). + * + * Syntax: + * + * parse(expr) + * parse(expr, options) + * parse([expr1, expr2, expr3, ...]) + * parse([expr1, expr2, expr3, ...], options) + * + * Example: + * + * const node = parse('sqrt(3^2 + 4^2)') + * node.compile(math).eval() // 5 + * + * let scope = {a:3, b:4} + * const node = parse('a * b') // 12 + * const code = node.compile(math) + * code.eval(scope) // 12 + * scope.a = 5 + * code.eval(scope) // 20 + * + * const nodes = math.parse(['a = 3', 'b = 4', 'a * b']) + * nodes[2].compile(math).eval() // 12 + * + * @param {string | string[] | Matrix} expr + * @param {{nodes: Object<string, Node>}} [options] Available options: + * - `nodes` a set of custom nodes + * @return {Node | Node[]} node + * @throws {Error} + */ + + function parse(expr, options) { + if (arguments.length !== 1 && arguments.length !== 2) { + throw new ArgumentsError('parse', arguments.length, 1, 2); + } // pass extra nodes + + + var extraNodes = options && options.nodes ? options.nodes : {}; + + if (typeof expr === 'string') { + // parse a single expression + return parseStart(expr, extraNodes); + } else if (Array.isArray(expr) || expr instanceof type.Matrix) { + // parse an array or matrix with expressions + return deepMap(expr, function (elem) { + if (typeof elem !== 'string') throw new TypeError('String expected'); + return parseStart(elem, extraNodes); + }); + } else { + // oops + throw new TypeError('String or matrix expected'); + } + } // token types enumeration + + + var TOKENTYPE = { + NULL: 0, + DELIMITER: 1, + NUMBER: 2, + SYMBOL: 3, + UNKNOWN: 4 // map with all delimiters + + }; + var DELIMITERS = { + ',': true, + '(': true, + ')': true, + '[': true, + ']': true, + '{': true, + '}': true, + '"': true, + '\'': true, + ';': true, + '+': true, + '-': true, + '*': true, + '.*': true, + '/': true, + './': true, + '%': true, + '^': true, + '.^': true, + '~': true, + '!': true, + '&': true, + '|': true, + '^|': true, + '=': true, + ':': true, + '?': true, + '==': true, + '!=': true, + '<': true, + '>': true, + '<=': true, + '>=': true, + '<<': true, + '>>': true, + '>>>': true // map with all named delimiters + + }; + var NAMED_DELIMITERS = { + 'mod': true, + 'to': true, + 'in': true, + 'and': true, + 'xor': true, + 'or': true, + 'not': true + }; + var CONSTANTS = { + 'true': true, + 'false': false, + 'null': null, + 'undefined': undefined + }; + var NUMERIC_CONSTANTS = ['NaN', 'Infinity']; + + function initialState() { + return { + extraNodes: {}, + // current extra nodes, must be careful not to mutate + expression: '', + // current expression + comment: '', + // last parsed comment + index: 0, + // current index in expr + token: '', + // current token + tokenType: TOKENTYPE.NULL, + // type of the token + nestingLevel: 0, + // level of nesting inside parameters, used to ignore newline characters + conditionalLevel: null // when a conditional is being parsed, the level of the conditional is stored here + + }; + } + /** + * View upto `length` characters of the expression starting at the current character. + * + * @param {State} state + * @param {number} [length=1] Number of characters to view + * @returns {string} + * @private + */ + + + function currentString(state, length) { + return state.expression.substr(state.index, length); + } + /** + * View the current character. Returns '' if end of expression is reached. + * + * @param {State} state + * @returns {string} + * @private + */ + + + function currentCharacter(state) { + return currentString(state, 1); + } + /** + * Get the next character from the expression. + * The character is stored into the char c. If the end of the expression is + * reached, the function puts an empty string in c. + * @private + */ + + + function next(state) { + state.index++; + } + /** + * Preview the previous character from the expression. + * @return {string} cNext + * @private + */ + + + function prevCharacter(state) { + return state.expression.charAt(state.index - 1); + } + /** + * Preview the next character from the expression. + * @return {string} cNext + * @private + */ + + + function nextCharacter(state) { + return state.expression.charAt(state.index + 1); + } + /** + * Get next token in the current string expr. + * The token and token type are available as token and tokenType + * @private + */ + + + function getToken(state) { + state.tokenType = TOKENTYPE.NULL; + state.token = ''; + state.comment = ''; // skip over whitespaces + // space, tab, and newline when inside parameters + + while (parse.isWhitespace(currentCharacter(state), state.nestingLevel)) { + next(state); + } // skip comment + + + if (currentCharacter(state) === '#') { + while (currentCharacter(state) !== '\n' && currentCharacter(state) !== '') { + state.comment += currentCharacter(state); + next(state); + } + } // check for end of expression + + + if (currentCharacter(state) === '') { + // token is still empty + state.tokenType = TOKENTYPE.DELIMITER; + return; + } // check for new line character + + + if (currentCharacter(state) === '\n' && !state.nestingLevel) { + state.tokenType = TOKENTYPE.DELIMITER; + state.token = currentCharacter(state); + next(state); + return; + } + + var c1 = currentCharacter(state); + var c2 = currentString(state, 2); + var c3 = currentString(state, 3); + + if (c3.length === 3 && DELIMITERS[c3]) { + state.tokenType = TOKENTYPE.DELIMITER; + state.token = c3; + next(state); + next(state); + next(state); + return; + } // check for delimiters consisting of 2 characters + + + if (c2.length === 2 && DELIMITERS[c2]) { + state.tokenType = TOKENTYPE.DELIMITER; + state.token = c2; + next(state); + next(state); + return; + } // check for delimiters consisting of 1 character + + + if (DELIMITERS[c1]) { + state.tokenType = TOKENTYPE.DELIMITER; + state.token = c1; + next(state); + return; + } // check for a number + + + if (parse.isDigitDot(c1)) { + state.tokenType = TOKENTYPE.NUMBER; // get number, can have a single dot + + if (currentCharacter(state) === '.') { + state.token += currentCharacter(state); + next(state); + + if (!parse.isDigit(currentCharacter(state))) { + // this is no number, it is just a dot (can be dot notation) + state.tokenType = TOKENTYPE.DELIMITER; + } + } else { + while (parse.isDigit(currentCharacter(state))) { + state.token += currentCharacter(state); + next(state); + } + + if (parse.isDecimalMark(currentCharacter(state), nextCharacter(state))) { + state.token += currentCharacter(state); + next(state); + } + } + + while (parse.isDigit(currentCharacter(state))) { + state.token += currentCharacter(state); + next(state); + } // check for exponential notation like "2.3e-4", "1.23e50" or "2e+4" + + + if (currentCharacter(state) === 'E' || currentCharacter(state) === 'e') { + if (parse.isDigit(nextCharacter(state)) || nextCharacter(state) === '-' || nextCharacter(state) === '+') { + state.token += currentCharacter(state); + next(state); + + if (currentCharacter(state) === '+' || currentCharacter(state) === '-') { + state.token += currentCharacter(state); + next(state); + } // Scientific notation MUST be followed by an exponent + + + if (!parse.isDigit(currentCharacter(state))) { + throw createSyntaxError(state, 'Digit expected, got "' + currentCharacter(state) + '"'); + } + + while (parse.isDigit(currentCharacter(state))) { + state.token += currentCharacter(state); + next(state); + } + + if (parse.isDecimalMark(currentCharacter(state), nextCharacter(state))) { + throw createSyntaxError(state, 'Digit expected, got "' + currentCharacter(state) + '"'); + } + } else if (nextCharacter(state) === '.') { + next(state); + throw createSyntaxError(state, 'Digit expected, got "' + currentCharacter(state) + '"'); + } + } + + return; + } // check for variables, functions, named operators + + + if (parse.isAlpha(currentCharacter(state), prevCharacter(state), nextCharacter(state))) { + while (parse.isAlpha(currentCharacter(state), prevCharacter(state), nextCharacter(state)) || parse.isDigit(currentCharacter(state))) { + state.token += currentCharacter(state); + next(state); + } + + if (NAMED_DELIMITERS.hasOwnProperty(state.token)) { + state.tokenType = TOKENTYPE.DELIMITER; + } else { + state.tokenType = TOKENTYPE.SYMBOL; + } + + return; + } // something unknown is found, wrong characters -> a syntax error + + + state.tokenType = TOKENTYPE.UNKNOWN; + + while (currentCharacter(state) !== '') { + state.token += currentCharacter(state); + next(state); + } + + throw createSyntaxError(state, 'Syntax error in part "' + state.token + '"'); + } + /** + * Get next token and skip newline tokens + */ + + + function getTokenSkipNewline(state) { + do { + getToken(state); + } while (state.token === '\n'); // eslint-disable-line no-unmodified-loop-condition + + } + /** + * Open parameters. + * New line characters will be ignored until closeParams(state) is called + */ + + + function openParams(state) { + state.nestingLevel++; + } + /** + * Close parameters. + * New line characters will no longer be ignored + */ + + + function closeParams(state) { + state.nestingLevel--; + } + /** + * Checks whether the current character `c` is a valid alpha character: + * + * - A latin letter (upper or lower case) Ascii: a-z, A-Z + * - An underscore Ascii: _ + * - A dollar sign Ascii: $ + * - A latin letter with accents Unicode: \u00C0 - \u02AF + * - A greek letter Unicode: \u0370 - \u03FF + * - A mathematical alphanumeric symbol Unicode: \u{1D400} - \u{1D7FF} excluding invalid code points + * + * The previous and next characters are needed to determine whether + * this character is part of a unicode surrogate pair. + * + * @param {string} c Current character in the expression + * @param {string} cPrev Previous character + * @param {string} cNext Next character + * @return {boolean} + */ + + + parse.isAlpha = function isAlpha(c, cPrev, cNext) { + return parse.isValidLatinOrGreek(c) || parse.isValidMathSymbol(c, cNext) || parse.isValidMathSymbol(cPrev, c); + }; + /** + * Test whether a character is a valid latin, greek, or letter-like character + * @param {string} c + * @return {boolean} + */ + + + parse.isValidLatinOrGreek = function isValidLatinOrGreek(c) { + return /^[a-zA-Z_$\u00C0-\u02AF\u0370-\u03FF\u2100-\u214F]$/.test(c); + }; + /** + * Test whether two given 16 bit characters form a surrogate pair of a + * unicode math symbol. + * + * http://unicode-table.com/en/ + * http://www.wikiwand.com/en/Mathematical_operators_and_symbols_in_Unicode + * + * Note: In ES6 will be unicode aware: + * http://stackoverflow.com/questions/280712/javascript-unicode-regexes + * https://mathiasbynens.be/notes/es6-unicode-regex + * + * @param {string} high + * @param {string} low + * @return {boolean} + */ + + + parse.isValidMathSymbol = function isValidMathSymbol(high, low) { + return /^[\uD835]$/.test(high) && /^[\uDC00-\uDFFF]$/.test(low) && /^[^\uDC55\uDC9D\uDCA0\uDCA1\uDCA3\uDCA4\uDCA7\uDCA8\uDCAD\uDCBA\uDCBC\uDCC4\uDD06\uDD0B\uDD0C\uDD15\uDD1D\uDD3A\uDD3F\uDD45\uDD47-\uDD49\uDD51\uDEA6\uDEA7\uDFCC\uDFCD]$/.test(low); + }; + /** + * Check whether given character c is a white space character: space, tab, or enter + * @param {string} c + * @param {number} nestingLevel + * @return {boolean} + */ + + + parse.isWhitespace = function isWhitespace(c, nestingLevel) { + // TODO: also take '\r' carriage return as newline? Or does that give problems on mac? + return c === ' ' || c === '\t' || c === '\n' && nestingLevel > 0; + }; + /** + * Test whether the character c is a decimal mark (dot). + * This is the case when it's not the start of a delimiter '.*', './', or '.^' + * @param {string} c + * @param {string} cNext + * @return {boolean} + */ + + + parse.isDecimalMark = function isDecimalMark(c, cNext) { + return c === '.' && cNext !== '/' && cNext !== '*' && cNext !== '^'; + }; + /** + * checks if the given char c is a digit or dot + * @param {string} c a string with one character + * @return {boolean} + */ + + + parse.isDigitDot = function isDigitDot(c) { + return c >= '0' && c <= '9' || c === '.'; + }; + /** + * checks if the given char c is a digit + * @param {string} c a string with one character + * @return {boolean} + */ + + + parse.isDigit = function isDigit(c) { + return c >= '0' && c <= '9'; + }; + /** + * Start of the parse levels below, in order of precedence + * @return {Node} node + * @private + */ + + + function parseStart(expression, extraNodes) { + var state = initialState(); + + _extends(state, { + expression: expression, + extraNodes: extraNodes + }); + + getToken(state); + var node = parseBlock(state); // check for garbage at the end of the expression + // an expression ends with a empty character '' and tokenType DELIMITER + + if (state.token !== '') { + if (state.tokenType === TOKENTYPE.DELIMITER) { + // user entered a not existing operator like "//" + // TODO: give hints for aliases, for example with "<>" give as hint " did you mean !== ?" + throw createError(state, 'Unexpected operator ' + state.token); + } else { + throw createSyntaxError(state, 'Unexpected part "' + state.token + '"'); + } + } + + return node; + } + /** + * Parse a block with expressions. Expressions can be separated by a newline + * character '\n', or by a semicolon ';'. In case of a semicolon, no output + * of the preceding line is returned. + * @return {Node} node + * @private + */ + + + function parseBlock(state) { + var node; + var blocks = []; + var visible; + + if (state.token !== '' && state.token !== '\n' && state.token !== ';') { + node = parseAssignment(state); + node.comment = state.comment; + } // TODO: simplify this loop + + + while (state.token === '\n' || state.token === ';') { + // eslint-disable-line no-unmodified-loop-condition + if (blocks.length === 0 && node) { + visible = state.token !== ';'; + blocks.push({ + node: node, + visible: visible + }); + } + + getToken(state); + + if (state.token !== '\n' && state.token !== ';' && state.token !== '') { + node = parseAssignment(state); + node.comment = state.comment; + visible = state.token !== ';'; + blocks.push({ + node: node, + visible: visible + }); + } + } + + if (blocks.length > 0) { + return new BlockNode(blocks); + } else { + if (!node) { + node = new ConstantNode(undefined); + node.comment = state.comment; + } + + return node; + } + } + /** + * Assignment of a function or variable, + * - can be a variable like 'a=2.3' + * - or a updating an existing variable like 'matrix(2,3:5)=[6,7,8]' + * - defining a function like 'f(x) = x^2' + * @return {Node} node + * @private + */ + + + function parseAssignment(state) { + var name, args, value, valid; + var node = parseConditional(state); + + if (state.token === '=') { + if (type.isSymbolNode(node)) { + // parse a variable assignment like 'a = 2/3' + name = node.name; + getTokenSkipNewline(state); + value = parseAssignment(state); + return new AssignmentNode(new SymbolNode(name), value); + } else if (type.isAccessorNode(node)) { + // parse a matrix subset assignment like 'A[1,2] = 4' + getTokenSkipNewline(state); + value = parseAssignment(state); + return new AssignmentNode(node.object, node.index, value); + } else if (type.isFunctionNode(node) && type.isSymbolNode(node.fn)) { + // parse function assignment like 'f(x) = x^2' + valid = true; + args = []; + name = node.name; + node.args.forEach(function (arg, index) { + if (type.isSymbolNode(arg)) { + args[index] = arg.name; + } else { + valid = false; + } + }); + + if (valid) { + getTokenSkipNewline(state); + value = parseAssignment(state); + return new FunctionAssignmentNode(name, args, value); + } + } + + throw createSyntaxError(state, 'Invalid left hand side of assignment operator ='); + } + + return node; + } + /** + * conditional operation + * + * condition ? truePart : falsePart + * + * Note: conditional operator is right-associative + * + * @return {Node} node + * @private + */ + + + function parseConditional(state) { + var node = parseLogicalOr(state); + + while (state.token === '?') { + // eslint-disable-line no-unmodified-loop-condition + // set a conditional level, the range operator will be ignored as long + // as conditionalLevel === state.nestingLevel. + var prev = state.conditionalLevel; + state.conditionalLevel = state.nestingLevel; + getTokenSkipNewline(state); + var condition = node; + var trueExpr = parseAssignment(state); + if (state.token !== ':') throw createSyntaxError(state, 'False part of conditional expression expected'); + state.conditionalLevel = null; + getTokenSkipNewline(state); + var falseExpr = parseAssignment(state); // Note: check for conditional operator again, right associativity + + node = new ConditionalNode(condition, trueExpr, falseExpr); // restore the previous conditional level + + state.conditionalLevel = prev; + } + + return node; + } + /** + * logical or, 'x or y' + * @return {Node} node + * @private + */ + + + function parseLogicalOr(state) { + var node = parseLogicalXor(state); + + while (state.token === 'or') { + // eslint-disable-line no-unmodified-loop-condition + getTokenSkipNewline(state); + node = new OperatorNode('or', 'or', [node, parseLogicalXor(state)]); + } + + return node; + } + /** + * logical exclusive or, 'x xor y' + * @return {Node} node + * @private + */ + + + function parseLogicalXor(state) { + var node = parseLogicalAnd(state); + + while (state.token === 'xor') { + // eslint-disable-line no-unmodified-loop-condition + getTokenSkipNewline(state); + node = new OperatorNode('xor', 'xor', [node, parseLogicalAnd(state)]); + } + + return node; + } + /** + * logical and, 'x and y' + * @return {Node} node + * @private + */ + + + function parseLogicalAnd(state) { + var node = parseBitwiseOr(state); + + while (state.token === 'and') { + // eslint-disable-line no-unmodified-loop-condition + getTokenSkipNewline(state); + node = new OperatorNode('and', 'and', [node, parseBitwiseOr(state)]); + } + + return node; + } + /** + * bitwise or, 'x | y' + * @return {Node} node + * @private + */ + + + function parseBitwiseOr(state) { + var node = parseBitwiseXor(state); + + while (state.token === '|') { + // eslint-disable-line no-unmodified-loop-condition + getTokenSkipNewline(state); + node = new OperatorNode('|', 'bitOr', [node, parseBitwiseXor(state)]); + } + + return node; + } + /** + * bitwise exclusive or (xor), 'x ^| y' + * @return {Node} node + * @private + */ + + + function parseBitwiseXor(state) { + var node = parseBitwiseAnd(state); + + while (state.token === '^|') { + // eslint-disable-line no-unmodified-loop-condition + getTokenSkipNewline(state); + node = new OperatorNode('^|', 'bitXor', [node, parseBitwiseAnd(state)]); + } + + return node; + } + /** + * bitwise and, 'x & y' + * @return {Node} node + * @private + */ + + + function parseBitwiseAnd(state) { + var node = parseRelational(state); + + while (state.token === '&') { + // eslint-disable-line no-unmodified-loop-condition + getTokenSkipNewline(state); + node = new OperatorNode('&', 'bitAnd', [node, parseRelational(state)]); + } + + return node; + } + /** + * Parse a chained conditional, like 'a > b >= c' + * @return {Node} node + */ + + + function parseRelational(state) { + var params = [parseShift(state)]; + var conditionals = []; + var operators = { + '==': 'equal', + '!=': 'unequal', + '<': 'smaller', + '>': 'larger', + '<=': 'smallerEq', + '>=': 'largerEq' + }; + + while (operators.hasOwnProperty(state.token)) { + // eslint-disable-line no-unmodified-loop-condition + var cond = { + name: state.token, + fn: operators[state.token] + }; + conditionals.push(cond); + getTokenSkipNewline(state); + params.push(parseShift(state)); + } + + if (params.length === 1) { + return params[0]; + } else if (params.length === 2) { + return new OperatorNode(conditionals[0].name, conditionals[0].fn, params); + } else { + return new RelationalNode(conditionals.map(function (c) { + return c.fn; + }), params); + } + } + /** + * Bitwise left shift, bitwise right arithmetic shift, bitwise right logical shift + * @return {Node} node + * @private + */ + + + function parseShift(state) { + var node, operators, name, fn, params; + node = parseConversion(state); + operators = { + '<<': 'leftShift', + '>>': 'rightArithShift', + '>>>': 'rightLogShift' + }; + + while (operators.hasOwnProperty(state.token)) { + name = state.token; + fn = operators[name]; + getTokenSkipNewline(state); + params = [node, parseConversion(state)]; + node = new OperatorNode(name, fn, params); + } + + return node; + } + /** + * conversion operators 'to' and 'in' + * @return {Node} node + * @private + */ + + + function parseConversion(state) { + var node, operators, name, fn, params; + node = parseRange(state); + operators = { + 'to': 'to', + 'in': 'to' // alias of 'to' + + }; + + while (operators.hasOwnProperty(state.token)) { + name = state.token; + fn = operators[name]; + getTokenSkipNewline(state); + + if (name === 'in' && state.token === '') { + // end of expression -> this is the unit 'in' ('inch') + node = new OperatorNode('*', 'multiply', [node, new SymbolNode('in')], true); + } else { + // operator 'a to b' or 'a in b' + params = [node, parseRange(state)]; + node = new OperatorNode(name, fn, params); + } + } + + return node; + } + /** + * parse range, "start:end", "start:step:end", ":", "start:", ":end", etc + * @return {Node} node + * @private + */ + + + function parseRange(state) { + var node; + var params = []; + + if (state.token === ':') { + // implicit start=1 (one-based) + node = new ConstantNode(1); + } else { + // explicit start + node = parseAddSubtract(state); + } + + if (state.token === ':' && state.conditionalLevel !== state.nestingLevel) { + // we ignore the range operator when a conditional operator is being processed on the same level + params.push(node); // parse step and end + + while (state.token === ':' && params.length < 3) { + // eslint-disable-line no-unmodified-loop-condition + getTokenSkipNewline(state); + + if (state.token === ')' || state.token === ']' || state.token === ',' || state.token === '') { + // implicit end + params.push(new SymbolNode('end')); + } else { + // explicit end + params.push(parseAddSubtract(state)); + } + } + + if (params.length === 3) { + // params = [start, step, end] + node = new RangeNode(params[0], params[2], params[1]); // start, end, step + } else { + // length === 2 + // params = [start, end] + node = new RangeNode(params[0], params[1]); // start, end + } + } + + return node; + } + /** + * add or subtract + * @return {Node} node + * @private + */ + + + function parseAddSubtract(state) { + var node, operators, name, fn, params; + node = parseMultiplyDivide(state); + operators = { + '+': 'add', + '-': 'subtract' + }; + + while (operators.hasOwnProperty(state.token)) { + name = state.token; + fn = operators[name]; + getTokenSkipNewline(state); + params = [node, parseMultiplyDivide(state)]; + node = new OperatorNode(name, fn, params); + } + + return node; + } + /** + * multiply, divide, modulus + * @return {Node} node + * @private + */ + + + function parseMultiplyDivide(state) { + var node, last, operators, name, fn; + node = parseImplicitMultiplication(state); + last = node; + operators = { + '*': 'multiply', + '.*': 'dotMultiply', + '/': 'divide', + './': 'dotDivide', + '%': 'mod', + 'mod': 'mod' + }; + + while (true) { + if (operators.hasOwnProperty(state.token)) { + // explicit operators + name = state.token; + fn = operators[name]; + getTokenSkipNewline(state); + last = parseImplicitMultiplication(state); + node = new OperatorNode(name, fn, [node, last]); + } else { + break; + } + } + + return node; + } + /** + * implicit multiplication + * @return {Node} node + * @private + */ + + + function parseImplicitMultiplication(state) { + var node, last; + node = parseRule2(state); + last = node; + + while (true) { + if (state.tokenType === TOKENTYPE.SYMBOL || state.token === 'in' && type.isConstantNode(node) || state.tokenType === TOKENTYPE.NUMBER && !type.isConstantNode(last) && (!type.isOperatorNode(last) || last.op === '!') || state.token === '(') { + // parse implicit multiplication + // + // symbol: implicit multiplication like '2a', '(2+3)a', 'a b' + // number: implicit multiplication like '(2+3)2' + // parenthesis: implicit multiplication like '2(3+4)', '(3+4)(1+2)' + last = parseRule2(state); + node = new OperatorNode('*', 'multiply', [node, last], true + /* implicit */ + ); + } else { + break; + } + } + + return node; + } + /** + * Infamous "rule 2" as described in https://github.com/josdejong/mathjs/issues/792#issuecomment-361065370 + * Explicit division gets higher precedence than implicit multiplication + * when the division matches this pattern: [number] / [number] [symbol] + * @return {Node} node + * @private + */ + + + function parseRule2(state) { + var node = parseUnary(state); + var last = node; + var tokenStates = []; + + while (true) { + // Match the "number /" part of the pattern "number / number symbol" + if (state.token === '/' && type.isConstantNode(last)) { + // Look ahead to see if the next token is a number + tokenStates.push(_extends({}, state)); + getTokenSkipNewline(state); // Match the "number / number" part of the pattern + + if (state.tokenType === TOKENTYPE.NUMBER) { + // Look ahead again + tokenStates.push(_extends({}, 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 + _extends(state, tokenStates.pop()); + + tokenStates.pop(); + last = parseUnary(state); + node = new OperatorNode('/', 'divide', [node, last]); + } else { + // Not a match, so rewind + tokenStates.pop(); + + _extends(state, tokenStates.pop()); + + break; + } + } else { + // Not a match, so rewind + _extends(state, tokenStates.pop()); + + break; + } + } else { + break; + } + } + + return node; + } + /** + * Unary plus and minus, and logical and bitwise not + * @return {Node} node + * @private + */ + + + function parseUnary(state) { + var name, params, fn; + var operators = { + '-': 'unaryMinus', + '+': 'unaryPlus', + '~': 'bitNot', + 'not': 'not' + }; + + if (operators.hasOwnProperty(state.token)) { + fn = operators[state.token]; + name = state.token; + getTokenSkipNewline(state); + params = [parseUnary(state)]; + return new OperatorNode(name, fn, params); + } + + return parsePow(state); + } + /** + * power + * Note: power operator is right associative + * @return {Node} node + * @private + */ + + + function parsePow(state) { + var node, name, fn, params; + node = parseLeftHandOperators(state); + + if (state.token === '^' || state.token === '.^') { + name = state.token; + fn = name === '^' ? 'pow' : 'dotPow'; + getTokenSkipNewline(state); + params = [node, parseUnary(state)]; // Go back to unary, we can have '2^-3' + + node = new OperatorNode(name, fn, params); + } + + return node; + } + /** + * Left hand operators: factorial x!, ctranspose x' + * @return {Node} node + * @private + */ + + + function parseLeftHandOperators(state) { + var node, operators, name, fn, params; + node = parseCustomNodes(state); + operators = { + '!': 'factorial', + '\'': 'ctranspose' + }; + + while (operators.hasOwnProperty(state.token)) { + name = state.token; + fn = operators[name]; + getToken(state); + params = [node]; + node = new OperatorNode(name, fn, params); + node = parseAccessors(state, node); + } + + return node; + } + /** + * Parse a custom node handler. A node handler can be used to process + * nodes in a custom way, for example for handling a plot. + * + * A handler must be passed as second argument of the parse function. + * - must extend math.expression.node.Node + * - must contain a function _compile(defs: Object) : string + * - must contain a function find(filter: Object) : Node[] + * - must contain a function toString() : string + * - the constructor is called with a single argument containing all parameters + * + * For example: + * + * nodes = { + * 'plot': PlotHandler + * } + * + * The constructor of the handler is called as: + * + * node = new PlotHandler(params) + * + * The handler will be invoked when evaluating an expression like: + * + * node = math.parse('plot(sin(x), x)', nodes) + * + * @return {Node} node + * @private + */ + + + function parseCustomNodes(state) { + var params = []; + + if (state.tokenType === TOKENTYPE.SYMBOL && state.extraNodes.hasOwnProperty(state.token)) { + var CustomNode = state.extraNodes[state.token]; + getToken(state); // parse parameters + + if (state.token === '(') { + params = []; + openParams(state); + getToken(state); + + if (state.token !== ')') { + params.push(parseAssignment(state)); // parse a list with parameters + + while (state.token === ',') { + // eslint-disable-line no-unmodified-loop-condition + getToken(state); + params.push(parseAssignment(state)); + } + } + + if (state.token !== ')') { + throw createSyntaxError(state, 'Parenthesis ) expected'); + } + + closeParams(state); + getToken(state); + } // create a new custom node + // noinspection JSValidateTypes + + + return new CustomNode(params); + } + + return parseSymbol(state); + } + /** + * parse symbols: functions, variables, constants, units + * @return {Node} node + * @private + */ + + + function parseSymbol(state) { + var node, name; + + if (state.tokenType === TOKENTYPE.SYMBOL || state.tokenType === TOKENTYPE.DELIMITER && state.token in NAMED_DELIMITERS) { + name = state.token; + getToken(state); + + if (CONSTANTS.hasOwnProperty(name)) { + // true, false, null, ... + node = new ConstantNode(CONSTANTS[name]); + } else if (NUMERIC_CONSTANTS.indexOf(name) !== -1) { + // NaN, Infinity + node = new ConstantNode(numeric(name, 'number')); + } else { + node = new SymbolNode(name); + } // parse function parameters and matrix index + + + node = parseAccessors(state, node); + return node; + } + + return parseDoubleQuotesString(state); + } + /** + * parse accessors: + * - function invocation in round brackets (...), for example sqrt(2) + * - index enclosed in square brackets [...], for example A[2,3] + * - dot notation for properties, like foo.bar + * @param {Node} node Node on which to apply the parameters. If there + * are no parameters in the expression, the node + * itself is returned + * @param {string[]} [types] Filter the types of notations + * can be ['(', '[', '.'] + * @return {Node} node + * @private + */ + + + function parseAccessors(state, node, types) { + var params; + + while ((state.token === '(' || state.token === '[' || state.token === '.') && (!types || types.indexOf(state.token) !== -1)) { + // eslint-disable-line no-unmodified-loop-condition + params = []; + + if (state.token === '(') { + if (type.isSymbolNode(node) || type.isAccessorNode(node)) { + // function invocation like fn(2, 3) or obj.fn(2, 3) + openParams(state); + getToken(state); + + if (state.token !== ')') { + params.push(parseAssignment(state)); // parse a list with parameters + + while (state.token === ',') { + // eslint-disable-line no-unmodified-loop-condition + getToken(state); + params.push(parseAssignment(state)); + } + } + + if (state.token !== ')') { + throw createSyntaxError(state, 'Parenthesis ) expected'); + } + + closeParams(state); + getToken(state); + node = new FunctionNode(node, params); + } else { + // implicit multiplication like (2+3)(4+5) or sqrt(2)(1+2) + // don't parse it here but let it be handled by parseImplicitMultiplication + // with correct precedence + return node; + } + } else if (state.token === '[') { + // index notation like variable[2, 3] + openParams(state); + getToken(state); + + if (state.token !== ']') { + params.push(parseAssignment(state)); // parse a list with parameters + + while (state.token === ',') { + // eslint-disable-line no-unmodified-loop-condition + getToken(state); + params.push(parseAssignment(state)); + } + } + + if (state.token !== ']') { + throw createSyntaxError(state, 'Parenthesis ] expected'); + } + + closeParams(state); + getToken(state); + node = new AccessorNode(node, new IndexNode(params)); + } else { + // dot notation like variable.prop + getToken(state); + + if (state.tokenType !== TOKENTYPE.SYMBOL) { + throw createSyntaxError(state, 'Property name expected after dot'); + } + + params.push(new ConstantNode(state.token)); + getToken(state); + var dotNotation = true; + node = new AccessorNode(node, new IndexNode(params, dotNotation)); + } + } + + return node; + } + /** + * Parse a double quotes string. + * @return {Node} node + * @private + */ + + + function parseDoubleQuotesString(state) { + var node, str; + + if (state.token === '"') { + str = parseDoubleQuotesStringToken(state); // create constant + + node = new ConstantNode(str); // parse index parameters + + node = parseAccessors(state, node); + return node; + } + + return parseSingleQuotesString(state); + } + /** + * Parse a string surrounded by double quotes "..." + * @return {string} + */ + + + function parseDoubleQuotesStringToken(state) { + var str = ''; + + while (currentCharacter(state) !== '' && currentCharacter(state) !== '"') { + if (currentCharacter(state) === '\\') { + // escape character, immediately process the next + // character to prevent stopping at a next '\"' + str += currentCharacter(state); + next(state); + } + + str += currentCharacter(state); + next(state); + } + + getToken(state); + + if (state.token !== '"') { + throw createSyntaxError(state, 'End of string " expected'); + } + + getToken(state); + return JSON.parse('"' + str + '"'); // unescape escaped characters + } + /** + * Parse a single quotes string. + * @return {Node} node + * @private + */ + + + function parseSingleQuotesString(state) { + var node, str; + + if (state.token === '\'') { + str = parseSingleQuotesStringToken(state); // create constant + + node = new ConstantNode(str); // parse index parameters + + node = parseAccessors(state, node); + return node; + } + + return parseMatrix(state); + } + /** + * Parse a string surrounded by single quotes '...' + * @return {string} + */ + + + function parseSingleQuotesStringToken(state) { + var str = ''; + + while (currentCharacter(state) !== '' && currentCharacter(state) !== '\'') { + if (currentCharacter(state) === '\\') { + // escape character, immediately process the next + // character to prevent stopping at a next '\'' + str += currentCharacter(state); + next(state); + } + + str += currentCharacter(state); + next(state); + } + + getToken(state); + + if (state.token !== '\'') { + throw createSyntaxError(state, 'End of string \' expected'); + } + + getToken(state); + return JSON.parse('"' + str + '"'); // unescape escaped characters + } + /** + * parse the matrix + * @return {Node} node + * @private + */ + + + function parseMatrix(state) { + var array, params, rows, cols; + + if (state.token === '[') { + // matrix [...] + openParams(state); + getToken(state); + + if (state.token !== ']') { + // this is a non-empty matrix + var row = parseRow(state); + + if (state.token === ';') { + // 2 dimensional array + rows = 1; + params = [row]; // the rows of the matrix are separated by dot-comma's + + while (state.token === ';') { + // eslint-disable-line no-unmodified-loop-condition + getToken(state); + params[rows] = parseRow(state); + rows++; + } + + if (state.token !== ']') { + throw createSyntaxError(state, 'End of matrix ] expected'); + } + + closeParams(state); + getToken(state); // check if the number of columns matches in all rows + + cols = params[0].items.length; + + for (var r = 1; r < rows; r++) { + if (params[r].items.length !== cols) { + throw createError(state, 'Column dimensions mismatch ' + '(' + params[r].items.length + ' !== ' + cols + ')'); + } + } + + array = new ArrayNode(params); + } else { + // 1 dimensional vector + if (state.token !== ']') { + throw createSyntaxError(state, 'End of matrix ] expected'); + } + + closeParams(state); + getToken(state); + array = row; + } + } else { + // this is an empty matrix "[ ]" + closeParams(state); + getToken(state); + array = new ArrayNode([]); + } + + return parseAccessors(state, array); + } + + return parseObject(state); + } + /** + * Parse a single comma-separated row from a matrix, like 'a, b, c' + * @return {ArrayNode} node + */ + + + function parseRow(state) { + var params = [parseAssignment(state)]; + var len = 1; + + while (state.token === ',') { + // eslint-disable-line no-unmodified-loop-condition + getToken(state); // parse expression + + params[len] = parseAssignment(state); + len++; + } + + return new ArrayNode(params); + } + /** + * parse an object, enclosed in angle brackets{...}, for example {value: 2} + * @return {Node} node + * @private + */ + + + function parseObject(state) { + if (state.token === '{') { + var key; + var properties = {}; + + do { + getToken(state); + + if (state.token !== '}') { + // parse key + if (state.token === '"') { + key = parseDoubleQuotesStringToken(state); + } else if (state.token === '\'') { + key = parseSingleQuotesStringToken(state); + } else if (state.tokenType === TOKENTYPE.SYMBOL) { + key = state.token; + getToken(state); + } else { + throw createSyntaxError(state, 'Symbol or string expected as object key'); + } // parse key/value separator + + + if (state.token !== ':') { + throw createSyntaxError(state, 'Colon : expected after object key'); + } + + getToken(state); // parse key + + properties[key] = parseAssignment(state); + } + } while (state.token === ','); // eslint-disable-line no-unmodified-loop-condition + + + if (state.token !== '}') { + throw createSyntaxError(state, 'Comma , or bracket } expected after object value'); + } + + getToken(state); + var node = new ObjectNode(properties); // parse index parameters + + node = parseAccessors(state, node); + return node; + } + + return parseNumber(state); + } + /** + * parse a number + * @return {Node} node + * @private + */ + + + function parseNumber(state) { + var numberStr; + + if (state.tokenType === TOKENTYPE.NUMBER) { + // this is a number + numberStr = state.token; + getToken(state); + return new ConstantNode(numeric(numberStr, config.number)); + } + + return parseParentheses(state); + } + /** + * parentheses + * @return {Node} node + * @private + */ + + + function parseParentheses(state) { + var node; // check if it is a parenthesized expression + + if (state.token === '(') { + // parentheses (...) + openParams(state); + getToken(state); + node = parseAssignment(state); // start again + + if (state.token !== ')') { + throw createSyntaxError(state, 'Parenthesis ) expected'); + } + + closeParams(state); + getToken(state); + node = new ParenthesisNode(node); + node = parseAccessors(state, node); + return node; + } + + return parseEnd(state); + } + /** + * Evaluated when the expression is not yet ended but expected to end + * @return {Node} res + * @private + */ + + + function parseEnd(state) { + if (state.token === '') { + // syntax error or unexpected end of expression + throw createSyntaxError(state, 'Unexpected end of expression'); + } else { + throw createSyntaxError(state, 'Value expected'); + } + } + /** + * Shortcut for getting the current row value (one based) + * Returns the line of the currently handled expression + * @private + */ + + /* TODO: implement keeping track on the row number + function row () { + return null + } + */ + + /** + * Shortcut for getting the current col value (one based) + * Returns the column (position) where the last state.token starts + * @private + */ + + + function col(state) { + return state.index - state.token.length + 1; + } + /** + * Create an error + * @param {string} message + * @return {SyntaxError} instantiated error + * @private + */ + + + function createSyntaxError(state, message) { + var c = col(state); + var error = new SyntaxError(message + ' (char ' + c + ')'); + error['char'] = c; + return error; + } + /** + * Create an error + * @param {string} message + * @return {Error} instantiated error + * @private + */ + + + function createError(state, message) { + var c = col(state); + var error = new SyntaxError(message + ' (char ' + c + ')'); + error['char'] = c; + return error; + } + + return parse; +} + +exports.name = 'parse'; +exports.path = 'expression'; +exports.factory = factory; +},{"../error/ArgumentsError":8,"../type/numeric":44,"../utils/collection/deepMap":49,"./node/AccessorNode":15,"./node/ArrayNode":16,"./node/AssignmentNode":17,"./node/BlockNode":18,"./node/ConditionalNode":19,"./node/ConstantNode":20,"./node/FunctionAssignmentNode":21,"./node/FunctionNode":22,"./node/IndexNode":23,"./node/ObjectNode":25,"./node/OperatorNode":26,"./node/ParenthesisNode":27,"./node/RangeNode":28,"./node/RelationalNode":29,"./node/SymbolNode":30}],35:[function(require,module,exports){ +'use strict'; + +var IndexError = require('../../error/IndexError'); +/** + * Transform zero-based indices to one-based indices in errors + * @param {Error} err + * @returns {Error} Returns the transformed error + */ + + +exports.transform = function (err) { + if (err && err.isIndexError) { + return new IndexError(err.index + 1, err.min + 1, err.max !== undefined ? err.max + 1 : undefined); + } + + return err; +}; +},{"../../error/IndexError":10}],36:[function(require,module,exports){ +'use strict'; + +var clone = require('../../utils/object').clone; + +var validateIndex = require('../../utils/array').validateIndex; + +var getSafeProperty = require('../../utils/customs').getSafeProperty; + +var setSafeProperty = require('../../utils/customs').setSafeProperty; + +var DimensionError = require('../../error/DimensionError'); + +function factory(type, config, load, typed) { + var matrix = load(require('../../type/matrix/function/matrix')); + /** + * Get or set a subset of a matrix or string. + * + * Syntax: + * math.subset(value, index) // retrieve a subset + * math.subset(value, index, replacement [, defaultValue]) // replace a subset + * + * Examples: + * + * // get a subset + * const d = [[1, 2], [3, 4]] + * math.subset(d, math.index(1, 0)) // returns 3 + * math.subset(d, math.index([0, 1], 1)) // returns [[2], [4]] + * + * // replace a subset + * const e = [] + * const f = math.subset(e, math.index(0, [0, 2]), [5, 6]) // f = [[5, 6]] + * const g = math.subset(f, math.index(1, 1), 7, 0) // g = [[5, 6], [0, 7]] + * + * See also: + * + * size, resize, squeeze, index + * + * @param {Array | Matrix | string} matrix An array, matrix, or string + * @param {Index} index An index containing ranges for each + * dimension + * @param {*} [replacement] An array, matrix, or scalar. + * If provided, the subset is replaced with replacement. + * If not provided, the subset is returned + * @param {*} [defaultValue=undefined] Default value, filled in on new entries when + * the matrix is resized. If not provided, + * math.matrix elements will be left undefined. + * @return {Array | Matrix | string} Either the retrieved subset or the updated matrix. + */ + + var subset = typed('subset', { + // get subset + 'Array, Index': function ArrayIndex(value, index) { + var m = matrix(value); + var subset = m.subset(index); // returns a Matrix + + return index.isScalar() ? subset : subset.valueOf(); // return an Array (like the input) + }, + 'Matrix, Index': function MatrixIndex(value, index) { + return value.subset(index); + }, + 'Object, Index': _getObjectProperty, + 'string, Index': _getSubstring, + // set subset + 'Array, Index, any': function ArrayIndexAny(value, index, replacement) { + return matrix(clone(value)).subset(index, replacement, undefined).valueOf(); + }, + 'Array, Index, any, any': function ArrayIndexAnyAny(value, index, replacement, defaultValue) { + return matrix(clone(value)).subset(index, replacement, defaultValue).valueOf(); + }, + 'Matrix, Index, any': function MatrixIndexAny(value, index, replacement) { + return value.clone().subset(index, replacement); + }, + 'Matrix, Index, any, any': function MatrixIndexAnyAny(value, index, replacement, defaultValue) { + return value.clone().subset(index, replacement, defaultValue); + }, + 'string, Index, string': _setSubstring, + 'string, Index, string, string': _setSubstring, + 'Object, Index, any': _setObjectProperty + }); + subset.toTex = undefined; // use default template + + return subset; + /** + * Retrieve a subset of a string + * @param {string} str string from which to get a substring + * @param {Index} index An index containing ranges for each dimension + * @returns {string} substring + * @private + */ + + function _getSubstring(str, index) { + if (!type.isIndex(index)) { + // TODO: better error message + throw new TypeError('Index expected'); + } + + if (index.size().length !== 1) { + throw new DimensionError(index.size().length, 1); + } // validate whether the range is out of range + + + var strLen = str.length; + validateIndex(index.min()[0], strLen); + validateIndex(index.max()[0], strLen); + var range = index.dimension(0); + var substr = ''; + range.forEach(function (v) { + substr += str.charAt(v); + }); + return substr; + } + /** + * Replace a substring in a string + * @param {string} str string to be replaced + * @param {Index} index An index containing ranges for each dimension + * @param {string} replacement Replacement string + * @param {string} [defaultValue] Default value to be uses when resizing + * the string. is ' ' by default + * @returns {string} result + * @private + */ + + + function _setSubstring(str, index, replacement, defaultValue) { + if (!index || index.isIndex !== true) { + // TODO: better error message + throw new TypeError('Index expected'); + } + + if (index.size().length !== 1) { + throw new DimensionError(index.size().length, 1); + } + + if (defaultValue !== undefined) { + if (typeof defaultValue !== 'string' || defaultValue.length !== 1) { + throw new TypeError('Single character expected as defaultValue'); + } + } else { + defaultValue = ' '; + } + + var range = index.dimension(0); + var len = range.size()[0]; + + if (len !== replacement.length) { + throw new DimensionError(range.size()[0], replacement.length); + } // validate whether the range is out of range + + + var strLen = str.length; + validateIndex(index.min()[0]); + validateIndex(index.max()[0]); // copy the string into an array with characters + + var chars = []; + + for (var i = 0; i < strLen; i++) { + chars[i] = str.charAt(i); + } + + range.forEach(function (v, i) { + chars[v] = replacement.charAt(i[0]); + }); // initialize undefined characters with a space + + if (chars.length > strLen) { + for (var _i = strLen - 1, _len = chars.length; _i < _len; _i++) { + if (!chars[_i]) { + chars[_i] = defaultValue; + } + } + } + + return chars.join(''); + } +} +/** + * Retrieve a property from an object + * @param {Object} object + * @param {Index} index + * @return {*} Returns the value of the property + * @private + */ + + +function _getObjectProperty(object, index) { + if (index.size().length !== 1) { + throw new DimensionError(index.size(), 1); + } + + var key = index.dimension(0); + + if (typeof key !== 'string') { + throw new TypeError('String expected as index to retrieve an object property'); + } + + return getSafeProperty(object, key); +} +/** + * Set a property on an object + * @param {Object} object + * @param {Index} index + * @param {*} replacement + * @return {*} Returns the updated object + * @private + */ + + +function _setObjectProperty(object, index, replacement) { + if (index.size().length !== 1) { + throw new DimensionError(index.size(), 1); + } + + var key = index.dimension(0); + + if (typeof key !== 'string') { + throw new TypeError('String expected as index to retrieve an object property'); + } // clone the object, and apply the property to the clone + + + var updated = clone(object); + setSafeProperty(updated, key, replacement); + return updated; +} + +exports.name = 'subset'; +exports.factory = factory; +},{"../../error/DimensionError":9,"../../type/matrix/function/matrix":42,"../../utils/array":46,"../../utils/customs":51,"../../utils/object":55}],37:[function(require,module,exports){ +'use strict'; + +var string = require('../../utils/string'); + +function factory(type, config, load, typed) { + /** + * Format a value of any type into a string. + * + * Syntax: + * + * math.format(value) + * math.format(value, options) + * math.format(value, precision) + * math.format(value, callback) + * + * Where: + * + * - `value: *` + * The value to be formatted + * - `options: Object` + * An object with formatting options. Available options: + * - `notation: string` + * Number notation. Choose from: + * - 'fixed' + * Always use regular number notation. + * For example '123.40' and '14000000' + * - 'exponential' + * Always use exponential notation. + * For example '1.234e+2' and '1.4e+7' + * - 'engineering' + * Always use engineering notation. + * For example '123.4e+0' and '14.0e+6' + * - 'auto' (default) + * Regular number notation for numbers having an absolute value between + * `lower` and `upper` bounds, and uses exponential notation elsewhere. + * Lower bound is included, upper bound is excluded. + * For example '123.4' and '1.4e7'. + * - `precision: number` + * A number between 0 and 16 to round the digits of the number. In case + * of notations 'exponential', 'engineering', and 'auto', `precision` + * defines the total number of significant digits returned. + * In case of notation 'fixed', `precision` defines the number of + * significant digits after the decimal point. + * `precision` is undefined by default. + * - `lowerExp: number` + * Exponent determining the lower boundary for formatting a value with + * an exponent when `notation='auto`. Default value is `-3`. + * - `upperExp: number` + * Exponent determining the upper boundary for formatting a value with + * an exponent when `notation='auto`. Default value is `5`. + * - `fraction: string`. Available values: 'ratio' (default) or 'decimal'. + * For example `format(fraction(1, 3))` will output '1/3' when 'ratio' is + * configured, and will output `0.(3)` when 'decimal' is configured. + * - `callback: function` + * A custom formatting function, invoked for all numeric elements in `value`, + * for example all elements of a matrix, or the real and imaginary + * parts of a complex number. This callback can be used to override the + * built-in numeric notation with any type of formatting. Function `callback` + * is called with `value` as parameter and must return a string. + * + * When `value` is an Object: + * + * - When the object contains a property `format` being a function, this function + * is invoked as `value.format(options)` and the result is returned. + * - When the object has its own `toString` method, this method is invoked + * and the result is returned. + * - In other cases the function will loop over all object properties and + * return JSON object notation like '{"a": 2, "b": 3}'. + * + * When value is a function: + * + * - When the function has a property `syntax`, it returns this + * syntax description. + * - In other cases, a string `'function'` is returned. + * + * Examples: + * + * math.format(6.4) // returns '6.4' + * math.format(1240000) // returns '1.24e6' + * math.format(1/3) // returns '0.3333333333333333' + * math.format(1/3, 3) // returns '0.333' + * math.format(21385, 2) // returns '21000' + * math.format(12e8, {notation: 'fixed'}) // returns '1200000000' + * math.format(2.3, {notation: 'fixed', precision: 4}) // returns '2.3000' + * math.format(52.8, {notation: 'exponential'}) // returns '5.28e+1' + * math.format(12400,{notation: 'engineering'}) // returns '12.400e+3' + * math.format(2000, {lowerExp: -2, upperExp: 2}) // returns '2e+3' + * + * function formatCurrency(value) { + * // return currency notation with two digits: + * return '$' + value.toFixed(2) + * + * // you could also use math.format inside the callback: + * // return '$' + math.format(value, {notation: 'fixed', precision: 2}) + * } + * math.format([2.1, 3, 0.016], formatCurrency} // returns '[$2.10, $3.00, $0.02]' + * + * See also: + * + * print + * + * @param {*} value Value to be stringified + * @param {Object | Function | number} [options] Formatting options + * @return {string} The formatted value + */ + var format = typed('format', { + 'any': string.format, + 'any, Object | function | number': string.format + }); + format.toTex = undefined; // use default template + + return format; +} + +exports.name = 'format'; +exports.factory = factory; +},{"../../utils/string":57}],38:[function(require,module,exports){ +'use strict'; + +function _typeof2(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof2 = function _typeof2(obj) { return typeof obj; }; } else { _typeof2 = function _typeof2(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof2(obj); } + +function factory(type, config, load, typed) { + /** + * Determine the type of a variable. + * + * Function `typeof` recognizes the following types of objects: + * + * Object | Returns | Example + * ---------------------- | ------------- | ------------------------------------------ + * null | `'null'` | `math.typeof(null)` + * number | `'number'` | `math.typeof(3.5)` + * boolean | `'boolean'` | `math.typeof(true)` + * string | `'string'` | `math.typeof('hello world')` + * Array | `'Array'` | `math.typeof([1, 2, 3])` + * Date | `'Date'` | `math.typeof(new Date())` + * Function | `'Function'` | `math.typeof(function () {})` + * Object | `'Object'` | `math.typeof({a: 2, b: 3})` + * RegExp | `'RegExp'` | `math.typeof(/a regexp/)` + * undefined | `'undefined'` | `math.typeof(undefined)` + * math.type.BigNumber | `'BigNumber'` | `math.typeof(math.bignumber('2.3e500'))` + * math.type.Chain | `'Chain'` | `math.typeof(math.chain(2))` + * math.type.Complex | `'Complex'` | `math.typeof(math.complex(2, 3))` + * math.type.Fraction | `'Fraction'` | `math.typeof(math.fraction(1, 3))` + * math.type.Help | `'Help'` | `math.typeof(math.help('sqrt'))` + * math.type.Help | `'Help'` | `math.typeof(math.help('sqrt'))` + * math.type.Index | `'Index'` | `math.typeof(math.index(1, 3))` + * math.type.Matrix | `'Matrix'` | `math.typeof(math.matrix([[1,2], [3, 4]]))` + * math.type.Range | `'Range'` | `math.typeof(math.range(0, 10))` + * math.type.ResultSet | `'ResultSet'` | `math.typeof(math.eval('a=2\nb=3'))` + * math.type.Unit | `'Unit'` | `math.typeof(math.unit('45 deg'))` + * math.expression.node​.AccessorNode | `'AccessorNode'` | `math.typeof(math.parse('A[2]'))` + * math.expression.node​.ArrayNode | `'ArrayNode'` | `math.typeof(math.parse('[1,2,3]'))` + * math.expression.node​.AssignmentNode | `'AssignmentNode'` | `math.typeof(math.parse('x=2'))` + * math.expression.node​.BlockNode | `'BlockNode'` | `math.typeof(math.parse('a=2; b=3'))` + * math.expression.node​.ConditionalNode | `'ConditionalNode'` | `math.typeof(math.parse('x<0 ? -x : x'))` + * math.expression.node​.ConstantNode | `'ConstantNode'` | `math.typeof(math.parse('2.3'))` + * math.expression.node​.FunctionAssignmentNode | `'FunctionAssignmentNode'` | `math.typeof(math.parse('f(x)=x^2'))` + * math.expression.node​.FunctionNode | `'FunctionNode'` | `math.typeof(math.parse('sqrt(4)'))` + * math.expression.node​.IndexNode | `'IndexNode'` | `math.typeof(math.parse('A[2]').index)` + * math.expression.node​.ObjectNode | `'ObjectNode'` | `math.typeof(math.parse('{a:2}'))` + * math.expression.node​.ParenthesisNode | `'ParenthesisNode'` | `math.typeof(math.parse('(2+3)'))` + * math.expression.node​.RangeNode | `'RangeNode'` | `math.typeof(math.parse('1:10'))` + * math.expression.node​.SymbolNode | `'SymbolNode'` | `math.typeof(math.parse('x'))` + * + * Syntax: + * + * math.typeof(x) + * + * Examples: + * + * math.typeof(3.5) // returns 'number' + * math.typeof(math.complex('2-4i')) // returns 'Complex' + * math.typeof(math.unit('45 deg')) // returns 'Unit' + * math.typeof('hello world') // returns 'string' + * + * @param {*} x The variable for which to test the type. + * @return {string} Returns the name of the type. Primitive types are lower case, + * non-primitive types are upper-camel-case. + * For example 'number', 'string', 'Array', 'Date'. + */ + var _typeof = typed('_typeof', { + 'any': function any(x) { + var t = _typeof2(x); + + if (t === 'object') { + // JavaScript types + if (x === null) return 'null'; + if (Array.isArray(x)) return 'Array'; + if (x instanceof Date) return 'Date'; + if (x instanceof RegExp) return 'RegExp'; // math.js types + + if (type.isBigNumber(x)) return 'BigNumber'; + if (type.isComplex(x)) return 'Complex'; + if (type.isFraction(x)) return 'Fraction'; + if (type.isMatrix(x)) return 'Matrix'; + if (type.isUnit(x)) return 'Unit'; + if (type.isIndex(x)) return 'Index'; + if (type.isRange(x)) return 'Range'; + if (type.isResultSet(x)) return 'ResultSet'; + if (type.isNode(x)) return x.type; + if (type.isChain(x)) return 'Chain'; + if (type.isHelp(x)) return 'Help'; + return 'Object'; + } + + if (t === 'function') return 'Function'; + return t; // can be 'string', 'number', 'boolean', ... + } + }); + + _typeof.toTex = undefined; // use default template + + return _typeof; +} + +exports.name = 'typeof'; +exports.factory = factory; +},{}],39:[function(require,module,exports){ +'use strict'; + +var deepMap = require('../../../utils/collection/deepMap'); + +function factory(type, config, load, typed) { + /** + * Create a BigNumber, which can store numbers with arbitrary precision. + * When a matrix is provided, all elements will be converted to BigNumber. + * + * Syntax: + * + * math.bignumber(x) + * + * Examples: + * + * 0.1 + 0.2 // returns number 0.30000000000000004 + * math.bignumber(0.1) + math.bignumber(0.2) // returns BigNumber 0.3 + * + * + * 7.2e500 // returns number Infinity + * math.bignumber('7.2e500') // returns BigNumber 7.2e500 + * + * See also: + * + * boolean, complex, index, matrix, string, unit + * + * @param {number | string | Fraction | BigNumber | Array | Matrix | boolean | null} [value] Value for the big number, + * 0 by default. + * @returns {BigNumber} The created bignumber + */ + var bignumber = typed('bignumber', { + '': function _() { + return new type.BigNumber(0); + }, + 'number': function number(x) { + // convert to string to prevent errors in case of >15 digits + return new type.BigNumber(x + ''); + }, + 'string': function string(x) { + return new type.BigNumber(x); + }, + 'BigNumber': function BigNumber(x) { + // we assume a BigNumber is immutable + return x; + }, + 'Fraction': function Fraction(x) { + return new type.BigNumber(x.n).div(x.d).times(x.s); + }, + 'null': function _null(x) { + return new type.BigNumber(0); + }, + 'Array | Matrix': function ArrayMatrix(x) { + return deepMap(x, bignumber); + } + }); + bignumber.toTex = { + 0: '0', + 1: "\\left(${args[0]}\\right)" + }; + return bignumber; +} + +exports.name = 'bignumber'; +exports.factory = factory; +},{"../../../utils/collection/deepMap":49}],40:[function(require,module,exports){ +'use strict'; + +var deepMap = require('../../../utils/collection/deepMap'); + +function factory(type, config, load, typed) { + /** + * Create a fraction convert a value to a fraction. + * + * Syntax: + * math.fraction(numerator, denominator) + * math.fraction({n: numerator, d: denominator}) + * math.fraction(matrix: Array | Matrix) Turn all matrix entries + * into fractions + * + * Examples: + * + * math.fraction(1, 3) + * math.fraction('2/3') + * math.fraction({n: 2, d: 3}) + * math.fraction([0.2, 0.25, 1.25]) + * + * See also: + * + * bignumber, number, string, unit + * + * @param {number | string | Fraction | BigNumber | Array | Matrix} [args] + * Arguments specifying the numerator and denominator of + * the fraction + * @return {Fraction | Array | Matrix} Returns a fraction + */ + var fraction = typed('fraction', { + 'number': function number(x) { + if (!isFinite(x) || isNaN(x)) { + throw new Error(x + ' cannot be represented as a fraction'); + } + + return new type.Fraction(x); + }, + 'string': function string(x) { + return new type.Fraction(x); + }, + 'number, number': function numberNumber(numerator, denominator) { + return new type.Fraction(numerator, denominator); + }, + 'null': function _null(x) { + return new type.Fraction(0); + }, + 'BigNumber': function BigNumber(x) { + return new type.Fraction(x.toString()); + }, + 'Fraction': function Fraction(x) { + return x; // fractions are immutable + }, + 'Object': function Object(x) { + return new type.Fraction(x); + }, + 'Array | Matrix': function ArrayMatrix(x) { + return deepMap(x, fraction); + } + }); + return fraction; +} + +exports.name = 'fraction'; +exports.factory = factory; +},{"../../../utils/collection/deepMap":49}],41:[function(require,module,exports){ +'use strict'; + +var number = require('../../utils/number'); + +function factory(type, config, load, typed) { + /** + * Create a range. A range has a start, step, and end, and contains functions + * to iterate over the range. + * + * A range can be constructed as: + * + * const range = new Range(start, end) + * const range = new Range(start, end, step) + * + * To get the result of the range: + * range.forEach(function (x) { + * console.log(x) + * }) + * range.map(function (x) { + * return math.sin(x) + * }) + * range.toArray() + * + * Example usage: + * + * const c = new Range(2, 6) // 2:1:5 + * c.toArray() // [2, 3, 4, 5] + * const d = new Range(2, -3, -1) // 2:-1:-2 + * d.toArray() // [2, 1, 0, -1, -2] + * + * @class Range + * @constructor Range + * @param {number} start included lower bound + * @param {number} end excluded upper bound + * @param {number} [step] step size, default value is 1 + */ + function Range(start, end, step) { + if (!(this instanceof Range)) { + throw new SyntaxError('Constructor must be called with the new operator'); + } + + var hasStart = start !== null && start !== undefined; + var hasEnd = end !== null && end !== undefined; + var hasStep = step !== null && step !== undefined; + + if (hasStart) { + if (type.isBigNumber(start)) { + start = start.toNumber(); + } else if (typeof start !== 'number') { + throw new TypeError('Parameter start must be a number'); + } + } + + if (hasEnd) { + if (type.isBigNumber(end)) { + end = end.toNumber(); + } else if (typeof end !== 'number') { + throw new TypeError('Parameter end must be a number'); + } + } + + if (hasStep) { + if (type.isBigNumber(step)) { + step = step.toNumber(); + } else if (typeof step !== 'number') { + throw new TypeError('Parameter step must be a number'); + } + } + + this.start = hasStart ? parseFloat(start) : 0; + this.end = hasEnd ? parseFloat(end) : 0; + this.step = hasStep ? parseFloat(step) : 1; + } + /** + * Attach type information + */ + + + Range.prototype.type = 'Range'; + Range.prototype.isRange = true; + /** + * Parse a string into a range, + * The string contains the start, optional step, and end, separated by a colon. + * If the string does not contain a valid range, null is returned. + * For example str='0:2:11'. + * @memberof Range + * @param {string} str + * @return {Range | null} range + */ + + Range.parse = function (str) { + if (typeof str !== 'string') { + return null; + } + + var args = str.split(':'); + var nums = args.map(function (arg) { + return parseFloat(arg); + }); + var invalid = nums.some(function (num) { + return isNaN(num); + }); + + if (invalid) { + return null; + } + + switch (nums.length) { + case 2: + return new Range(nums[0], nums[1]); + + case 3: + return new Range(nums[0], nums[2], nums[1]); + + default: + return null; + } + }; + /** + * Create a clone of the range + * @return {Range} clone + */ + + + Range.prototype.clone = function () { + return new Range(this.start, this.end, this.step); + }; + /** + * Retrieve the size of the range. + * Returns an array containing one number, the number of elements in the range. + * @memberof Range + * @returns {number[]} size + */ + + + Range.prototype.size = function () { + var len = 0; + var start = this.start; + var step = this.step; + var end = this.end; + var diff = end - start; + + if (number.sign(step) === number.sign(diff)) { + len = Math.ceil(diff / step); + } else if (diff === 0) { + len = 0; + } + + if (isNaN(len)) { + len = 0; + } + + return [len]; + }; + /** + * Calculate the minimum value in the range + * @memberof Range + * @return {number | undefined} min + */ + + + Range.prototype.min = function () { + var size = this.size()[0]; + + if (size > 0) { + if (this.step > 0) { + // positive step + return this.start; + } else { + // negative step + return this.start + (size - 1) * this.step; + } + } else { + return undefined; + } + }; + /** + * Calculate the maximum value in the range + * @memberof Range + * @return {number | undefined} max + */ + + + Range.prototype.max = function () { + var size = this.size()[0]; + + if (size > 0) { + if (this.step > 0) { + // positive step + return this.start + (size - 1) * this.step; + } else { + // negative step + return this.start; + } + } else { + return undefined; + } + }; + /** + * Execute a callback function for each value in the range. + * @memberof Range + * @param {function} callback The callback method is invoked with three + * parameters: the value of the element, the index + * of the element, and the Range being traversed. + */ + + + Range.prototype.forEach = function (callback) { + var x = this.start; + var step = this.step; + var end = this.end; + var i = 0; + + if (step > 0) { + while (x < end) { + callback(x, [i], this); + x += step; + i++; + } + } else if (step < 0) { + while (x > end) { + callback(x, [i], this); + x += step; + i++; + } + } + }; + /** + * Execute a callback function for each value in the Range, and return the + * results as an array + * @memberof Range + * @param {function} callback The callback method is invoked with three + * parameters: the value of the element, the index + * of the element, and the Matrix being traversed. + * @returns {Array} array + */ + + + Range.prototype.map = function (callback) { + var array = []; + this.forEach(function (value, index, obj) { + array[index[0]] = callback(value, index, obj); + }); + return array; + }; + /** + * Create an Array with a copy of the Ranges data + * @memberof Range + * @returns {Array} array + */ + + + Range.prototype.toArray = function () { + var array = []; + this.forEach(function (value, index) { + array[index[0]] = value; + }); + return array; + }; + /** + * Get the primitive value of the Range, a one dimensional array + * @memberof Range + * @returns {Array} array + */ + + + Range.prototype.valueOf = function () { + // TODO: implement a caching mechanism for range.valueOf() + return this.toArray(); + }; + /** + * Get a string representation of the range, with optional formatting options. + * Output is formatted as 'start:step:end', for example '2:6' or '0:0.2:11' + * @memberof Range + * @param {Object | number | function} [options] Formatting options. See + * lib/utils/number:format for a + * description of the available + * options. + * @returns {string} str + */ + + + Range.prototype.format = function (options) { + var str = number.format(this.start, options); + + if (this.step !== 1) { + str += ':' + number.format(this.step, options); + } + + str += ':' + number.format(this.end, options); + return str; + }; + /** + * Get a string representation of the range. + * @memberof Range + * @returns {string} + */ + + + Range.prototype.toString = function () { + return this.format(); + }; + /** + * Get a JSON representation of the range + * @memberof Range + * @returns {Object} Returns a JSON object structured as: + * `{"mathjs": "Range", "start": 2, "end": 4, "step": 1}` + */ + + + Range.prototype.toJSON = function () { + return { + mathjs: 'Range', + start: this.start, + end: this.end, + step: this.step + }; + }; + /** + * Instantiate a Range from a JSON object + * @memberof Range + * @param {Object} json A JSON object structured as: + * `{"mathjs": "Range", "start": 2, "end": 4, "step": 1}` + * @return {Range} + */ + + + Range.fromJSON = function (json) { + return new Range(json.start, json.end, json.step); + }; + + return Range; +} + +exports.name = 'Range'; +exports.path = 'type'; +exports.factory = factory; +},{"../../utils/number":54}],42:[function(require,module,exports){ +'use strict'; + +function factory(type, config, load, typed) { + /** + * Create a Matrix. The function creates a new `math.type.Matrix` object from + * an `Array`. A Matrix has utility functions to manipulate the data in the + * matrix, like getting the size and getting or setting values in the matrix. + * Supported storage formats are 'dense' and 'sparse'. + * + * Syntax: + * + * math.matrix() // creates an empty matrix using default storage format (dense). + * math.matrix(data) // creates a matrix with initial data using default storage format (dense). + * math.matrix('dense') // creates an empty matrix using the given storage format. + * math.matrix(data, 'dense') // creates a matrix with initial data using the given storage format. + * math.matrix(data, 'sparse') // creates a sparse matrix with initial data. + * math.matrix(data, 'sparse', 'number') // creates a sparse matrix with initial data, number data type. + * + * Examples: + * + * let m = math.matrix([[1, 2], [3, 4]]) + * m.size() // Array [2, 2] + * m.resize([3, 2], 5) + * m.valueOf() // Array [[1, 2], [3, 4], [5, 5]] + * m.get([1, 0]) // number 3 + * + * See also: + * + * bignumber, boolean, complex, index, number, string, unit, sparse + * + * @param {Array | Matrix} [data] A multi dimensional array + * @param {string} [format] The Matrix storage format + * + * @return {Matrix} The created matrix + */ + var matrix = typed('matrix', { + '': function _() { + return _create([]); + }, + 'string': function string(format) { + return _create([], format); + }, + 'string, string': function stringString(format, datatype) { + return _create([], format, datatype); + }, + 'Array': function Array(data) { + return _create(data); + }, + 'Matrix': function Matrix(data) { + return _create(data, data.storage()); + }, + 'Array | Matrix, string': _create, + 'Array | Matrix, string, string': _create + }); + matrix.toTex = { + 0: '\\begin{bmatrix}\\end{bmatrix}', + 1: "\\left(${args[0]}\\right)", + 2: "\\left(${args[0]}\\right)" + }; + return matrix; + /** + * Create a new Matrix with given storage format + * @param {Array} data + * @param {string} [format] + * @param {string} [datatype] + * @returns {Matrix} Returns a new Matrix + * @private + */ + + function _create(data, format, datatype) { + // get storage format constructor + var M = type.Matrix.storage(format || 'default'); // create instance + + return new M(data, datatype); + } +} + +exports.name = 'matrix'; +exports.factory = factory; +},{}],43:[function(require,module,exports){ +'use strict'; + +var deepMap = require('./../utils/collection/deepMap'); + +function factory(type, config, load, typed) { + /** + * Create a number or convert a string, boolean, or unit to a number. + * When value is a matrix, all elements will be converted to number. + * + * Syntax: + * + * math.number(value) + * math.number(unit, valuelessUnit) + * + * Examples: + * + * math.number(2) // returns number 2 + * math.number('7.2') // returns number 7.2 + * math.number(true) // returns number 1 + * math.number([true, false, true, true]) // returns [1, 0, 1, 1] + * math.number(math.unit('52cm'), 'm') // returns 0.52 + * + * See also: + * + * bignumber, boolean, complex, index, matrix, string, unit + * + * @param {string | number | BigNumber | Fraction | boolean | Array | Matrix | Unit | null} [value] Value to be converted + * @param {Unit | string} [valuelessUnit] A valueless unit, used to convert a unit to a number + * @return {number | Array | Matrix} The created number + */ + var number = typed('number', { + '': function _() { + return 0; + }, + 'number': function number(x) { + return x; + }, + 'string': function string(x) { + if (x === 'NaN') return NaN; + var num = Number(x); + + if (isNaN(num)) { + throw new SyntaxError('String "' + x + '" is no valid number'); + } + + return num; + }, + 'BigNumber': function BigNumber(x) { + return x.toNumber(); + }, + 'Fraction': function Fraction(x) { + return x.valueOf(); + }, + 'Unit': function Unit(x) { + throw new Error('Second argument with valueless unit expected'); + }, + 'null': function _null(x) { + return 0; + }, + 'Unit, string | Unit': function UnitStringUnit(unit, valuelessUnit) { + return unit.toNumber(valuelessUnit); + }, + 'Array | Matrix': function ArrayMatrix(x) { + return deepMap(x, number); + } + }); + number.toTex = { + 0: "0", + 1: "\\left(${args[0]}\\right)", + 2: "\\left(\\left(${args[0]}\\right)${args[1]}\\right)" + }; + return number; +} + +exports.name = 'number'; +exports.factory = factory; +},{"./../utils/collection/deepMap":49}],44:[function(require,module,exports){ +'use strict'; + +function factory(type, config, load, typed) { + var getTypeOf = load(require('../function/utils/typeof')); + var validInputTypes = { + 'string': true, + 'number': true, + 'BigNumber': true, + 'Fraction': true // Load the conversion functions for each output type + + }; + var validOutputTypes = { + 'number': load(require('./number')), + 'BigNumber': load(require('./bignumber/function/bignumber')), + 'Fraction': load(require('./fraction/function/fraction')) + /** + * Convert a numeric value to a specific type: number, BigNumber, or Fraction + * + * @param {string | number | BigNumber | Fraction } value + * @param {'number' | 'BigNumber' | 'Fraction'} outputType + * @return {number | BigNumber | Fraction} Returns an instance of the + * numeric in the requested type + */ + + }; + + var numeric = function numeric(value, outputType) { + var inputType = getTypeOf(value); + + if (!(inputType in validInputTypes)) { + throw new TypeError('Cannot convert ' + value + ' of type "' + inputType + '"; valid input types are ' + Object.keys(validInputTypes).join(', ')); + } + + if (!(outputType in validOutputTypes)) { + throw new TypeError('Cannot convert ' + value + ' to type "' + outputType + '"; valid output types are ' + Object.keys(validOutputTypes).join(', ')); + } + + if (outputType === inputType) { + return value; + } else { + return validOutputTypes[outputType](value); + } + }; + + numeric.toTex = function (node, options) { + // Not sure if this is strictly right but should work correctly for the vast majority of use cases. + return node.args[0].toTex(); + }; + + return numeric; +} // FIXME: expose numeric in the math namespace after we've decided on a name and have written proper docs for this function. See https://github.com/josdejong/mathjs/pull/1270 +// exports.name = 'type._numeric' + + +exports.path = 'type'; +exports.name = '_numeric'; +exports.factory = factory; +},{"../function/utils/typeof":38,"./bignumber/function/bignumber":39,"./fraction/function/fraction":40,"./number":43}],45:[function(require,module,exports){ +'use strict'; + +function factory(type, config, load, typed) { + /** + * A ResultSet contains a list or results + * @class ResultSet + * @param {Array} entries + * @constructor ResultSet + */ + function ResultSet(entries) { + if (!(this instanceof ResultSet)) { + throw new SyntaxError('Constructor must be called with the new operator'); + } + + this.entries = entries || []; + } + /** + * Attach type information + */ + + + ResultSet.prototype.type = 'ResultSet'; + ResultSet.prototype.isResultSet = true; + /** + * Returns the array with results hold by this ResultSet + * @memberof ResultSet + * @returns {Array} entries + */ + + ResultSet.prototype.valueOf = function () { + return this.entries; + }; + /** + * Returns the stringified results of the ResultSet + * @memberof ResultSet + * @returns {string} string + */ + + + ResultSet.prototype.toString = function () { + return '[' + this.entries.join(', ') + ']'; + }; + /** + * Get a JSON representation of the ResultSet + * @memberof ResultSet + * @returns {Object} Returns a JSON object structured as: + * `{"mathjs": "ResultSet", "entries": [...]}` + */ + + + ResultSet.prototype.toJSON = function () { + return { + mathjs: 'ResultSet', + entries: this.entries + }; + }; + /** + * Instantiate a ResultSet from a JSON object + * @memberof ResultSet + * @param {Object} json A JSON object structured as: + * `{"mathjs": "ResultSet", "entries": [...]}` + * @return {ResultSet} + */ + + + ResultSet.fromJSON = function (json) { + return new ResultSet(json.entries); + }; + + return ResultSet; +} + +exports.name = 'ResultSet'; +exports.path = 'type'; +exports.factory = factory; +},{}],46:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.size = size; +exports.validate = validate; +exports.validateIndex = validateIndex; +exports.resize = resize; +exports.reshape = reshape; +exports.squeeze = squeeze; +exports.unsqueeze = unsqueeze; +exports.flatten = flatten; +exports.map = map; +exports.forEach = forEach; +exports.filter = filter; +exports.filterRegExp = filterRegExp; +exports.join = join; +exports.identify = identify; +exports.generalize = generalize; + +var _number = _interopRequireDefault(require("./number")); + +var _string = _interopRequireDefault(require("./string")); + +var _DimensionError = _interopRequireDefault(require("../error/DimensionError")); + +var _IndexError = _interopRequireDefault(require("../error/IndexError")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +/** + * Calculate the size of a multi dimensional array. + * This function checks the size of the first entry, it does not validate + * whether all dimensions match. (use function `validate` for that) + * @param {Array} x + * @Return {Number[]} size + */ +function size(x) { + var s = []; + + while (Array.isArray(x)) { + s.push(x.length); + x = x[0]; + } + + return s; +} +/** + * Recursively validate whether each element in a multi dimensional array + * has a size corresponding to the provided size array. + * @param {Array} array Array to be validated + * @param {number[]} size Array with the size of each dimension + * @param {number} dim Current dimension + * @throws DimensionError + * @private + */ + + +function _validate(array, size, dim) { + var i; + var len = array.length; + + if (len !== size[dim]) { + throw new _DimensionError.default(len, size[dim]); + } + + if (dim < size.length - 1) { + // recursively validate each child array + var dimNext = dim + 1; + + for (i = 0; i < len; i++) { + var child = array[i]; + + if (!Array.isArray(child)) { + throw new _DimensionError.default(size.length - 1, size.length, '<'); + } + + _validate(array[i], size, dimNext); + } + } else { + // last dimension. none of the childs may be an array + for (i = 0; i < len; i++) { + if (Array.isArray(array[i])) { + throw new _DimensionError.default(size.length + 1, size.length, '>'); + } + } + } +} +/** + * Validate whether each element in a multi dimensional array has + * a size corresponding to the provided size array. + * @param {Array} array Array to be validated + * @param {number[]} size Array with the size of each dimension + * @throws DimensionError + */ + + +function validate(array, size) { + var isScalar = size.length === 0; + + if (isScalar) { + // scalar + if (Array.isArray(array)) { + throw new _DimensionError.default(array.length, 0); + } + } else { + // array + _validate(array, size, 0); + } +} +/** + * Test whether index is an integer number with index >= 0 and index < length + * when length is provided + * @param {number} index Zero-based index + * @param {number} [length] Length of the array + */ + + +function validateIndex(index, length) { + if (!_number.default.isNumber(index) || !_number.default.isInteger(index)) { + throw new TypeError('Index must be an integer (value: ' + index + ')'); + } + + if (index < 0 || typeof length === 'number' && index >= length) { + throw new _IndexError.default(index, length); + } +} +/** + * Resize a multi dimensional array. The resized array is returned. + * @param {Array} array Array to be resized + * @param {Array.<number>} size Array with the size of each dimension + * @param {*} [defaultValue=0] Value to be filled in in new entries, + * zero by default. Specify for example `null`, + * to clearly see entries that are not explicitly + * set. + * @return {Array} array The resized array + */ + + +function resize(array, size, defaultValue) { + // TODO: add support for scalars, having size=[] ? + // check the type of the arguments + if (!Array.isArray(array) || !Array.isArray(size)) { + throw new TypeError('Array expected'); + } + + if (size.length === 0) { + throw new Error('Resizing to scalar is not supported'); + } // check whether size contains positive integers + + + size.forEach(function (value) { + if (!_number.default.isNumber(value) || !_number.default.isInteger(value) || value < 0) { + throw new TypeError('Invalid size, must contain positive integers ' + '(size: ' + _string.default.format(size) + ')'); + } + }); // recursively resize the array + + var _defaultValue = defaultValue !== undefined ? defaultValue : 0; + + _resize(array, size, 0, _defaultValue); + + return array; +} +/** + * Recursively resize a multi dimensional array + * @param {Array} array Array to be resized + * @param {number[]} size Array with the size of each dimension + * @param {number} dim Current dimension + * @param {*} [defaultValue] Value to be filled in in new entries, + * undefined by default. + * @private + */ + + +function _resize(array, size, dim, defaultValue) { + var i; + var elem; + var oldLen = array.length; + var newLen = size[dim]; + var minLen = Math.min(oldLen, newLen); // apply new length + + array.length = newLen; + + if (dim < size.length - 1) { + // non-last dimension + var dimNext = dim + 1; // resize existing child arrays + + for (i = 0; i < minLen; i++) { + // resize child array + elem = array[i]; + + if (!Array.isArray(elem)) { + elem = [elem]; // add a dimension + + array[i] = elem; + } + + _resize(elem, size, dimNext, defaultValue); + } // create new child arrays + + + for (i = minLen; i < newLen; i++) { + // get child array + elem = []; + array[i] = elem; // resize new child array + + _resize(elem, size, dimNext, defaultValue); + } + } else { + // last dimension + // remove dimensions of existing values + for (i = 0; i < minLen; i++) { + while (Array.isArray(array[i])) { + array[i] = array[i][0]; + } + } // fill new elements with the default value + + + for (i = minLen; i < newLen; i++) { + array[i] = defaultValue; + } + } +} +/** + * Re-shape a multi dimensional array to fit the specified dimensions + * @param {Array} array Array to be reshaped + * @param {Array.<number>} sizes List of sizes for each dimension + * @returns {Array} Array whose data has been formatted to fit the + * specified dimensions + * + * @throws {DimensionError} If the product of the new dimension sizes does + * not equal that of the old ones + */ + + +function reshape(array, sizes) { + var flatArray = flatten(array); + var newArray; + + function product(arr) { + return arr.reduce(function (prev, curr) { + return prev * curr; + }); + } + + if (!Array.isArray(array) || !Array.isArray(sizes)) { + throw new TypeError('Array expected'); + } + + if (sizes.length === 0) { + throw new _DimensionError.default(0, product(size(array)), '!='); + } + + var totalSize = 1; + + for (var sizeIndex = 0; sizeIndex < sizes.length; sizeIndex++) { + totalSize *= sizes[sizeIndex]; + } + + if (flatArray.length !== totalSize) { + throw new _DimensionError.default(product(sizes), product(size(array)), '!='); + } + + try { + newArray = _reshape(flatArray, sizes); + } catch (e) { + if (e instanceof _DimensionError.default) { + throw new _DimensionError.default(product(sizes), product(size(array)), '!='); + } + + throw e; + } + + return newArray; +} +/** + * Iteratively re-shape a multi dimensional array to fit the specified dimensions + * @param {Array} array Array to be reshaped + * @param {Array.<number>} sizes List of sizes for each dimension + * @returns {Array} Array whose data has been formatted to fit the + * specified dimensions + */ + + +function _reshape(array, sizes) { + // testing if there are enough elements for the requested shape + var tmpArray = array; + var tmpArray2; // for each dimensions starting by the last one and ignoring the first one + + for (var sizeIndex = sizes.length - 1; sizeIndex > 0; sizeIndex--) { + var size = sizes[sizeIndex]; + tmpArray2 = []; // aggregate the elements of the current tmpArray in elements of the requested size + + var length = tmpArray.length / size; + + for (var i = 0; i < length; i++) { + tmpArray2.push(tmpArray.slice(i * size, (i + 1) * size)); + } // set it as the new tmpArray for the next loop turn or for return + + + tmpArray = tmpArray2; + } + + return tmpArray; +} +/** + * Squeeze a multi dimensional array + * @param {Array} array + * @param {Array} [arraySize] + * @returns {Array} returns the array itself + */ + + +function squeeze(array, arraySize) { + var s = arraySize || size(array); // squeeze outer dimensions + + while (Array.isArray(array) && array.length === 1) { + array = array[0]; + s.shift(); + } // find the first dimension to be squeezed + + + var dims = s.length; + + while (s[dims - 1] === 1) { + dims--; + } // squeeze inner dimensions + + + if (dims < s.length) { + array = _squeeze(array, dims, 0); + s.length = dims; + } + + return array; +} +/** + * Recursively squeeze a multi dimensional array + * @param {Array} array + * @param {number} dims Required number of dimensions + * @param {number} dim Current dimension + * @returns {Array | *} Returns the squeezed array + * @private + */ + + +function _squeeze(array, dims, dim) { + var i, ii; + + if (dim < dims) { + var next = dim + 1; + + for (i = 0, ii = array.length; i < ii; i++) { + array[i] = _squeeze(array[i], dims, next); + } + } else { + while (Array.isArray(array)) { + array = array[0]; + } + } + + return array; +} +/** + * Unsqueeze a multi dimensional array: add dimensions when missing + * + * Paramter `size` will be mutated to match the new, unqueezed matrix size. + * + * @param {Array} array + * @param {number} dims Desired number of dimensions of the array + * @param {number} [outer] Number of outer dimensions to be added + * @param {Array} [arraySize] Current size of array. + * @returns {Array} returns the array itself + * @private + */ + + +function unsqueeze(array, dims, outer, arraySize) { + var s = arraySize || size(array); // unsqueeze outer dimensions + + if (outer) { + for (var i = 0; i < outer; i++) { + array = [array]; + s.unshift(1); + } + } // unsqueeze inner dimensions + + + array = _unsqueeze(array, dims, 0); + + while (s.length < dims) { + s.push(1); + } + + return array; +} +/** + * Recursively unsqueeze a multi dimensional array + * @param {Array} array + * @param {number} dims Required number of dimensions + * @param {number} dim Current dimension + * @returns {Array | *} Returns the squeezed array + * @private + */ + + +function _unsqueeze(array, dims, dim) { + var i, ii; + + if (Array.isArray(array)) { + var next = dim + 1; + + for (i = 0, ii = array.length; i < ii; i++) { + array[i] = _unsqueeze(array[i], dims, next); + } + } else { + for (var d = dim; d < dims; d++) { + array = [array]; + } + } + + return array; +} +/** + * Flatten a multi dimensional array, put all elements in a one dimensional + * array + * @param {Array} array A multi dimensional array + * @return {Array} The flattened array (1 dimensional) + */ + + +function flatten(array) { + if (!Array.isArray(array)) { + // if not an array, return as is + return array; + } + + var flat = []; + array.forEach(function callback(value) { + if (Array.isArray(value)) { + value.forEach(callback); // traverse through sub-arrays recursively + } else { + flat.push(value); + } + }); + return flat; +} +/** + * A safe map + * @param {Array} array + * @param {function} callback + */ + + +function map(array, callback) { + return Array.prototype.map.call(array, callback); +} +/** + * A safe forEach + * @param {Array} array + * @param {function} callback + */ + + +function forEach(array, callback) { + Array.prototype.forEach.call(array, callback); +} +/** + * A safe filter + * @param {Array} array + * @param {function} callback + */ + + +function filter(array, callback) { + if (size(array).length !== 1) { + throw new Error('Only one dimensional matrices supported'); + } + + return Array.prototype.filter.call(array, callback); +} +/** + * Filter values in a callback given a regular expression + * @param {Array} array + * @param {RegExp} regexp + * @return {Array} Returns the filtered array + * @private + */ + + +function filterRegExp(array, regexp) { + if (size(array).length !== 1) { + throw new Error('Only one dimensional matrices supported'); + } + + return Array.prototype.filter.call(array, function (entry) { + return regexp.test(entry); + }); +} +/** + * A safe join + * @param {Array} array + * @param {string} separator + */ + + +function join(array, separator) { + return Array.prototype.join.call(array, separator); +} +/** + * Assign a numeric identifier to every element of a sorted array + * @param {Array} a An array + * @return {Array} An array of objects containing the original value and its identifier + */ + + +function identify(a) { + if (!Array.isArray(a)) { + throw new TypeError('Array input expected'); + } + + if (a.length === 0) { + return a; + } + + var b = []; + var count = 0; + b[0] = { + value: a[0], + identifier: 0 + }; + + for (var i = 1; i < a.length; i++) { + if (a[i] === a[i - 1]) { + count++; + } else { + count = 0; + } + + b.push({ + value: a[i], + identifier: count + }); + } + + return b; +} +/** + * Remove the numeric identifier from the elements + * @param {array} a An array + * @return {array} An array of values without identifiers + */ + + +function generalize(a) { + if (!Array.isArray(a)) { + throw new TypeError('Array input expected'); + } + + if (a.length === 0) { + return a; + } + + var b = []; + + for (var i = 0; i < a.length; i++) { + b.push(a[i].value); + } + + return b; +} +},{"../error/DimensionError":9,"../error/IndexError":10,"./number":54,"./string":57}],47:[function(require,module,exports){ +'use strict'; + +var objectUtils = require('../object'); +/** + * Convert a BigNumber to a formatted string representation. + * + * Syntax: + * + * format(value) + * format(value, options) + * format(value, precision) + * format(value, fn) + * + * Where: + * + * {number} value The value to be formatted + * {Object} options An object with formatting options. Available options: + * {string} notation + * Number notation. Choose from: + * 'fixed' Always use regular number notation. + * For example '123.40' and '14000000' + * 'exponential' Always use exponential notation. + * For example '1.234e+2' and '1.4e+7' + * 'auto' (default) Regular number notation for numbers + * having an absolute value between + * `lower` and `upper` bounds, and uses + * exponential notation elsewhere. + * Lower bound is included, upper bound + * is excluded. + * For example '123.4' and '1.4e7'. + * {number} precision A number between 0 and 16 to round + * the digits of the number. + * In case of notations 'exponential', + * 'engineering', and 'auto', + * `precision` defines the total + * number of significant digits returned. + * In case of notation 'fixed', + * `precision` defines the number of + * significant digits after the decimal + * point. + * `precision` is undefined by default. + * {number} lowerExp Exponent determining the lower boundary + * for formatting a value with an exponent + * when `notation='auto`. + * Default value is `-3`. + * {number} upperExp Exponent determining the upper boundary + * for formatting a value with an exponent + * when `notation='auto`. + * Default value is `5`. + * {Function} fn A custom formatting function. Can be used to override the + * built-in notations. Function `fn` is called with `value` as + * parameter and must return a string. Is useful for example to + * format all values inside a matrix in a particular way. + * + * Examples: + * + * format(6.4) // '6.4' + * format(1240000) // '1.24e6' + * format(1/3) // '0.3333333333333333' + * format(1/3, 3) // '0.333' + * format(21385, 2) // '21000' + * format(12e8, {notation: 'fixed'}) // returns '1200000000' + * format(2.3, {notation: 'fixed', precision: 4}) // returns '2.3000' + * format(52.8, {notation: 'exponential'}) // returns '5.28e+1' + * format(12400, {notation: 'engineering'}) // returns '12.400e+3' + * + * @param {BigNumber} value + * @param {Object | Function | number} [options] + * @return {string} str The formatted value + */ + + +exports.format = function (value, options) { + if (typeof options === 'function') { + // handle format(value, fn) + return options(value); + } // handle special cases + + + if (!value.isFinite()) { + return value.isNaN() ? 'NaN' : value.gt(0) ? 'Infinity' : '-Infinity'; + } // default values for options + + + var notation = 'auto'; + var precision; + + if (options !== undefined) { + // determine notation from options + if (options.notation) { + notation = options.notation; + } // determine precision from options + + + if (typeof options === 'number') { + precision = options; + } else if (options.precision) { + precision = options.precision; + } + } // handle the various notations + + + switch (notation) { + case 'fixed': + return exports.toFixed(value, precision); + + case 'exponential': + return exports.toExponential(value, precision); + + case 'auto': + // TODO: clean up some day. Deprecated since: 2018-01-24 + // @deprecated upper and lower are replaced with upperExp and lowerExp since v4.0.0 + if (options && options.exponential && (options.exponential.lower !== undefined || options.exponential.upper !== undefined)) { + var fixedOptions = objectUtils.map(options, function (x) { + return x; + }); + fixedOptions.exponential = undefined; + + if (options.exponential.lower !== undefined) { + fixedOptions.lowerExp = Math.round(Math.log(options.exponential.lower) / Math.LN10); + } + + if (options.exponential.upper !== undefined) { + fixedOptions.upperExp = Math.round(Math.log(options.exponential.upper) / Math.LN10); + } + + console.warn('Deprecation warning: Formatting options exponential.lower and exponential.upper ' + '(minimum and maximum value) ' + 'are replaced with exponential.lowerExp and exponential.upperExp ' + '(minimum and maximum exponent) since version 4.0.0. ' + 'Replace ' + JSON.stringify(options) + ' with ' + JSON.stringify(fixedOptions)); + return exports.format(value, fixedOptions); + } // determine lower and upper bound for exponential notation. + // TODO: implement support for upper and lower to be BigNumbers themselves + + + var lowerExp = options && options.lowerExp !== undefined ? options.lowerExp : -3; + var upperExp = options && options.upperExp !== undefined ? options.upperExp : 5; // handle special case zero + + if (value.isZero()) return '0'; // determine whether or not to output exponential notation + + var str; + var exp = value.logarithm(); + + if (exp.gte(lowerExp) && exp.lt(upperExp)) { + // normal number notation + str = value.toSignificantDigits(precision).toFixed(); + } else { + // exponential notation + str = exports.toExponential(value, precision); + } // remove trailing zeros after the decimal point + + + return str.replace(/((\.\d*?)(0+))($|e)/, function () { + var digits = arguments[2]; + var e = arguments[4]; + return digits !== '.' ? digits + e : e; + }); + + default: + throw new Error('Unknown notation "' + notation + '". ' + 'Choose "auto", "exponential", or "fixed".'); + } +}; +/** + * Format a number in exponential notation. Like '1.23e+5', '2.3e+0', '3.500e-3' + * @param {BigNumber} value + * @param {number} [precision] Number of digits in formatted output. + * If not provided, the maximum available digits + * is used. + * @returns {string} str + */ + + +exports.toExponential = function (value, precision) { + if (precision !== undefined) { + return value.toExponential(precision - 1); // Note the offset of one + } else { + return value.toExponential(); + } +}; +/** + * Format a number with fixed notation. + * @param {BigNumber} value + * @param {number} [precision=undefined] Optional number of decimals after the + * decimal point. Undefined by default. + */ + + +exports.toFixed = function (value, precision) { + return value.toFixed(precision); +}; +},{"../object":55}],48:[function(require,module,exports){ +'use strict'; +/** + * Test whether a value is a BigNumber + * @param {*} x + * @return {boolean} + */ + +module.exports = function isBigNumber(x) { + return x && x.constructor.prototype.isBigNumber || false; +}; +},{}],49:[function(require,module,exports){ +'use strict'; +/** + * Execute the callback function element wise for each element in array and any + * nested array + * Returns an array with the results + * @param {Array | Matrix} array + * @param {Function} callback The callback is called with two parameters: + * value1 and value2, which contain the current + * element of both arrays. + * @param {boolean} [skipZeros] Invoke callback function for non-zero values only. + * + * @return {Array | Matrix} res + */ + +module.exports = function deepMap(array, callback, skipZeros) { + if (array && typeof array.map === 'function') { + // TODO: replace array.map with a for loop to improve performance + return array.map(function (x) { + return deepMap(x, callback, skipZeros); + }); + } else { + return callback(array); + } +}; +},{}],50:[function(require,module,exports){ +'use strict'; +/** + * Test whether a value is a Matrix + * @param {*} x + * @returns {boolean} returns true with input is a Matrix + * (like a DenseMatrix or SparseMatrix) + */ + +module.exports = function isMatrix(x) { + return x && x.constructor.prototype.isMatrix || false; +}; +},{}],51:[function(require,module,exports){ +'use strict'; + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +var hasOwnProperty = require('./object').hasOwnProperty; +/** + * Get a property of a plain object + * Throws an error in case the object is not a plain object or the + * property is not defined on the object itself + * @param {Object} object + * @param {string} prop + * @return {*} Returns the property value when safe + */ + + +function getSafeProperty(object, prop) { + // only allow getting safe properties of a plain object + if (isPlainObject(object) && isSafeProperty(object, prop)) { + return object[prop]; + } + + if (typeof object[prop] === 'function' && isSafeMethod(object, prop)) { + throw new Error('Cannot access method "' + prop + '" as a property'); + } + + throw new Error('No access to property "' + prop + '"'); +} +/** + * Set a property on a plain object. + * Throws an error in case the object is not a plain object or the + * property would override an inherited property like .constructor or .toString + * @param {Object} object + * @param {string} prop + * @param {*} value + * @return {*} Returns the value + */ +// TODO: merge this function into access.js? + + +function setSafeProperty(object, prop, value) { + // only allow setting safe properties of a plain object + if (isPlainObject(object) && isSafeProperty(object, prop)) { + object[prop] = value; + return value; + } + + throw new Error('No access to property "' + prop + '"'); +} +/** + * Test whether a property is safe to use for an object. + * For example .toString and .constructor are not safe + * @param {string} prop + * @return {boolean} Returns true when safe + */ + + +function isSafeProperty(object, prop) { + if (!object || _typeof(object) !== 'object') { + return false; + } // SAFE: whitelisted + // e.g length + + + if (hasOwnProperty(safeNativeProperties, prop)) { + return true; + } // UNSAFE: inherited from Object prototype + // e.g constructor + + + if (prop in Object.prototype) { + // 'in' is used instead of hasOwnProperty for nodejs v0.10 + // which is inconsistent on root prototypes. It is safe + // here because Object.prototype is a root object + return false; + } // UNSAFE: inherited from Function prototype + // e.g call, apply + + + if (prop in Function.prototype) { + // 'in' is used instead of hasOwnProperty for nodejs v0.10 + // which is inconsistent on root prototypes. It is safe + // here because Function.prototype is a root object + return false; + } + + return true; +} +/** + * Validate whether a method is safe. + * Throws an error when that's not the case. + * @param {Object} object + * @param {string} method + */ +// TODO: merge this function into assign.js? + + +function validateSafeMethod(object, method) { + if (!isSafeMethod(object, method)) { + throw new Error('No access to method "' + method + '"'); + } +} +/** + * Check whether a method is safe. + * Throws an error when that's not the case (for example for `constructor`). + * @param {Object} object + * @param {string} method + * @return {boolean} Returns true when safe, false otherwise + */ + + +function isSafeMethod(object, method) { + if (!object || typeof object[method] !== 'function') { + return false; + } // UNSAFE: ghosted + // e.g overridden toString + // Note that IE10 doesn't support __proto__ and we can't do this check there. + + + if (hasOwnProperty(object, method) && Object.getPrototypeOf && method in Object.getPrototypeOf(object)) { + return false; + } // SAFE: whitelisted + // e.g toString + + + if (hasOwnProperty(safeNativeMethods, method)) { + return true; + } // UNSAFE: inherited from Object prototype + // e.g constructor + + + if (method in Object.prototype) { + // 'in' is used instead of hasOwnProperty for nodejs v0.10 + // which is inconsistent on root prototypes. It is safe + // here because Object.prototype is a root object + return false; + } // UNSAFE: inherited from Function prototype + // e.g call, apply + + + if (method in Function.prototype) { + // 'in' is used instead of hasOwnProperty for nodejs v0.10 + // which is inconsistent on root prototypes. It is safe + // here because Function.prototype is a root object + return false; + } + + return true; +} + +function isPlainObject(object) { + return _typeof(object) === 'object' && object && object.constructor === Object; +} + +var safeNativeProperties = { + length: true, + name: true +}; +var safeNativeMethods = { + toString: true, + valueOf: true, + toLocaleString: true +}; +exports.getSafeProperty = getSafeProperty; +exports.setSafeProperty = setSafeProperty; +exports.isSafeProperty = isSafeProperty; +exports.validateSafeMethod = validateSafeMethod; +exports.isSafeMethod = isSafeMethod; +exports.isPlainObject = isPlainObject; +},{"./object":55}],52:[function(require,module,exports){ +'use strict'; + +var Emitter = require('tiny-emitter'); +/** + * Extend given object with emitter functions `on`, `off`, `once`, `emit` + * @param {Object} obj + * @return {Object} obj + */ + + +exports.mixin = function (obj) { + // create event emitter + var emitter = new Emitter(); // bind methods to obj (we don't want to expose the emitter.e Array...) + + obj.on = emitter.on.bind(emitter); + obj.off = emitter.off.bind(emitter); + obj.once = emitter.once.bind(emitter); + obj.emit = emitter.emit.bind(emitter); + return obj; +}; +},{"tiny-emitter":58}],53:[function(require,module,exports){ +'use strict'; + +var escapeLatex = require('escape-latex'); + +exports.symbols = { + // GREEK LETTERS + Alpha: 'A', + alpha: '\\alpha', + Beta: 'B', + beta: '\\beta', + Gamma: '\\Gamma', + gamma: '\\gamma', + Delta: '\\Delta', + delta: '\\delta', + Epsilon: 'E', + epsilon: '\\epsilon', + varepsilon: '\\varepsilon', + Zeta: 'Z', + zeta: '\\zeta', + Eta: 'H', + eta: '\\eta', + Theta: '\\Theta', + theta: '\\theta', + vartheta: '\\vartheta', + Iota: 'I', + iota: '\\iota', + Kappa: 'K', + kappa: '\\kappa', + varkappa: '\\varkappa', + Lambda: '\\Lambda', + lambda: '\\lambda', + Mu: 'M', + mu: '\\mu', + Nu: 'N', + nu: '\\nu', + Xi: '\\Xi', + xi: '\\xi', + Omicron: 'O', + omicron: 'o', + Pi: '\\Pi', + pi: '\\pi', + varpi: '\\varpi', + Rho: 'P', + rho: '\\rho', + varrho: '\\varrho', + Sigma: '\\Sigma', + sigma: '\\sigma', + varsigma: '\\varsigma', + Tau: 'T', + tau: '\\tau', + Upsilon: "\\Upsilon", + upsilon: "\\upsilon", + Phi: '\\Phi', + phi: '\\phi', + varphi: '\\varphi', + Chi: 'X', + chi: '\\chi', + Psi: '\\Psi', + psi: '\\psi', + Omega: '\\Omega', + omega: '\\omega', + // logic + 'true': '\\mathrm{True}', + 'false': '\\mathrm{False}', + // other + i: 'i', + // TODO use \i ?? + inf: '\\infty', + Inf: '\\infty', + infinity: '\\infty', + Infinity: '\\infty', + oo: '\\infty', + lim: '\\lim', + 'undefined': '\\mathbf{?}' +}; +exports.operators = { + 'transpose': '^\\top', + 'ctranspose': '^H', + 'factorial': '!', + 'pow': '^', + 'dotPow': '.^\\wedge', + // TODO find ideal solution + 'unaryPlus': '+', + 'unaryMinus': '-', + 'bitNot': '\\~', + // TODO find ideal solution + 'not': '\\neg', + 'multiply': '\\cdot', + 'divide': '\\frac', + // TODO how to handle that properly? + 'dotMultiply': '.\\cdot', + // TODO find ideal solution + 'dotDivide': '.:', + // TODO find ideal solution + 'mod': '\\mod', + 'add': '+', + 'subtract': '-', + 'to': '\\rightarrow', + 'leftShift': '<<', + 'rightArithShift': '>>', + 'rightLogShift': '>>>', + 'equal': '=', + 'unequal': '\\neq', + 'smaller': '<', + 'larger': '>', + 'smallerEq': '\\leq', + 'largerEq': '\\geq', + 'bitAnd': '\\&', + 'bitXor': "\\underline{|}", + 'bitOr': '|', + 'and': '\\wedge', + 'xor': '\\veebar', + 'or': '\\vee' +}; +exports.defaultTemplate = "\\mathrm{${name}}\\left(${args}\\right)"; +var units = { + deg: '^\\circ' +}; + +exports.escape = function (string) { + return escapeLatex(string, { + 'preserveFormatting': true + }); +}; // @param {string} name +// @param {boolean} isUnit + + +exports.toSymbol = function (name, isUnit) { + isUnit = typeof isUnit === 'undefined' ? false : isUnit; + + if (isUnit) { + if (units.hasOwnProperty(name)) { + return units[name]; + } + + return '\\mathrm{' + exports.escape(name) + '}'; + } + + if (exports.symbols.hasOwnProperty(name)) { + return exports.symbols[name]; + } + + return exports.escape(name); +}; +},{"escape-latex":2}],54:[function(require,module,exports){ +'use strict'; + +var objectUtils = require('./object'); +/** + * @typedef {{sign: '+' | '-' | '', coefficients: number[], exponent: number}} SplitValue + */ + +/** + * Test whether value is a number + * @param {*} value + * @return {boolean} isNumber + */ + + +exports.isNumber = function (value) { + return typeof value === 'number'; +}; +/** + * Check if a number is integer + * @param {number | boolean} value + * @return {boolean} isInteger + */ + + +exports.isInteger = function (value) { + if (typeof value === 'boolean') { + return true; + } + + return isFinite(value) ? value === Math.round(value) : false; // Note: we use ==, not ===, as we can have Booleans as well +}; +/** + * Calculate the sign of a number + * @param {number} x + * @returns {*} + */ + + +exports.sign = Math.sign || function (x) { + if (x > 0) { + return 1; + } else if (x < 0) { + return -1; + } else { + return 0; + } +}; +/** + * Convert a number to a formatted string representation. + * + * Syntax: + * + * format(value) + * format(value, options) + * format(value, precision) + * format(value, fn) + * + * Where: + * + * {number} value The value to be formatted + * {Object} options An object with formatting options. Available options: + * {string} notation + * Number notation. Choose from: + * 'fixed' Always use regular number notation. + * For example '123.40' and '14000000' + * 'exponential' Always use exponential notation. + * For example '1.234e+2' and '1.4e+7' + * 'engineering' Always use engineering notation. + * For example '123.4e+0' and '14.0e+6' + * 'auto' (default) Regular number notation for numbers + * having an absolute value between + * `lowerExp` and `upperExp` bounds, and + * uses exponential notation elsewhere. + * Lower bound is included, upper bound + * is excluded. + * For example '123.4' and '1.4e7'. + * {number} precision A number between 0 and 16 to round + * the digits of the number. + * In case of notations 'exponential', + * 'engineering', and 'auto', + * `precision` defines the total + * number of significant digits returned. + * In case of notation 'fixed', + * `precision` defines the number of + * significant digits after the decimal + * point. + * `precision` is undefined by default, + * not rounding any digits. + * {number} lowerExp Exponent determining the lower boundary + * for formatting a value with an exponent + * when `notation='auto`. + * Default value is `-3`. + * {number} upperExp Exponent determining the upper boundary + * for formatting a value with an exponent + * when `notation='auto`. + * Default value is `5`. + * {Function} fn A custom formatting function. Can be used to override the + * built-in notations. Function `fn` is called with `value` as + * parameter and must return a string. Is useful for example to + * format all values inside a matrix in a particular way. + * + * Examples: + * + * format(6.4) // '6.4' + * format(1240000) // '1.24e6' + * format(1/3) // '0.3333333333333333' + * format(1/3, 3) // '0.333' + * format(21385, 2) // '21000' + * format(12.071, {notation: 'fixed'}) // '12' + * format(2.3, {notation: 'fixed', precision: 2}) // '2.30' + * format(52.8, {notation: 'exponential'}) // '5.28e+1' + * format(12345678, {notation: 'engineering'}) // '12.345678e+6' + * + * @param {number} value + * @param {Object | Function | number} [options] + * @return {string} str The formatted value + */ + + +exports.format = function (value, options) { + if (typeof options === 'function') { + // handle format(value, fn) + return options(value); + } // handle special cases + + + if (value === Infinity) { + return 'Infinity'; + } else if (value === -Infinity) { + return '-Infinity'; + } else if (isNaN(value)) { + return 'NaN'; + } // default values for options + + + var notation = 'auto'; + var precision; + + if (options) { + // determine notation from options + if (options.notation) { + notation = options.notation; + } // determine precision from options + + + if (exports.isNumber(options)) { + precision = options; + } else if (options.precision) { + precision = options.precision; + } + } // handle the various notations + + + switch (notation) { + case 'fixed': + return exports.toFixed(value, precision); + + case 'exponential': + return exports.toExponential(value, precision); + + case 'engineering': + return exports.toEngineering(value, precision); + + case 'auto': + // TODO: clean up some day. Deprecated since: 2018-01-24 + // @deprecated upper and lower are replaced with upperExp and lowerExp since v4.0.0 + if (options && options.exponential && (options.exponential.lower !== undefined || options.exponential.upper !== undefined)) { + var fixedOptions = objectUtils.map(options, function (x) { + return x; + }); + fixedOptions.exponential = undefined; + + if (options.exponential.lower !== undefined) { + fixedOptions.lowerExp = Math.round(Math.log(options.exponential.lower) / Math.LN10); + } + + if (options.exponential.upper !== undefined) { + fixedOptions.upperExp = Math.round(Math.log(options.exponential.upper) / Math.LN10); + } + + console.warn('Deprecation warning: Formatting options exponential.lower and exponential.upper ' + '(minimum and maximum value) ' + 'are replaced with exponential.lowerExp and exponential.upperExp ' + '(minimum and maximum exponent) since version 4.0.0. ' + 'Replace ' + JSON.stringify(options) + ' with ' + JSON.stringify(fixedOptions)); + return exports.toPrecision(value, precision, fixedOptions); + } + + return exports.toPrecision(value, precision, options && options) // remove trailing zeros after the decimal point + .replace(/((\.\d*?)(0+))($|e)/, function () { + var digits = arguments[2]; + var e = arguments[4]; + return digits !== '.' ? digits + e : e; + }); + + default: + throw new Error('Unknown notation "' + notation + '". ' + 'Choose "auto", "exponential", or "fixed".'); + } +}; +/** + * Split a number into sign, coefficients, and exponent + * @param {number | string} value + * @return {SplitValue} + * Returns an object containing sign, coefficients, and exponent + */ + + +exports.splitNumber = function (value) { + // parse the input value + var match = String(value).toLowerCase().match(/^0*?(-?)(\d+\.?\d*)(e([+-]?\d+))?$/); + + if (!match) { + throw new SyntaxError('Invalid number ' + value); + } + + var sign = match[1]; + var digits = match[2]; + var exponent = parseFloat(match[4] || '0'); + var dot = digits.indexOf('.'); + exponent += dot !== -1 ? dot - 1 : digits.length - 1; + var coefficients = digits.replace('.', '') // remove the dot (must be removed before removing leading zeros) + .replace(/^0*/, function (zeros) { + // remove leading zeros, add their count to the exponent + exponent -= zeros.length; + return ''; + }).replace(/0*$/, '') // remove trailing zeros + .split('').map(function (d) { + return parseInt(d); + }); + + if (coefficients.length === 0) { + coefficients.push(0); + exponent++; + } + + return { + sign: sign, + coefficients: coefficients, + exponent: exponent + }; +}; +/** + * Format a number in engineering notation. Like '1.23e+6', '2.3e+0', '3.500e-3' + * @param {number | string} value + * @param {number} [precision] Optional number of significant figures to return. + */ + + +exports.toEngineering = function (value, precision) { + if (isNaN(value) || !isFinite(value)) { + return String(value); + } + + var rounded = exports.roundDigits(exports.splitNumber(value), precision); + var e = rounded.exponent; + var c = rounded.coefficients; // find nearest lower multiple of 3 for exponent + + var newExp = e % 3 === 0 ? e : e < 0 ? e - 3 - e % 3 : e - e % 3; + + if (exports.isNumber(precision)) { + // add zeroes to give correct sig figs + if (precision > c.length) c = c.concat(zeros(precision - c.length)); + } else { + // concatenate coefficients with necessary zeros + var significandsDiff = e >= 0 ? e : Math.abs(newExp); // add zeros if necessary (for ex: 1e+8) + + if (c.length - 1 < significandsDiff) c = c.concat(zeros(significandsDiff - (c.length - 1))); + } // find difference in exponents + + + var expDiff = Math.abs(e - newExp); + var decimalIdx = 1; // push decimal index over by expDiff times + + while (--expDiff >= 0) { + decimalIdx++; + } // if all coefficient values are zero after the decimal point and precision is unset, don't add a decimal value. + // otherwise concat with the rest of the coefficients + + + var decimals = c.slice(decimalIdx).join(''); + var decimalVal = exports.isNumber(precision) && decimals.length || decimals.match(/[1-9]/) ? '.' + decimals : ''; + var str = c.slice(0, decimalIdx).join('') + decimalVal + 'e' + (e >= 0 ? '+' : '') + newExp.toString(); + return rounded.sign + str; +}; +/** + * Format a number with fixed notation. + * @param {number | string} value + * @param {number} [precision=undefined] Optional number of decimals after the + * decimal point. null by default. + */ + + +exports.toFixed = function (value, precision) { + if (isNaN(value) || !isFinite(value)) { + return String(value); + } + + var splitValue = exports.splitNumber(value); + var rounded = typeof precision === 'number' ? exports.roundDigits(splitValue, splitValue.exponent + 1 + precision) : splitValue; + var c = rounded.coefficients; + var p = rounded.exponent + 1; // exponent may have changed + // append zeros if needed + + var pp = p + (precision || 0); + + if (c.length < pp) { + c = c.concat(zeros(pp - c.length)); + } // prepend zeros if needed + + + if (p < 0) { + c = zeros(-p + 1).concat(c); + p = 1; + } // insert a dot if needed + + + if (p < c.length) { + c.splice(p, 0, p === 0 ? '0.' : '.'); + } + + return rounded.sign + c.join(''); +}; +/** + * Format a number in exponential notation. Like '1.23e+5', '2.3e+0', '3.500e-3' + * @param {number | string} value + * @param {number} [precision] Number of digits in formatted output. + * If not provided, the maximum available digits + * is used. + */ + + +exports.toExponential = function (value, precision) { + if (isNaN(value) || !isFinite(value)) { + return String(value); + } // round if needed, else create a clone + + + var split = exports.splitNumber(value); + var rounded = precision ? exports.roundDigits(split, precision) : split; + var c = rounded.coefficients; + var e = rounded.exponent; // append zeros if needed + + if (c.length < precision) { + c = c.concat(zeros(precision - c.length)); + } // format as `C.CCCe+EEE` or `C.CCCe-EEE` + + + var first = c.shift(); + return rounded.sign + first + (c.length > 0 ? '.' + c.join('') : '') + 'e' + (e >= 0 ? '+' : '') + e; +}; +/** + * Format a number with a certain precision + * @param {number | string} value + * @param {number} [precision=undefined] Optional number of digits. + * @param {{lowerExp: number | undefined, upperExp: number | undefined}} [options] + * By default: + * lowerExp = -3 (incl) + * upper = +5 (excl) + * @return {string} + */ + + +exports.toPrecision = function (value, precision, options) { + if (isNaN(value) || !isFinite(value)) { + return String(value); + } // determine lower and upper bound for exponential notation. + + + var lowerExp = options && options.lowerExp !== undefined ? options.lowerExp : -3; + var upperExp = options && options.upperExp !== undefined ? options.upperExp : 5; + var split = exports.splitNumber(value); + + if (split.exponent < lowerExp || split.exponent >= upperExp) { + // exponential notation + return exports.toExponential(value, precision); + } else { + var rounded = precision ? exports.roundDigits(split, precision) : split; + var c = rounded.coefficients; + var e = rounded.exponent; // append trailing zeros + + if (c.length < precision) { + c = c.concat(zeros(precision - c.length)); + } // append trailing zeros + // TODO: simplify the next statement + + + c = c.concat(zeros(e - c.length + 1 + (c.length < precision ? precision - c.length : 0))); // prepend zeros + + c = zeros(-e).concat(c); + var dot = e > 0 ? e : 0; + + if (dot < c.length - 1) { + c.splice(dot + 1, 0, '.'); + } + + return rounded.sign + c.join(''); + } +}; +/** + * Round the number of digits of a number * + * @param {SplitValue} split A value split with .splitNumber(value) + * @param {number} precision A positive integer + * @return {SplitValue} + * Returns an object containing sign, coefficients, and exponent + * with rounded digits + */ + + +exports.roundDigits = function (split, precision) { + // create a clone + var rounded = { + sign: split.sign, + coefficients: split.coefficients, + exponent: split.exponent + }; + var c = rounded.coefficients; // prepend zeros if needed + + while (precision <= 0) { + c.unshift(0); + rounded.exponent++; + precision++; + } + + if (c.length > precision) { + var removed = c.splice(precision, c.length - precision); + + if (removed[0] >= 5) { + var i = precision - 1; + c[i]++; + + while (c[i] === 10) { + c.pop(); + + if (i === 0) { + c.unshift(0); + rounded.exponent++; + i++; + } + + i--; + c[i]++; + } + } + } + + return rounded; +}; +/** + * Create an array filled with zeros. + * @param {number} length + * @return {Array} + */ + + +function zeros(length) { + var arr = []; + + for (var i = 0; i < length; i++) { + arr.push(0); + } + + return arr; +} +/** + * Count the number of significant digits of a number. + * + * For example: + * 2.34 returns 3 + * 0.0034 returns 2 + * 120.5e+30 returns 4 + * + * @param {number} value + * @return {number} digits Number of significant digits + */ + + +exports.digits = function (value) { + return value.toExponential().replace(/e.*$/, '') // remove exponential notation + .replace(/^0\.?0*|\./, '') // remove decimal point and leading zeros + .length; +}; +/** + * Minimum number added to one that makes the result different than one + */ + + +exports.DBL_EPSILON = Number.EPSILON || 2.2204460492503130808472633361816E-16; +/** + * Compares two floating point numbers. + * @param {number} x First value to compare + * @param {number} y Second value to compare + * @param {number} [epsilon] The maximum relative difference between x and y + * If epsilon is undefined or null, the function will + * test whether x and y are exactly equal. + * @return {boolean} whether the two numbers are nearly equal +*/ + +exports.nearlyEqual = function (x, y, epsilon) { + // if epsilon is null or undefined, test whether x and y are exactly equal + if (epsilon === null || epsilon === undefined) { + return x === y; + } + + if (x === y) { + return true; + } // NaN + + + if (isNaN(x) || isNaN(y)) { + return false; + } // at this point x and y should be finite + + + if (isFinite(x) && isFinite(y)) { + // check numbers are very close, needed when comparing numbers near zero + var diff = Math.abs(x - y); + + if (diff < exports.DBL_EPSILON) { + return true; + } else { + // use relative error + return diff <= Math.max(Math.abs(x), Math.abs(y)) * epsilon; + } + } // Infinite and Number or negative Infinite and positive Infinite cases + + + return false; +}; +},{"./object":55}],55:[function(require,module,exports){ +'use strict'; + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +var isBigNumber = require('./bignumber/isBigNumber'); +/** + * Clone an object + * + * clone(x) + * + * Can clone any primitive type, array, and object. + * If x has a function clone, this function will be invoked to clone the object. + * + * @param {*} x + * @return {*} clone + */ + + +exports.clone = function clone(x) { + var type = _typeof(x); // immutable primitive types + + + if (type === 'number' || type === 'string' || type === 'boolean' || x === null || x === undefined) { + return x; + } // use clone function of the object when available + + + if (typeof x.clone === 'function') { + return x.clone(); + } // array + + + if (Array.isArray(x)) { + return x.map(function (value) { + return clone(value); + }); + } + + if (x instanceof Date) return new Date(x.valueOf()); + if (isBigNumber(x)) return x; // bignumbers are immutable + + if (x instanceof RegExp) throw new TypeError('Cannot clone ' + x); // TODO: clone a RegExp + // object + + return exports.map(x, clone); +}; +/** + * Apply map to all properties of an object + * @param {Object} object + * @param {function} callback + * @return {Object} Returns a copy of the object with mapped properties + */ + + +exports.map = function (object, callback) { + var clone = {}; + + for (var key in object) { + if (exports.hasOwnProperty(object, key)) { + clone[key] = callback(object[key]); + } + } + + return clone; +}; +/** + * Extend object a with the properties of object b + * @param {Object} a + * @param {Object} b + * @return {Object} a + */ + + +exports.extend = function (a, b) { + for (var prop in b) { + if (exports.hasOwnProperty(b, prop)) { + a[prop] = b[prop]; + } + } + + return a; +}; +/** + * Deep extend an object a with the properties of object b + * @param {Object} a + * @param {Object} b + * @returns {Object} + */ + + +exports.deepExtend = function deepExtend(a, b) { + // TODO: add support for Arrays to deepExtend + if (Array.isArray(b)) { + throw new TypeError('Arrays are not supported by deepExtend'); + } + + for (var prop in b) { + if (exports.hasOwnProperty(b, prop)) { + if (b[prop] && b[prop].constructor === Object) { + if (a[prop] === undefined) { + a[prop] = {}; + } + + if (a[prop].constructor === Object) { + deepExtend(a[prop], b[prop]); + } else { + a[prop] = b[prop]; + } + } else if (Array.isArray(b[prop])) { + throw new TypeError('Arrays are not supported by deepExtend'); + } else { + a[prop] = b[prop]; + } + } + } + + return a; +}; +/** + * Deep test equality of all fields in two pairs of arrays or objects. + * @param {Array | Object} a + * @param {Array | Object} b + * @returns {boolean} + */ + + +exports.deepEqual = function deepEqual(a, b) { + var prop, i, len; + + if (Array.isArray(a)) { + if (!Array.isArray(b)) { + return false; + } + + if (a.length !== b.length) { + return false; + } + + for (i = 0, len = a.length; i < len; i++) { + if (!exports.deepEqual(a[i], b[i])) { + return false; + } + } + + return true; + } else if (a instanceof Object) { + if (Array.isArray(b) || !(b instanceof Object)) { + return false; + } + + for (prop in a) { + // noinspection JSUnfilteredForInLoop + if (!exports.deepEqual(a[prop], b[prop])) { + return false; + } + } + + for (prop in b) { + // noinspection JSUnfilteredForInLoop + if (!exports.deepEqual(a[prop], b[prop])) { + return false; + } + } + + return true; + } else { + return a === b; + } +}; +/** + * Test whether the current JavaScript engine supports Object.defineProperty + * @returns {boolean} returns true if supported + */ + + +exports.canDefineProperty = function () { + // test needed for broken IE8 implementation + try { + if (Object.defineProperty) { + Object.defineProperty({}, 'x', { + get: function get() {} + }); + return true; + } + } catch (e) {} + + return false; +}; +/** + * Attach a lazy loading property to a constant. + * The given function `fn` is called once when the property is first requested. + * On older browsers (<IE8), the function will fall back to direct evaluation + * of the properties value. + * @param {Object} object Object where to add the property + * @param {string} prop Property name + * @param {Function} fn Function returning the property value. Called + * without arguments. + */ + + +exports.lazy = function (object, prop, fn) { + if (exports.canDefineProperty()) { + var _uninitialized = true; + + var _value; + + Object.defineProperty(object, prop, { + get: function get() { + if (_uninitialized) { + _value = fn(); + _uninitialized = false; + } + + return _value; + }, + set: function set(value) { + _value = value; + _uninitialized = false; + }, + configurable: true, + enumerable: true + }); + } else { + // fall back to immediate evaluation + object[prop] = fn(); + } +}; +/** + * Traverse a path into an object. + * When a namespace is missing, it will be created + * @param {Object} object + * @param {string} path A dot separated string like 'name.space' + * @return {Object} Returns the object at the end of the path + */ + + +exports.traverse = function (object, path) { + var obj = object; + + if (path) { + var names = path.split('.'); + + for (var i = 0; i < names.length; i++) { + var name = names[i]; + + if (!(name in obj)) { + obj[name] = {}; + } + + obj = obj[name]; + } + } + + return obj; +}; +/** + * A safe hasOwnProperty + * @param {Object} object + * @param {string} property + */ + + +exports.hasOwnProperty = function (object, property) { + return object && Object.hasOwnProperty.call(object, property); +}; +/** + * Test whether an object is a factory. a factory has fields: + * + * - factory: function (type: Object, config: Object, load: function, typed: function [, math: Object]) (required) + * - name: string (optional) + * - path: string A dot separated path (optional) + * - math: boolean If true (false by default), the math namespace is passed + * as fifth argument of the factory function + * + * @param {*} object + * @returns {boolean} + */ + + +exports.isFactory = function (object) { + return object && typeof object.factory === 'function'; +}; +},{"./bignumber/isBigNumber":48}],56:[function(require,module,exports){ +"use strict"; + +// TODO: remove these polyfills as soon as we have a build process that transpiles the code to ES5 +// Polyfill for IE 11 (Number.isFinite is used in `complex.js`) +// source: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite +Number.isFinite = Number.isFinite || function (value) { + return typeof value === 'number' && isFinite(value); +}; // Polyfill for IE 11 +// source: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN + + +Number.isNaN = Number.isNaN || function (value) { + return value !== value; // eslint-disable-line no-self-compare +}; +},{}],57:[function(require,module,exports){ +'use strict'; + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +var formatNumber = require('./number').format; + +var formatBigNumber = require('./bignumber/formatter').format; + +var isBigNumber = require('./bignumber/isBigNumber'); +/** + * Test whether value is a string + * @param {*} value + * @return {boolean} isString + */ + + +exports.isString = function (value) { + return typeof value === 'string'; +}; +/** + * Check if a text ends with a certain string. + * @param {string} text + * @param {string} search + */ + + +exports.endsWith = function (text, search) { + var start = text.length - search.length; + var end = text.length; + return text.substring(start, end) === search; +}; +/** + * Format a value of any type into a string. + * + * Usage: + * math.format(value) + * math.format(value, precision) + * + * When value is a function: + * + * - When the function has a property `syntax`, it returns this + * syntax description. + * - In other cases, a string `'function'` is returned. + * + * When `value` is an Object: + * + * - When the object contains a property `format` being a function, this + * function is invoked as `value.format(options)` and the result is returned. + * - When the object has its own `toString` method, this method is invoked + * and the result is returned. + * - In other cases the function will loop over all object properties and + * return JSON object notation like '{"a": 2, "b": 3}'. + * + * Example usage: + * math.format(2/7) // '0.2857142857142857' + * math.format(math.pi, 3) // '3.14' + * math.format(new Complex(2, 3)) // '2 + 3i' + * math.format('hello') // '"hello"' + * + * @param {*} value Value to be stringified + * @param {Object | number | Function} [options] Formatting options. See + * lib/utils/number:format for a + * description of the available + * options. + * @return {string} str + */ + + +exports.format = function (value, options) { + if (typeof value === 'number') { + return formatNumber(value, options); + } + + if (isBigNumber(value)) { + return formatBigNumber(value, options); + } // note: we use unsafe duck-typing here to check for Fractions, this is + // ok here since we're only invoking toString or concatenating its values + + + if (looksLikeFraction(value)) { + if (!options || options.fraction !== 'decimal') { + // output as ratio, like '1/3' + return value.s * value.n + '/' + value.d; + } else { + // output as decimal, like '0.(3)' + return value.toString(); + } + } + + if (Array.isArray(value)) { + return formatArray(value, options); + } + + if (exports.isString(value)) { + return '"' + value + '"'; + } + + if (typeof value === 'function') { + return value.syntax ? String(value.syntax) : 'function'; + } + + if (value && _typeof(value) === 'object') { + if (typeof value.format === 'function') { + return value.format(options); + } else if (value && value.toString() !== {}.toString()) { + // this object has a non-native toString method, use that one + return value.toString(); + } else { + var entries = []; + + for (var key in value) { + if (value.hasOwnProperty(key)) { + entries.push('"' + key + '": ' + exports.format(value[key], options)); + } + } + + return '{' + entries.join(', ') + '}'; + } + } + + return String(value); +}; +/** + * Stringify a value into a string enclosed in double quotes. + * Unescaped double quotes and backslashes inside the value are escaped. + * @param {*} value + * @return {string} + */ + + +exports.stringify = function (value) { + var text = String(value); + var escaped = ''; + var i = 0; + + while (i < text.length) { + var c = text.charAt(i); + + if (c === '\\') { + escaped += c; + i++; + c = text.charAt(i); + + if (c === '' || '"\\/bfnrtu'.indexOf(c) === -1) { + escaped += '\\'; // no valid escape character -> escape it + } + + escaped += c; + } else if (c === '"') { + escaped += '\\"'; + } else { + escaped += c; + } + + i++; + } + + return '"' + escaped + '"'; +}; +/** + * Escape special HTML characters + * @param {*} value + * @return {string} + */ + + +exports.escape = function (value) { + var text = String(value); + text = text.replace(/&/g, '&').replace(/"/g, '"').replace(/'/g, ''').replace(/</g, '<').replace(/>/g, '>'); + return text; +}; +/** + * Recursively format an n-dimensional matrix + * Example output: "[[1, 2], [3, 4]]" + * @param {Array} array + * @param {Object | number | Function} [options] Formatting options. See + * lib/utils/number:format for a + * description of the available + * options. + * @returns {string} str + */ + + +function formatArray(array, options) { + if (Array.isArray(array)) { + var str = '['; + var len = array.length; + + for (var i = 0; i < len; i++) { + if (i !== 0) { + str += ', '; + } + + str += formatArray(array[i], options); + } + + str += ']'; + return str; + } else { + return exports.format(array, options); + } +} +/** + * Check whether a value looks like a Fraction (unsafe duck-type check) + * @param {*} value + * @return {boolean} + */ + + +function looksLikeFraction(value) { + return value && _typeof(value) === 'object' && typeof value.s === 'number' && typeof value.n === 'number' && typeof value.d === 'number' || false; +} +},{"./bignumber/formatter":47,"./bignumber/isBigNumber":48,"./number":54}],58:[function(require,module,exports){ +function E () { + // Keep this empty so it's easier to inherit from + // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3) +} + +E.prototype = { + on: function (name, callback, ctx) { + var e = this.e || (this.e = {}); + + (e[name] || (e[name] = [])).push({ + fn: callback, + ctx: ctx + }); + + return this; + }, + + once: function (name, callback, ctx) { + var self = this; + function listener () { + self.off(name, listener); + callback.apply(ctx, arguments); + }; + + listener._ = callback + return this.on(name, listener, ctx); + }, + + emit: function (name) { + var data = [].slice.call(arguments, 1); + var evtArr = ((this.e || (this.e = {}))[name] || []).slice(); + var i = 0; + var len = evtArr.length; + + for (i; i < len; i++) { + evtArr[i].fn.apply(evtArr[i].ctx, data); + } + + return this; + }, + + off: function (name, callback) { + var e = this.e || (this.e = {}); + var evts = e[name]; + var liveEvents = []; + + if (evts && callback) { + for (var i = 0, len = evts.length; i < len; i++) { + if (evts[i].fn !== callback && evts[i].fn._ !== callback) + liveEvents.push(evts[i]); + } + } + + // Remove event from queue to prevent memory leak + // Suggested by https://github.com/lazd + // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910 + + (liveEvents.length) + ? e[name] = liveEvents + : delete e[name]; + + return this; + } +}; + +module.exports = E; + +},{}],59:[function(require,module,exports){ +/** + * typed-function + * + * Type checking for JavaScript functions + * + * https://github.com/josdejong/typed-function + */ +'use strict'; + +(function (root, factory) { + if (typeof define === 'function' && define.amd) { + // AMD. Register as an anonymous module. + define([], factory); + } else if (typeof exports === 'object') { + // OldNode. Does not work with strict CommonJS, but + // only CommonJS-like environments that support module.exports, + // like OldNode. + module.exports = factory(); + } else { + // Browser globals (root is window) + root.typed = factory(); + } +}(this, function () { + + function ok () { + return true; + } + + function notOk () { + return false; + } + + function undef () { + return undefined; + } + + /** + * @typedef {{ + * params: Param[], + * fn: function + * }} Signature + * + * @typedef {{ + * types: Type[], + * restParam: boolean + * }} Param + * + * @typedef {{ + * name: string, + * typeIndex: number, + * test: function, + * conversion?: ConversionDef, + * conversionIndex: number, + * }} Type + * + * @typedef {{ + * from: string, + * to: string, + * convert: function (*) : * + * }} ConversionDef + * + * @typedef {{ + * name: string, + * test: function(*) : boolean + * }} TypeDef + */ + + // create a new instance of typed-function + function create () { + // data type tests + var _types = [ + { name: 'number', test: function (x) { return typeof x === 'number' } }, + { name: 'string', test: function (x) { return typeof x === 'string' } }, + { name: 'boolean', test: function (x) { return typeof x === 'boolean' } }, + { name: 'Function', test: function (x) { return typeof x === 'function'} }, + { name: 'Array', test: Array.isArray }, + { name: 'Date', test: function (x) { return x instanceof Date } }, + { name: 'RegExp', test: function (x) { return x instanceof RegExp } }, + { name: 'Object', test: function (x) { + return typeof x === 'object' && x.constructor === Object + }}, + { name: 'null', test: function (x) { return x === null } }, + { name: 'undefined', test: function (x) { return x === undefined } } + ]; + + var anyType = { + name: 'any', + test: ok + } + + // types which need to be ignored + var _ignore = []; + + // type conversions + var _conversions = []; + + // This is a temporary object, will be replaced with a typed function at the end + var typed = { + types: _types, + conversions: _conversions, + ignore: _ignore + }; + + /** + * Find the test function for a type + * @param {String} typeName + * @return {TypeDef} Returns the type definition when found, + * Throws a TypeError otherwise + */ + function findTypeByName (typeName) { + var entry = findInArray(typed.types, function (entry) { + return entry.name === typeName; + }); + + if (entry) { + return entry; + } + + if (typeName === 'any') { // special baked-in case 'any' + return anyType; + } + + var hint = findInArray(typed.types, function (entry) { + return entry.name.toLowerCase() === typeName.toLowerCase(); + }); + + throw new TypeError('Unknown type "' + typeName + '"' + + (hint ? ('. Did you mean "' + hint.name + '"?') : '')); + } + + /** + * Find the index of a type definition. Handles special case 'any' + * @param {TypeDef} type + * @return {number} + */ + function findTypeIndex(type) { + if (type === anyType) { + return 999; + } + + return typed.types.indexOf(type); + } + + /** + * Find a type that matches a value. + * @param {*} value + * @return {string} Returns the name of the first type for which + * the type test matches the value. + */ + function findTypeName(value) { + var entry = findInArray(typed.types, function (entry) { + return entry.test(value); + }); + + if (entry) { + return entry.name; + } + + throw new TypeError('Value has unknown type. Value: ' + value); + } + + /** + * Find a specific signature from a (composed) typed function, for example: + * + * typed.find(fn, ['number', 'string']) + * typed.find(fn, 'number, string') + * + * Function find only only works for exact matches. + * + * @param {Function} fn A typed-function + * @param {string | string[]} signature Signature to be found, can be + * an array or a comma separated string. + * @return {Function} Returns the matching signature, or + * throws an error when no signature + * is found. + */ + function find (fn, signature) { + if (!fn.signatures) { + throw new TypeError('Function is no typed-function'); + } + + // normalize input + var arr; + if (typeof signature === 'string') { + arr = signature.split(','); + for (var i = 0; i < arr.length; i++) { + arr[i] = arr[i].trim(); + } + } + else if (Array.isArray(signature)) { + arr = signature; + } + else { + throw new TypeError('String array or a comma separated string expected'); + } + + var str = arr.join(','); + + // find an exact match + var match = fn.signatures[str]; + if (match) { + return match; + } + + // TODO: extend find to match non-exact signatures + + throw new TypeError('Signature not found (signature: ' + (fn.name || 'unnamed') + '(' + arr.join(', ') + '))'); + } + + /** + * Convert a given value to another data type. + * @param {*} value + * @param {string} type + */ + function convert (value, type) { + var from = findTypeName(value); + + // check conversion is needed + if (type === from) { + return value; + } + + for (var i = 0; i < typed.conversions.length; i++) { + var conversion = typed.conversions[i]; + if (conversion.from === from && conversion.to === type) { + return conversion.convert(value); + } + } + + throw new Error('Cannot convert from ' + from + ' to ' + type); + } + + /** + * Stringify parameters in a normalized way + * @param {Param[]} params + * @return {string} + */ + function stringifyParams (params) { + return params + .map(function (param) { + var typeNames = param.types.map(getTypeName); + + return (param.restParam ? '...' : '') + typeNames.join('|'); + }) + .join(','); + } + + /** + * Parse a parameter, like "...number | boolean" + * @param {string} param + * @param {ConversionDef[]} conversions + * @return {Param} param + */ + function parseParam (param, conversions) { + var restParam = param.indexOf('...') === 0; + var types = (!restParam) + ? param + : (param.length > 3) + ? param.slice(3) + : 'any'; + + var typeNames = types.split('|').map(trim) + .filter(notEmpty) + .filter(notIgnore); + + var matchingConversions = filterConversions(conversions, typeNames); + + var exactTypes = typeNames.map(function (typeName) { + var type = findTypeByName(typeName); + + return { + name: typeName, + typeIndex: findTypeIndex(type), + test: type.test, + conversion: null, + conversionIndex: -1 + }; + }); + + var convertibleTypes = matchingConversions.map(function (conversion) { + var type = findTypeByName(conversion.from); + + return { + name: conversion.from, + typeIndex: findTypeIndex(type), + test: type.test, + conversion: conversion, + conversionIndex: conversions.indexOf(conversion) + }; + }); + + return { + types: exactTypes.concat(convertibleTypes), + restParam: restParam + }; + } + + /** + * Parse a signature with comma separated parameters, + * like "number | boolean, ...string" + * @param {string} signature + * @param {function} fn + * @param {ConversionDef[]} conversions + * @return {Signature | null} signature + */ + function parseSignature (signature, fn, conversions) { + var params = []; + + if (signature.trim() !== '') { + params = signature + .split(',') + .map(trim) + .map(function (param, index, array) { + var parsedParam = parseParam(param, conversions); + + if (parsedParam.restParam && (index !== array.length - 1)) { + throw new SyntaxError('Unexpected rest parameter "' + param + '": ' + + 'only allowed for the last parameter'); + } + + return parsedParam; + }); + } + + if (params.some(isInvalidParam)) { + // invalid signature: at least one parameter has no types + // (they may have been filtered) + return null; + } + + return { + params: params, + fn: fn + }; + } + + /** + * Test whether a set of params contains a restParam + * @param {Param[]} params + * @return {boolean} Returns true when the last parameter is a restParam + */ + function hasRestParam(params) { + var param = last(params) + return param ? param.restParam : false; + } + + /** + * Test whether a parameter contains conversions + * @param {Param} param + * @return {boolean} Returns true when at least one of the parameters + * contains a conversion. + */ + function hasConversions(param) { + return param.types.some(function (type) { + return type.conversion != null; + }); + } + + /** + * Create a type test for a single parameter, which can have one or multiple + * types. + * @param {Param} param + * @return {function(x: *) : boolean} Returns a test function + */ + function compileTest(param) { + if (!param || param.types.length === 0) { + // nothing to do + return ok; + } + else if (param.types.length === 1) { + return findTypeByName(param.types[0].name).test; + } + else if (param.types.length === 2) { + var test0 = findTypeByName(param.types[0].name).test; + var test1 = findTypeByName(param.types[1].name).test; + return function or(x) { + return test0(x) || test1(x); + } + } + else { // param.types.length > 2 + var tests = param.types.map(function (type) { + return findTypeByName(type.name).test; + }) + return function or(x) { + for (var i = 0; i < tests.length; i++) { + if (tests[i](x)) { + return true; + } + } + return false; + } + } + } + + /** + * Create a test for all parameters of a signature + * @param {Param[]} params + * @return {function(args: Array<*>) : boolean} + */ + function compileTests(params) { + var tests, test0, test1; + + if (hasRestParam(params)) { + // variable arguments like '...number' + tests = initial(params).map(compileTest); + var varIndex = tests.length; + var lastTest = compileTest(last(params)); + var testRestParam = function (args) { + for (var i = varIndex; i < args.length; i++) { + if (!lastTest(args[i])) { + return false; + } + } + return true; + } + + return function testArgs(args) { + for (var i = 0; i < tests.length; i++) { + if (!tests[i](args[i])) { + return false; + } + } + return testRestParam(args) && (args.length >= varIndex + 1); + }; + } + else { + // no variable arguments + if (params.length === 0) { + return function testArgs(args) { + return args.length === 0; + }; + } + else if (params.length === 1) { + test0 = compileTest(params[0]); + return function testArgs(args) { + return test0(args[0]) && args.length === 1; + }; + } + else if (params.length === 2) { + test0 = compileTest(params[0]); + test1 = compileTest(params[1]); + return function testArgs(args) { + return test0(args[0]) && test1(args[1]) && args.length === 2; + }; + } + else { // arguments.length > 2 + tests = params.map(compileTest); + return function testArgs(args) { + for (var i = 0; i < tests.length; i++) { + if (!tests[i](args[i])) { + return false; + } + } + return args.length === tests.length; + }; + } + } + } + + /** + * Find the parameter at a specific index of a signature. + * Handles rest parameters. + * @param {Signature} signature + * @param {number} index + * @return {Param | null} Returns the matching parameter when found, + * null otherwise. + */ + function getParamAtIndex(signature, index) { + return index < signature.params.length + ? signature.params[index] + : hasRestParam(signature.params) + ? last(signature.params) + : null + } + + /** + * Get all type names of a parameter + * @param {Signature} signature + * @param {number} index + * @param {boolean} excludeConversions + * @return {string[]} Returns an array with type names + */ + function getExpectedTypeNames (signature, index, excludeConversions) { + var param = getParamAtIndex(signature, index); + var types = param + ? excludeConversions + ? param.types.filter(isExactType) + : param.types + : []; + + return types.map(getTypeName); + } + + /** + * Returns the name of a type + * @param {Type} type + * @return {string} Returns the type name + */ + function getTypeName(type) { + return type.name; + } + + /** + * Test whether a type is an exact type or conversion + * @param {Type} type + * @return {boolean} Returns true when + */ + function isExactType(type) { + return type.conversion === null || type.conversion === undefined; + } + + /** + * Helper function for creating error messages: create an array with + * all available types on a specific argument index. + * @param {Signature[]} signatures + * @param {number} index + * @return {string[]} Returns an array with available types + */ + function mergeExpectedParams(signatures, index) { + var typeNames = uniq(flatMap(signatures, function (signature) { + return getExpectedTypeNames(signature, index, false); + })); + + return (typeNames.indexOf('any') !== -1) ? ['any'] : typeNames; + } + + /** + * Create + * @param {string} name The name of the function + * @param {array.<*>} args The actual arguments passed to the function + * @param {Signature[]} signatures A list with available signatures + * @return {TypeError} Returns a type error with additional data + * attached to it in the property `data` + */ + function createError(name, args, signatures) { + var err, expected; + var _name = name || 'unnamed'; + + // test for wrong type at some index + var matchingSignatures = signatures; + var index; + for (index = 0; index < args.length; index++) { + var nextMatchingDefs = matchingSignatures.filter(function (signature) { + var test = compileTest(getParamAtIndex(signature, index)); + return (index < signature.params.length || hasRestParam(signature.params)) && + test(args[index]); + }); + + if (nextMatchingDefs.length === 0) { + // no matching signatures anymore, throw error "wrong type" + expected = mergeExpectedParams(matchingSignatures, index); + if (expected.length > 0) { + var actualType = findTypeName(args[index]); + + err = new TypeError('Unexpected type of argument in function ' + _name + + ' (expected: ' + expected.join(' or ') + + ', actual: ' + actualType + ', index: ' + index + ')'); + err.data = { + category: 'wrongType', + fn: _name, + index: index, + actual: actualType, + expected: expected + } + return err; + } + } + else { + matchingSignatures = nextMatchingDefs; + } + } + + // test for too few arguments + var lengths = matchingSignatures.map(function (signature) { + return hasRestParam(signature.params) ? Infinity : signature.params.length; + }); + if (args.length < Math.min.apply(null, lengths)) { + expected = mergeExpectedParams(matchingSignatures, index); + err = new TypeError('Too few arguments in function ' + _name + + ' (expected: ' + expected.join(' or ') + + ', index: ' + args.length + ')'); + err.data = { + category: 'tooFewArgs', + fn: _name, + index: args.length, + expected: expected + } + return err; + } + + // test for too many arguments + var maxLength = Math.max.apply(null, lengths); + if (args.length > maxLength) { + err = new TypeError('Too many arguments in function ' + _name + + ' (expected: ' + maxLength + ', actual: ' + args.length + ')'); + err.data = { + category: 'tooManyArgs', + fn: _name, + index: args.length, + expectedLength: maxLength + } + return err; + } + + err = new TypeError('Arguments of type "' + args.join(', ') + + '" do not match any of the defined signatures of function ' + _name + '.'); + err.data = { + category: 'mismatch', + actual: args.map(findTypeName) + } + return err; + } + + /** + * Find the lowest index of all exact types of a parameter (no conversions) + * @param {Param} param + * @return {number} Returns the index of the lowest type in typed.types + */ + function getLowestTypeIndex (param) { + var min = 999; + + for (var i = 0; i < param.types.length; i++) { + if (isExactType(param.types[i])) { + min = Math.min(min, param.types[i].typeIndex); + } + } + + return min; + } + + /** + * Find the lowest index of the conversion of all types of the parameter + * having a conversion + * @param {Param} param + * @return {number} Returns the lowest index of the conversions of this type + */ + function getLowestConversionIndex (param) { + var min = 999; + + for (var i = 0; i < param.types.length; i++) { + if (!isExactType(param.types[i])) { + min = Math.min(min, param.types[i].conversionIndex); + } + } + + return min; + } + + /** + * Compare two params + * @param {Param} param1 + * @param {Param} param2 + * @return {number} returns a negative number when param1 must get a lower + * index than param2, a positive number when the opposite, + * or zero when both are equal + */ + function compareParams (param1, param2) { + var c; + + // compare having a rest parameter or not + c = param1.restParam - param2.restParam; + if (c !== 0) { + return c; + } + + // compare having conversions or not + c = hasConversions(param1) - hasConversions(param2); + if (c !== 0) { + return c; + } + + // compare the index of the types + c = getLowestTypeIndex(param1) - getLowestTypeIndex(param2); + if (c !== 0) { + return c; + } + + // compare the index of any conversion + return getLowestConversionIndex(param1) - getLowestConversionIndex(param2); + } + + /** + * Compare two signatures + * @param {Signature} signature1 + * @param {Signature} signature2 + * @return {number} returns a negative number when param1 must get a lower + * index than param2, a positive number when the opposite, + * or zero when both are equal + */ + function compareSignatures (signature1, signature2) { + var len = Math.min(signature1.params.length, signature2.params.length); + var i; + var c; + + // compare whether the params have conversions at all or not + c = signature1.params.some(hasConversions) - signature2.params.some(hasConversions) + if (c !== 0) { + return c; + } + + // next compare whether the params have conversions one by one + for (i = 0; i < len; i++) { + c = hasConversions(signature1.params[i]) - hasConversions(signature2.params[i]); + if (c !== 0) { + return c; + } + } + + // compare the types of the params one by one + for (i = 0; i < len; i++) { + c = compareParams(signature1.params[i], signature2.params[i]); + if (c !== 0) { + return c; + } + } + + // compare the number of params + return signature1.params.length - signature2.params.length; + } + + /** + * Get params containing all types that can be converted to the defined types. + * + * @param {ConversionDef[]} conversions + * @param {string[]} typeNames + * @return {ConversionDef[]} Returns the conversions that are available + * for every type (if any) + */ + function filterConversions(conversions, typeNames) { + var matches = {}; + + conversions.forEach(function (conversion) { + if (typeNames.indexOf(conversion.from) === -1 && + typeNames.indexOf(conversion.to) !== -1 && + !matches[conversion.from]) { + matches[conversion.from] = conversion; + } + }); + + return Object.keys(matches).map(function (from) { + return matches[from]; + }); + } + + /** + * Preprocess arguments before calling the original function: + * - if needed convert the parameters + * - in case of rest parameters, move the rest parameters into an Array + * @param {Param[]} params + * @param {function} fn + * @return {function} Returns a wrapped function + */ + function compileArgsPreprocessing(params, fn) { + var fnConvert = fn; + + // TODO: can we make this wrapper function smarter/simpler? + + if (params.some(hasConversions)) { + var restParam = hasRestParam(params); + var compiledConversions = params.map(compileArgConversion) + + fnConvert = function convertArgs() { + var args = []; + var last = restParam ? arguments.length - 1 : arguments.length; + for (var i = 0; i < last; i++) { + args[i] = compiledConversions[i](arguments[i]); + } + if (restParam) { + args[last] = arguments[last].map(compiledConversions[last]); + } + + return fn.apply(null, args); + } + } + + var fnPreprocess = fnConvert; + if (hasRestParam(params)) { + var offset = params.length - 1; + + fnPreprocess = function preprocessRestParams () { + return fnConvert.apply(null, + slice(arguments, 0, offset).concat([slice(arguments, offset)])); + } + } + + return fnPreprocess; + } + + /** + * Compile conversion for a parameter to the right type + * @param {Param} param + * @return {function} Returns the wrapped function that will convert arguments + * + */ + function compileArgConversion(param) { + var test0, test1, conversion0, conversion1; + var tests = []; + var conversions = []; + + param.types.forEach(function (type) { + if (type.conversion) { + tests.push(findTypeByName(type.conversion.from).test); + conversions.push(type.conversion.convert); + } + }); + + // create optimized conversion functions depending on the number of conversions + switch (conversions.length) { + case 0: + return function convertArg(arg) { + return arg; + } + + case 1: + test0 = tests[0] + conversion0 = conversions[0]; + return function convertArg(arg) { + if (test0(arg)) { + return conversion0(arg) + } + return arg; + } + + case 2: + test0 = tests[0] + test1 = tests[1] + conversion0 = conversions[0]; + conversion1 = conversions[1]; + return function convertArg(arg) { + if (test0(arg)) { + return conversion0(arg) + } + if (test1(arg)) { + return conversion1(arg) + } + return arg; + } + + default: + return function convertArg(arg) { + for (var i = 0; i < conversions.length; i++) { + if (tests[i](arg)) { + return conversions[i](arg); + } + } + return arg; + } + } + } + + /** + * Convert an array with signatures into a map with signatures, + * where signatures with union types are split into separate signatures + * + * Throws an error when there are conflicting types + * + * @param {Signature[]} signatures + * @return {Object.<string, function>} Returns a map with signatures + * as key and the original function + * of this signature as value. + */ + function createSignaturesMap(signatures) { + var signaturesMap = {}; + signatures.forEach(function (signature) { + if (!signature.params.some(hasConversions)) { + splitParams(signature.params, true).forEach(function (params) { + signaturesMap[stringifyParams(params)] = signature.fn; + }); + } + }); + + return signaturesMap; + } + + /** + * Split params with union types in to separate params. + * + * For example: + * + * splitParams([['Array', 'Object'], ['string', 'RegExp']) + * // returns: + * // [ + * // ['Array', 'string'], + * // ['Array', 'RegExp'], + * // ['Object', 'string'], + * // ['Object', 'RegExp'] + * // ] + * + * @param {Param[]} params + * @param {boolean} ignoreConversionTypes + * @return {Param[]} + */ + function splitParams(params, ignoreConversionTypes) { + function _splitParams(params, index, types) { + if (index < params.length) { + var param = params[index] + var filteredTypes = ignoreConversionTypes + ? param.types.filter(isExactType) + : param.types; + var typeGroups + + if (param.restParam) { + // split the types of a rest parameter in two: + // one with only exact types, and one with exact types and conversions + var exactTypes = filteredTypes.filter(isExactType) + typeGroups = exactTypes.length < filteredTypes.length + ? [exactTypes, filteredTypes] + : [filteredTypes] + + } + else { + // split all the types of a regular parameter into one type per group + typeGroups = filteredTypes.map(function (type) { + return [type] + }) + } + + // recurse over the groups with types + return flatMap(typeGroups, function (typeGroup) { + return _splitParams(params, index + 1, types.concat([typeGroup])); + }); + + } + else { + // we've reached the end of the parameters. Now build a new Param + var splittedParams = types.map(function (type, typeIndex) { + return { + types: type, + restParam: (typeIndex === params.length - 1) && hasRestParam(params) + } + }); + + return [splittedParams]; + } + } + + return _splitParams(params, 0, []); + } + + /** + * Test whether two signatures have a conflicting signature + * @param {Signature} signature1 + * @param {Signature} signature2 + * @return {boolean} Returns true when the signatures conflict, false otherwise. + */ + function hasConflictingParams(signature1, signature2) { + var ii = Math.max(signature1.params.length, signature2.params.length); + + for (var i = 0; i < ii; i++) { + var typesNames1 = getExpectedTypeNames(signature1, i, true); + var typesNames2 = getExpectedTypeNames(signature2, i, true); + + if (!hasOverlap(typesNames1, typesNames2)) { + return false; + } + } + + var len1 = signature1.params.length; + var len2 = signature2.params.length; + var restParam1 = hasRestParam(signature1.params); + var restParam2 = hasRestParam(signature2.params); + + return restParam1 + ? restParam2 ? (len1 === len2) : (len2 >= len1) + : restParam2 ? (len1 >= len2) : (len1 === len2) + } + + /** + * Create a typed function + * @param {String} name The name for the typed function + * @param {Object.<string, function>} signaturesMap + * An object with one or + * multiple signatures as key, and the + * function corresponding to the + * signature as value. + * @return {function} Returns the created typed function. + */ + function createTypedFunction(name, signaturesMap) { + if (Object.keys(signaturesMap).length === 0) { + throw new SyntaxError('No signatures provided'); + } + + // parse the signatures, and check for conflicts + var parsedSignatures = []; + Object.keys(signaturesMap) + .map(function (signature) { + return parseSignature(signature, signaturesMap[signature], typed.conversions); + }) + .filter(notNull) + .forEach(function (parsedSignature) { + // check whether this parameter conflicts with already parsed signatures + var conflictingSignature = findInArray(parsedSignatures, function (s) { + return hasConflictingParams(s, parsedSignature) + }); + if (conflictingSignature) { + throw new TypeError('Conflicting signatures "' + + stringifyParams(conflictingSignature.params) + '" and "' + + stringifyParams(parsedSignature.params) + '".'); + } + + parsedSignatures.push(parsedSignature); + }); + + // split and filter the types of the signatures, and then order them + var signatures = flatMap(parsedSignatures, function (parsedSignature) { + var params = parsedSignature ? splitParams(parsedSignature.params, false) : [] + + return params.map(function (params) { + return { + params: params, + fn: parsedSignature.fn + }; + }); + }).filter(notNull); + + signatures.sort(compareSignatures); + + // we create a highly optimized checks for the first couple of signatures with max 2 arguments + var ok0 = signatures[0] && signatures[0].params.length <= 2 && !hasRestParam(signatures[0].params); + var ok1 = signatures[1] && signatures[1].params.length <= 2 && !hasRestParam(signatures[1].params); + var ok2 = signatures[2] && signatures[2].params.length <= 2 && !hasRestParam(signatures[2].params); + var ok3 = signatures[3] && signatures[3].params.length <= 2 && !hasRestParam(signatures[3].params); + var ok4 = signatures[4] && signatures[4].params.length <= 2 && !hasRestParam(signatures[4].params); + var ok5 = signatures[5] && signatures[5].params.length <= 2 && !hasRestParam(signatures[5].params); + var allOk = ok0 && ok1 && ok2 && ok3 && ok4 && ok5; + + // compile the tests + var tests = signatures.map(function (signature) { + return compileTests(signature.params); + }); + + var test00 = ok0 ? compileTest(signatures[0].params[0]) : notOk; + var test10 = ok1 ? compileTest(signatures[1].params[0]) : notOk; + var test20 = ok2 ? compileTest(signatures[2].params[0]) : notOk; + var test30 = ok3 ? compileTest(signatures[3].params[0]) : notOk; + var test40 = ok4 ? compileTest(signatures[4].params[0]) : notOk; + var test50 = ok5 ? compileTest(signatures[5].params[0]) : notOk; + + var test01 = ok0 ? compileTest(signatures[0].params[1]) : notOk; + var test11 = ok1 ? compileTest(signatures[1].params[1]) : notOk; + var test21 = ok2 ? compileTest(signatures[2].params[1]) : notOk; + var test31 = ok3 ? compileTest(signatures[3].params[1]) : notOk; + var test41 = ok4 ? compileTest(signatures[4].params[1]) : notOk; + var test51 = ok5 ? compileTest(signatures[5].params[1]) : notOk; + + // compile the functions + var fns = signatures.map(function(signature) { + return compileArgsPreprocessing(signature.params, signature.fn) + }); + + var fn0 = ok0 ? fns[0] : undef; + var fn1 = ok1 ? fns[1] : undef; + var fn2 = ok2 ? fns[2] : undef; + var fn3 = ok3 ? fns[3] : undef; + var fn4 = ok4 ? fns[4] : undef; + var fn5 = ok5 ? fns[5] : undef; + + var len0 = ok0 ? signatures[0].params.length : -1; + var len1 = ok1 ? signatures[1].params.length : -1; + var len2 = ok2 ? signatures[2].params.length : -1; + var len3 = ok3 ? signatures[3].params.length : -1; + var len4 = ok4 ? signatures[4].params.length : -1; + var len5 = ok5 ? signatures[5].params.length : -1; + + // simple and generic, but also slow + var iStart = allOk ? 6 : 0; + var iEnd = signatures.length; + var generic = function generic() { + 'use strict'; + + for (var i = iStart; i < iEnd; i++) { + if (tests[i](arguments)) { + return fns[i].apply(null, arguments); + } + } + + throw createError(name, arguments, signatures); + } + + // create the typed function + // fast, specialized version. Falls back to the slower, generic one if needed + var fn = function fn(arg0, arg1) { + 'use strict'; + + if (arguments.length === len0 && test00(arg0) && test01(arg1)) { return fn0.apply(null, arguments); } + if (arguments.length === len1 && test10(arg0) && test11(arg1)) { return fn1.apply(null, arguments); } + if (arguments.length === len2 && test20(arg0) && test21(arg1)) { return fn2.apply(null, arguments); } + if (arguments.length === len3 && test30(arg0) && test31(arg1)) { return fn3.apply(null, arguments); } + if (arguments.length === len4 && test40(arg0) && test41(arg1)) { return fn4.apply(null, arguments); } + if (arguments.length === len5 && test50(arg0) && test51(arg1)) { return fn5.apply(null, arguments); } + + return generic.apply(null, arguments); + } + + // attach name the typed function + try { + Object.defineProperty(fn, 'name', {value: name}); + } + catch (err) { + // old browsers do not support Object.defineProperty and some don't support setting the name property + // the function name is not essential for the functioning, it's mostly useful for debugging, + // so it's fine to have unnamed functions. + } + + // attach signatures to the function + fn.signatures = createSignaturesMap(signatures); + + return fn; + } + + /** + * Test whether a type should be NOT be ignored + * @param {string} typeName + * @return {boolean} + */ + function notIgnore(typeName) { + return typed.ignore.indexOf(typeName) === -1; + } + + /** + * trim a string + * @param {string} str + * @return {string} + */ + function trim(str) { + return str.trim(); + } + + /** + * Test whether a string is not empty + * @param {string} str + * @return {boolean} + */ + function notEmpty(str) { + return !!str; + } + + /** + * test whether a value is not strict equal to null + * @param {*} value + * @return {boolean} + */ + function notNull(value) { + return value !== null; + } + + /** + * Test whether a parameter has no types defined + * @param {Param} param + * @return {boolean} + */ + function isInvalidParam (param) { + return param.types.length === 0; + } + + /** + * Return all but the last items of an array + * @param {Array} arr + * @return {Array} + */ + function initial(arr) { + return arr.slice(0, arr.length - 1); + } + + /** + * return the last item of an array + * @param {Array} arr + * @return {*} + */ + function last(arr) { + return arr[arr.length - 1]; + } + + /** + * Slice an array or function Arguments + * @param {Array | Arguments | IArguments} arr + * @param {number} start + * @param {number} [end] + * @return {Array} + */ + function slice(arr, start, end) { + return Array.prototype.slice.call(arr, start, end); + } + + /** + * Test whether an array contains some item + * @param {Array} array + * @param {*} item + * @return {boolean} Returns true if array contains item, false if not. + */ + function contains(array, item) { + return array.indexOf(item) !== -1; + } + + /** + * Test whether two arrays have overlapping items + * @param {Array} array1 + * @param {Array} array2 + * @return {boolean} Returns true when at least one item exists in both arrays + */ + function hasOverlap(array1, array2) { + for (var i = 0; i < array1.length; i++) { + if (contains(array2, array1[i])) { + return true; + } + } + + return false; + } + + /** + * Return the first item from an array for which test(arr[i]) returns true + * @param {Array} arr + * @param {function} test + * @return {* | undefined} Returns the first matching item + * or undefined when there is no match + */ + function findInArray(arr, test) { + for (var i = 0; i < arr.length; i++) { + if (test(arr[i])) { + return arr[i]; + } + } + return undefined; + } + + /** + * Filter unique items of an array with strings + * @param {string[]} arr + * @return {string[]} + */ + function uniq(arr) { + var entries = {} + for (var i = 0; i < arr.length; i++) { + entries[arr[i]] = true; + } + return Object.keys(entries); + } + + /** + * Flat map the result invoking a callback for every item in an array. + * https://gist.github.com/samgiles/762ee337dff48623e729 + * @param {Array} arr + * @param {function} callback + * @return {Array} + */ + function flatMap(arr, callback) { + return Array.prototype.concat.apply([], arr.map(callback)); + } + + /** + * Retrieve the function name from a set of typed functions, + * and check whether the name of all functions match (if given) + * @param {function[]} fns + */ + function getName (fns) { + var name = ''; + + for (var i = 0; i < fns.length; i++) { + var fn = fns[i]; + + // check whether the names are the same when defined + if ((typeof fn.signatures === 'object' || typeof fn.signature === 'string') && fn.name !== '') { + if (name === '') { + name = fn.name; + } + else if (name !== fn.name) { + var err = new Error('Function names do not match (expected: ' + name + ', actual: ' + fn.name + ')'); + err.data = { + actual: fn.name, + expected: name + }; + throw err; + } + } + } + + return name; + } + + // extract and merge all signatures of a list with typed functions + function extractSignatures(fns) { + var err; + var signaturesMap = {}; + + function validateUnique(_signature, _fn) { + if (signaturesMap.hasOwnProperty(_signature) && _fn !== signaturesMap[_signature]) { + err = new Error('Signature "' + _signature + '" is defined twice'); + err.data = {signature: _signature}; + throw err; + // else: both signatures point to the same function, that's fine + } + } + + for (var i = 0; i < fns.length; i++) { + var fn = fns[i]; + + // test whether this is a typed-function + if (typeof fn.signatures === 'object') { + // merge the signatures + for (var signature in fn.signatures) { + if (fn.signatures.hasOwnProperty(signature)) { + validateUnique(signature, fn.signatures[signature]); + signaturesMap[signature] = fn.signatures[signature]; + } + } + } + else if (typeof fn.signature === 'string') { + validateUnique(fn.signature, fn); + signaturesMap[fn.signature] = fn; + } + else { + err = new TypeError('Function is no typed-function (index: ' + i + ')'); + err.data = {index: i}; + throw err; + } + } + + return signaturesMap; + } + + typed = createTypedFunction('typed', { + 'string, Object': createTypedFunction, + 'Object': function (signaturesMap) { + // find existing name + var fns = []; + for (var signature in signaturesMap) { + if (signaturesMap.hasOwnProperty(signature)) { + fns.push(signaturesMap[signature]); + } + } + var name = getName(fns); + return createTypedFunction(name, signaturesMap); + }, + '...Function': function (fns) { + return createTypedFunction(getName(fns), extractSignatures(fns)); + }, + 'string, ...Function': function (name, fns) { + return createTypedFunction(name, extractSignatures(fns)); + } + }); + + typed.create = create; + typed.types = _types; + typed.conversions = _conversions; + typed.ignore = _ignore; + typed.convert = convert; + typed.find = find; + + /** + * add a type + * @param {{name: string, test: function}} type + * @param {boolean} [beforeObjectTest=true] + * If true, the new test will be inserted before + * the test with name 'Object' (if any), since + * tests for Object match Array and classes too. + */ + typed.addType = function (type, beforeObjectTest) { + if (!type || typeof type.name !== 'string' || typeof type.test !== 'function') { + throw new TypeError('Object with properties {name: string, test: function} expected'); + } + + if (beforeObjectTest !== false) { + for (var i = 0; i < typed.types.length; i++) { + if (typed.types[i].name === 'Object') { + typed.types.splice(i, 0, type); + return + } + } + } + + typed.types.push(type); + }; + + // add a conversion + typed.addConversion = function (conversion) { + if (!conversion + || typeof conversion.from !== 'string' + || typeof conversion.to !== 'string' + || typeof conversion.convert !== 'function') { + throw new TypeError('Object with properties {from: string, to: string, convert: function} expected'); + } + + typed.conversions.push(conversion); + }; + + return typed; + } + + return create(); +})); +},{}]},{},[1])(1) +}); |