diff --git a/ajax/libs/mathjs/0.16.0/math.js b/ajax/libs/mathjs/0.16.0/math.js
new file mode 100644
index 000000000..b02d6aaf2
--- /dev/null
+++ b/ajax/libs/mathjs/0.16.0/math.js
@@ -0,0 +1,17806 @@
+/**
+ * math.js
+ * https://github.com/josdejong/mathjs
+ *
+ * Math.js is an extensive math library for JavaScript and Node.js,
+ * It features real and complex numbers, units, matrices, a large set of
+ * mathematical functions, and a flexible expression parser.
+ *
+ * @version 0.16.0
+ * @date    2013-11-28
+ *
+ * @license
+ * Copyright (C) 2013 Jos de Jong <wjosdejong@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy
+ * of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+!function(e){"object"==typeof exports?module.exports=e():"function"==typeof define&&define.amd?define(e):"undefined"!=typeof window?window.mathjs=e():"undefined"!=typeof global?global.mathjs=e():"undefined"!=typeof self&&(self.mathjs=e())}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+module.exports = require('./lib/math.js');
+
+},{"./lib/math.js":201}],2:[function(require,module,exports){
+module.exports = function (math) {
+  var string = require('../util/string');
+
+  /**
+   * @constructor Selector
+   * Wrap any value in a Selector, allowing to perform chained operations on
+   * the value.
+   *
+   * All methods available in the math.js library can be called upon the selector,
+   * and then will be evaluated with the value itself as first argument.
+   * The selector can be closed by executing selector.done(), which will return
+   * the final value.
+   *
+   * The Selector has a number of special functions:
+   * - done()             Finalize the chained operation and return the
+   *                      selectors value.
+   * - valueOf()          The same as done()
+   * - toString()         Returns a string representation of the selectors value.
+   *
+   * @param {*} [value]
+   */
+  function Selector (value) {
+    if (!(this instanceof Selector)) {
+      throw new SyntaxError(
+          'Selector constructor must be called with the new operator');
+    }
+
+    if (value instanceof Selector) {
+      this.value = value.value;
+    }
+    else {
+      this.value = value;
+    }
+  }
+
+  /**
+   * Close the selector. Returns the final value.
+   * Does the same as method valueOf()
+   * @returns {*} value
+   */
+  Selector.prototype.done = function () {
+    return this.value;
+  };
+
+  /**
+   * Get a submatrix or subselection from current value.
+   * Only applicable when the current value has a method get.
+   */
+  // TODO: Selector.get is deprecated since version 0.13.0, remove it some day
+  Selector.prototype.get = function (index) {
+    throw new Error('Selector.get is removed. Use Selector.subset(index) instead.')
+  };
+
+  /**
+   * Set a submatrix or subselection on current value.
+   * Only applicable when the current value has a method set.
+   */
+  // TODO: Selector.get is deprecated since version 0.13.0, remove it some day
+  Selector.prototype.set = function (index, replacement) {
+    throw new Error('Selector.set is removed. Use Selector.subset(index, replacement) instead.')
+  };
+
+  /**
+   * Close the selector. Returns the final value.
+   * Does the same as method done()
+   * @returns {*} value
+   */
+  Selector.prototype.valueOf = function () {
+    return this.value;
+  };
+
+  /**
+   * Get a string representation of the value in the selector
+   * @returns {String}
+   */
+  Selector.prototype.toString = function () {
+    return string.format(this.value);
+  };
+
+  /**
+   * Create a proxy method for the selector
+   * @param {String} name
+   * @param {*} value       The value or function to be proxied
+   */
+  function createProxy(name, value) {
+    var slice = Array.prototype.slice;
+    if (typeof value === 'function') {
+      // a function
+      Selector.prototype[name] = function () {
+        var args = [this.value].concat(slice.call(arguments, 0));
+        return new Selector(value.apply(this, args));
+      }
+    }
+    else {
+      // a constant
+      Selector.prototype[name] = new Selector(value);
+    }
+  }
+
+  Selector.createProxy = createProxy;
+
+  /**
+   * initialise the Chain prototype with all functions and constants in math
+   */
+  for (var prop in math) {
+    if (math.hasOwnProperty(prop) && prop) {
+      createProxy(prop, math[prop]);
+    }
+  }
+
+  return Selector;
+};
+
+},{"../util/string":215}],3:[function(require,module,exports){
+module.exports = function (math) {
+  var Complex = require('./type/Complex');
+
+  math.pi          = Math.PI;
+  math.e           = Math.E;
+  math.tau         = Math.PI * 2;
+  math.i           = new Complex(0, 1);
+
+  math['Infinity'] = Infinity;
+  math['NaN']      = NaN;
+  math['true']     = true;
+  math['false']    = false;
+
+  // uppercase constants (for compatibility with built-in Math)
+  math.E           = Math.E;
+  math.LN2         = Math.LN2;
+  math.LN10        = Math.LN10;
+  math.LOG2E       = Math.LOG2E;
+  math.LOG10E      = Math.LOG10E;
+  math.PI          = Math.PI;
+  math.SQRT1_2     = Math.SQRT1_2;
+  math.SQRT2       = Math.SQRT2;
+};
+
+},{"./type/Complex":202}],4:[function(require,module,exports){
+var Scope = require('./Scope');
+
+/**
+ * @constructor Parser
+ * Parser contains methods to evaluate or parse expressions, and has a number
+ * of convenience methods to get, set, and remove variables from memory. Parser
+ * keeps a scope containing variables in memory, which is used for all
+ * evaluations.
+ *
+ * Methods:
+ *    var result = parser.eval(expr);    // evaluate an expression
+ *    var value = parser.get(name);      // retrieve a variable from the parser
+ *    parser.set(name, value);           // set a variable in the parser
+ *    parser.remove(name);               // clear a variable from the
+ *                                       // parsers scope
+ *    parser.clear();                    // clear the parsers scope
+ *
+ *    // it is possible to parse an expression into a node tree:
+ *    var node = parser.parse(expr);     // parse an expression into a node tree
+ *    var result = node.eval();          // evaluate a parsed node
+ *
+ * Example usage:
+ *    var parser = new Parser(math);
+ *    // Note: there is a convenience method which can be used instead:
+ *    // var parser = new math.parser();
+ *
+ *    // evaluate expressions
+ *    parser.eval('sqrt(3^2 + 4^2)');         // 5
+ *    parser.eval('sqrt(-4)');                // 2i
+ *    parser.eval('2 inch in cm');            // 5.08 cm
+ *    parser.eval('cos(45 deg)');             // 0.7071067811865476
+ *
+ *    // define variables and functions
+ *    parser.eval('x = 7 / 2');               // 3.5
+ *    parser.eval('x + 3');                   // 6.5
+ *    parser.eval('function f(x, y) = x^y');  // f(x, y)
+ *    parser.eval('f(2, 3)');                 // 8
+ *
+ *    // get and set variables and functions
+ *    var x = parser.get('x');                // 7
+ *    var f = parser.get('f');                // function
+ *    var g = f(3, 2);                        // 9
+ *    parser.set('h', 500);
+ *    var i = parser.eval('h / 2');           // 250
+ *    parser.set('hello', function (name) {
+ *        return 'hello, ' + name + '!';
+ *    });
+ *    parser.eval('hello("user")');           // "hello, user!"
+ *
+ *    // clear defined functions and variables
+ *    parser.clear();
+ *
+ *
+ * @param {Object} math     Link to the math.js namespace
+ */
+function Parser(math) {
+  if (!(this instanceof Parser)) {
+    throw new SyntaxError(
+        'Parser constructor must be called with the new operator');
+  }
+
+  this.math = math;
+  this.scope = new Scope(math);
+}
+
+/**
+ * Parse an expression end return the parsed function node.
+ * The node can be evaluated via node.eval()
+ * @param {String} expr
+ * @return {Node} node
+ * @throws {Error}
+ */
+Parser.prototype.parse = function (expr) {
+  // TODO: validate arguments
+  return this.math.parse(expr, this.scope);
+};
+
+/**
+ * Parse and evaluate the given expression
+ * @param {String} expr   A string containing an expression, for example "2+3"
+ * @return {*} result     The result, or undefined when the expression was empty
+ * @throws {Error}
+ */
+Parser.prototype.eval = function (expr) {
+  // TODO: validate arguments
+  var node = this.math.parse(expr, this.scope);
+  return node.eval();
+};
+
+/**
+ * Get a variable (a function or variable) by name from the parsers scope.
+ * Returns undefined when not found
+ * @param {String} name
+ * @return {* | undefined} value
+ */
+Parser.prototype.get = function (name) {
+  // TODO: validate arguments
+  return this.scope.get(name);
+};
+
+/**
+ * Set a symbol (a function or variable) by name from the parsers scope.
+ * @param {String} name
+ * @param {* | undefined} value
+ */
+Parser.prototype.set = function (name, value) {
+  // TODO: validate arguments
+  return this.scope.set(name, value);
+};
+
+/**
+ * Remove a variable from the parsers scope
+ * @param {String} name
+ */
+Parser.prototype.remove = function (name) {
+  // TODO: validate arguments
+  this.scope.remove(name);
+};
+
+/**
+ * Clear the scope with variables and functions
+ */
+Parser.prototype.clear = function () {
+  this.scope.clear();
+};
+
+module.exports = Parser;
+
+},{"./Scope":5}],5:[function(require,module,exports){
+var Unit = require('../type/Unit');
+
+/**
+ * Scope
+ * A scope stores values of symbols: variables and functions.
+ *
+ * Syntax:
+ *     var scope = new Scope(math);
+ *     var scope = new Scope(math, parentScope);
+ *     var scope = new Scope(math, symbols);
+ *     var scope = new Scope(math, parentScope, symbols);
+ *
+ * Where:
+ *     {Object} math                Link to the (static) math.js namespace
+ *     {Scope | Object} parentScope Scope will be linked to a parent scope,
+ *                                  which is traversed when resolving
+ *                                  symbols.
+ *     {Object} symbols             A custom object that will be used to
+ *                                  resolve and store variables.
+ *
+ * @constructor Scope
+ * @param {...} [math]
+ * @param {*} [arg1]
+ * @param {*} [arg2]
+ */
+function Scope(math, arg1, arg2) {
+  this.math = math;
+
+  /** @type {Scope} */
+  this.parentScope = null;
+  // TODO: rename parentScope to previousScope, add a nextScope, change Scope to a linked list node
+
+  /** @type {Scope[]} */
+  this.subScopes = null;
+  // TODO: rename subScopes to childScopes (or childNodes?)
+
+  /** @type {Object.<String, *>} */
+  this.symbols = {};  // variables and functions
+
+  /** @type {Object.<String, Object>} */
+  this.cache = {};    // cache, referring to the scope.symbols object where
+  // a variable was last found
+
+  // read second argument (can be parentScope or symbols map)
+  if (arg1) {
+    if (arg1 instanceof Scope) {
+      this.parentScope = arg1;
+    }
+    else if (arg1 instanceof Object) {
+      this.symbols = arg1;
+    }
+  }
+
+  // read second argument (can be symbols map)
+  if (arg2) {
+    if (arg2 instanceof Object) {
+      this.symbols = arg2;
+    }
+  }
+}
+
+Scope.prototype = {
+  /**
+   * Create a sub scope
+   * The variables in a sub scope are not accessible from the parent scope
+   * @return {Scope} subScope
+   */
+  createSubScope: function () {
+    var subScope = new Scope(this.math, this);
+    if (!this.subScopes) {
+      this.subScopes = [];
+    }
+    this.subScopes.push(subScope);
+    return subScope;
+  },
+
+  /**
+   * Get a symbol value by name.
+   * Returns undefined if the symbol is not found in this scope or any of
+   * its parent scopes.
+   * @param {String} name
+   * @returns {* | undefined} value
+   */
+  get: function (name) {
+    var value;
+
+    // check itself
+    value = this.symbols[name];
+    if (value !== undefined) {
+      return value;
+    }
+
+    // read from cache
+    var symbols = this.cache[name];
+    if (symbols) {
+      return symbols[name];
+    }
+
+    // check parent scope
+    var parent = this.parentScope;
+    while (parent) {
+      value = parent.symbols[name];
+      if (value !== undefined) {
+        this.cache[name] = parent.symbols;
+        return value;
+      }
+      parent = parent.parentScope;
+    }
+
+    // check static context
+    value = this.math[name];
+    if (value !== undefined) {
+      this.cache[name] = this.math;
+      return value;
+    }
+
+    // check if name is a unit
+    if (Unit.isPlainUnit(name)) {
+      value = new Unit(null, name);
+      this.cache[name] = {};
+      this.cache[name][name] = value;
+      return value;
+    }
+
+    return undefined;
+  },
+
+  /**
+   * Test whether this scope contains a symbol (will not check parent scopes)
+   * @param {String} name
+   * @return {Boolean} hasSymbol
+   */
+  has: function (name) {
+    return (this.symbols[name] !== undefined);
+  },
+
+  /**
+   * Set a symbol value
+   * @param {String} name
+   * @param {*} value
+   * @return {*} value
+   */
+  set: function (name, value) {
+    return this.symbols[name] = value;
+  },
+
+  /**
+   * Remove a symbol by name
+   * @param {String} name
+   */
+  remove: function(name) {
+    delete this.symbols[name];
+  },
+
+  /**
+   * Clear all symbols in this scope, its sub scopes, and clear the cache.
+   * Parent scopes will not be cleared.
+   */
+  clear: function () {
+    var symbols = this.symbols;
+    for (var name in symbols) {
+      if (symbols.hasOwnProperty(name)) {
+        delete symbols[name];
+      }
+    }
+
+    if (this.subScopes) {
+      var subScopes = this.subScopes;
+      for (var i = 0, iMax = subScopes.length; i < iMax; i++) {
+        subScopes[i].clear();
+      }
+    }
+
+    this.clearCache();
+  },
+
+  /**
+   * Clear cached links to symbols in other scopes
+   */
+  clearCache: function () {
+    this.cache = {};
+  }
+};
+
+Scope.context = []; // static context, for example the math namespace
+
+module.exports = Scope;
+
+},{"../type/Unit":207}],6:[function(require,module,exports){
+module.exports = {
+  'name': 'Infinity',
+  'category': 'Constants',
+  'syntax': [
+    'Infinity'
+  ],
+  'description': 'Infinity, a number which is larger than the maximum number that can be handled by a floating point number.',
+  'examples': [
+    'Infinity',
+    '1 / 0'
+  ],
+  'seealso': []
+};
+
+},{}],7:[function(require,module,exports){
+module.exports = {
+  'name': 'LN10',
+  'category': 'Constants',
+  'syntax': [
+    'LN10'
+  ],
+  'description': 'Returns the natural logarithm of 10, approximately equal to 2.302',
+  'examples': [
+    'LN10',
+    'log(10)'
+  ],
+  'seealso': []
+};
+
+},{}],8:[function(require,module,exports){
+module.exports = {
+  'name': 'LN2',
+  'category': 'Constants',
+  'syntax': [
+    'LN2'
+  ],
+  'description': 'Returns the natural logarithm of 2, approximately equal to 0.693',
+  'examples': [
+    'LN2',
+    'log(2)'
+  ],
+  'seealso': []
+};
+
+},{}],9:[function(require,module,exports){
+module.exports = {
+  'name': 'LOG10E',
+  'category': 'Constants',
+  'syntax': [
+    'LOG10E'
+  ],
+  'description': 'Returns the base-10 logarithm of E, approximately equal to 0.434',
+  'examples': [
+    'LOG10E',
+    'log(e, 10)'
+  ],
+  'seealso': []
+};
+
+},{}],10:[function(require,module,exports){
+module.exports = {
+  'name': 'LOG2E',
+  'category': 'Constants',
+  'syntax': [
+    'LOG2E'
+  ],
+  'description': 'Returns the base-2 logarithm of E, approximately equal to 1.442',
+  'examples': [
+    'LOG2E',
+    'log(e, 2)'
+  ],
+  'seealso': []
+};
+
+},{}],11:[function(require,module,exports){
+module.exports = {
+  'name': 'NaN',
+  'category': 'Constants',
+  'syntax': [
+    'NaN'
+  ],
+  'description': 'Not a number',
+  'examples': [
+    'NaN',
+    '0 / 0'
+  ],
+  'seealso': []
+};
+
+},{}],12:[function(require,module,exports){
+module.exports = {
+  'name': 'SQRT1_2',
+  'category': 'Constants',
+  'syntax': [
+    'SQRT1_2'
+  ],
+  'description': 'Returns the square root of 1/2, approximately equal to 0.707',
+  'examples': [
+    'SQRT1_2',
+    'sqrt(1/2)'
+  ],
+  'seealso': []
+};
+
+},{}],13:[function(require,module,exports){
+module.exports = {
+  'name': 'SQRT2',
+  'category': 'Constants',
+  'syntax': [
+    'SQRT2'
+  ],
+  'description': 'Returns the square root of 2, approximately equal to 1.414',
+  'examples': [
+    'SQRT2',
+    'sqrt(2)'
+  ],
+  'seealso': []
+};
+
+},{}],14:[function(require,module,exports){
+module.exports = {
+  'name': 'e',
+  'category': 'Constants',
+  'syntax': [
+    'e'
+  ],
+  'description': 'Euler\'s number, the base of the natural logarithm. Approximately equal to 2.71828',
+  'examples': [
+    'e',
+    'e ^ 2',
+    'exp(2)',
+    'log(e)'
+  ],
+  'seealso': ['exp']
+};
+
+},{}],15:[function(require,module,exports){
+module.exports = {
+  'name': 'false',
+  'category': 'Constants',
+  'syntax': [
+    'false'
+  ],
+  'description': 'Boolean value false',
+  'examples': [
+    'false'
+  ],
+  'seealso': ['true']
+};
+
+},{}],16:[function(require,module,exports){
+module.exports = {
+  'name': 'i',
+  'category': 'Constants',
+  'syntax': [
+    'i'
+  ],
+  'description': 'Imaginary unit, defined as i*i=-1. A complex number is described as a + b*i, where a is the real part, and b is the imaginary part.',
+  'examples': [
+    'i',
+    'i * i',
+    'sqrt(-1)'
+  ],
+  'seealso': []
+};
+
+},{}],17:[function(require,module,exports){
+module.exports = {
+  'name': 'pi',
+  'category': 'Constants',
+  'syntax': [
+    'pi'
+  ],
+  'description': 'The number pi is a mathematical constant that is the ratio of a circle\'s circumference to its diameter, and is approximately equal to 3.14159',
+  'examples': [
+    'pi',
+    'sin(pi/2)'
+  ],
+  'seealso': ['tau']
+};
+
+},{}],18:[function(require,module,exports){
+module.exports = {
+  'name': 'tau',
+  'category': 'Constants',
+  'syntax': [
+    'pi'
+  ],
+  'description': 'Tau is the ratio constant of a circle\'s circumference to radius, equal to 2 * pi, approximately 6.2832.',
+  'examples': [
+    'tau',
+    '2 * pi'
+  ],
+  'seealso': ['pi']
+};
+
+},{}],19:[function(require,module,exports){
+module.exports = {
+  'name': 'true',
+  'category': 'Constants',
+  'syntax': [
+    'true'
+  ],
+  'description': 'Boolean value true',
+  'examples': [
+    'true'
+  ],
+  'seealso': ['false']
+};
+
+},{}],20:[function(require,module,exports){
+module.exports = {
+  'name': 'abs',
+  'category': 'Arithmetic',
+  'syntax': [
+    'abs(x)'
+  ],
+  'description': 'Compute the absolute value.',
+  'examples': [
+    'abs(3.5)',
+    'abs(-4.2)'
+  ],
+  'seealso': ['sign']
+};
+
+},{}],21:[function(require,module,exports){
+module.exports = {
+  'name': 'add',
+  'category': 'Operators',
+  'syntax': [
+    'x + y',
+    'add(x, y)'
+  ],
+  'description': 'Add two values.',
+  'examples': [
+    '2.1 + 3.6',
+    'ans - 3.6',
+    '3 + 2i',
+    '"hello" + " world"',
+    '3 cm + 2 inch'
+  ],
+  'seealso': [
+    'subtract'
+  ]
+};
+
+},{}],22:[function(require,module,exports){
+module.exports = {
+  'name': 'ceil',
+  'category': 'Arithmetic',
+  'syntax': [
+    'ceil(x)'
+  ],
+  'description':
+      'Round a value towards plus infinity.If x is complex, both real and imaginary part are rounded towards plus infinity.',
+  'examples': [
+    'ceil(3.2)',
+    'ceil(3.8)',
+    'ceil(-4.2)'
+  ],
+  'seealso': ['floor', 'fix', 'round']
+};
+
+},{}],23:[function(require,module,exports){
+module.exports = {
+  'name': 'cube',
+  'category': 'Arithmetic',
+  'syntax': [
+    'cube(x)'
+  ],
+  'description': 'Compute the cube of a value. The cube of x is x * x * x.',
+  'examples': [
+    'cube(2)',
+    '2^3',
+    '2 * 2 * 2'
+  ],
+  'seealso': [
+    'multiply',
+    'square',
+    'pow'
+  ]
+};
+
+},{}],24:[function(require,module,exports){
+module.exports = {
+  'name': 'divide',
+  'category': 'Operators',
+  'syntax': [
+    'x / y',
+    'divide(x, y)'
+  ],
+  'description': 'Divide two values.',
+  'examples': [
+    '2 / 3',
+    'ans * 3',
+    '4.5 / 2',
+    '3 + 4 / 2',
+    '(3 + 4) / 2',
+    '18 km / 4.5'
+  ],
+  'seealso': [
+    'multiply'
+  ]
+};
+
+},{}],25:[function(require,module,exports){
+module.exports = {
+  'name': 'edivide',
+  'category': 'Operators',
+  'syntax': [
+    'x ./ y',
+    'edivide(x, y)'
+  ],
+  'description': 'divide two values element wise.',
+  'examples': [
+    'a = [1, 2, 3; 4, 5, 6]',
+    'b = [2, 1, 1; 3, 2, 5]',
+    'a ./ b'
+  ],
+  'seealso': [
+    'multiply',
+    'emultiply',
+    'divide'
+  ]
+};
+
+},{}],26:[function(require,module,exports){
+module.exports = {
+  'name': 'emultiply',
+  'category': 'Operators',
+  'syntax': [
+    'x .* y',
+    'emultiply(x, y)'
+  ],
+  'description': 'multiply two values element wise.',
+  'examples': [
+    'a = [1, 2, 3; 4, 5, 6]',
+    'b = [2, 1, 1; 3, 2, 5]',
+    'a .* b'
+  ],
+  'seealso': [
+    'multiply',
+    'divide',
+    'edivide'
+  ]
+};
+
+},{}],27:[function(require,module,exports){
+module.exports = {
+  'name': 'epow',
+  'category': 'Operators',
+  'syntax': [
+    'x .^ y',
+    'epow(x, y)'
+  ],
+  'description':
+      'Calculates the power of x to y element wise.',
+  'examples': [
+    'a = [1, 2, 3; 4, 5, 6]',
+    'a .^ 2'
+  ],
+  'seealso': [
+    'pow'
+  ]
+};
+
+},{}],28:[function(require,module,exports){
+module.exports = {
+  'name': 'equal',
+  'category': 'Operators',
+  'syntax': [
+    'x == y',
+    'equal(x, y)'
+  ],
+  'description':
+      'Check equality of two values. Returns 1 if the values are equal, and 0 if not.',
+  'examples': [
+    '2+2 == 3',
+    '2+2 == 4',
+    'a = 3.2',
+    'b = 6-2.8',
+    'a == b',
+    '50cm == 0.5m'
+  ],
+  'seealso': [
+    'unequal', 'smaller', 'larger', 'smallereq', 'largereq'
+  ]
+};
+
+},{}],29:[function(require,module,exports){
+module.exports = {
+  'name': 'exp',
+  'category': 'Arithmetic',
+  'syntax': [
+    'exp(x)'
+  ],
+  'description': 'Calculate the exponent of a value.',
+  'examples': [
+    'exp(1.3)',
+    'e ^ 1.3',
+    'log(exp(1.3))',
+    'x = 2.4',
+    '(exp(i*x) == cos(x) + i*sin(x))   # Euler\'s formula'
+  ],
+  'seealso': [
+    'square',
+    'multiply',
+    'log'
+  ]
+};
+
+},{}],30:[function(require,module,exports){
+module.exports = {
+  'name': 'fix',
+  'category': 'Arithmetic',
+  'syntax': [
+    'fix(x)'
+  ],
+  'description':
+      'Round a value towards zero.If x is complex, both real and imaginary part are rounded towards zero.',
+  'examples': [
+    'fix(3.2)',
+    'fix(3.8)',
+    'fix(-4.2)',
+    'fix(-4.8)'
+  ],
+  'seealso': ['ceil', 'floor', 'round']
+};
+
+},{}],31:[function(require,module,exports){
+module.exports = {
+  'name': 'floor',
+  'category': 'Arithmetic',
+  'syntax': [
+    'floor(x)'
+  ],
+  'description':
+      'Round a value towards minus infinity.If x is complex, both real and imaginary part are rounded towards minus infinity.',
+  'examples': [
+    'floor(3.2)',
+    'floor(3.8)',
+    'floor(-4.2)'
+  ],
+  'seealso': ['ceil', 'fix', 'round']
+};
+
+},{}],32:[function(require,module,exports){
+module.exports = {
+  'name': 'gcd',
+  'category': 'Arithmetic',
+  'syntax': [
+    'gcd(a, b)',
+    'gcd(a, b, c, ...)'
+  ],
+  'description': 'Compute the greatest common divisor.',
+  'examples': [
+    'gcd(8, 12)',
+    'gcd(-4, 6)',
+    'gcd(25, 15, -10)'
+  ],
+  'seealso': [ 'lcm', 'xgcd' ]
+};
+
+},{}],33:[function(require,module,exports){
+module.exports = {
+  'name': 'larger',
+  'category': 'Operators',
+  'syntax': [
+    'x > y',
+    'larger(x, y)'
+  ],
+  'description':
+      'Check if value x is larger than y. Returns 1 if x is larger than y, and 0 if not.',
+  'examples': [
+    '2 > 3',
+    '5 > 2*2',
+    'a = 3.3',
+    'b = 6-2.8',
+    '(a > b)',
+    '(b < a)',
+    '5 cm > 2 inch'
+  ],
+  'seealso': [
+    'equal', 'unequal', 'smaller', 'smallereq', 'largereq'
+  ]
+};
+
+},{}],34:[function(require,module,exports){
+module.exports = {
+  'name': 'largereq',
+  'category': 'Operators',
+  'syntax': [
+    'x >= y',
+    'largereq(x, y)'
+  ],
+  'description':
+      'Check if value x is larger or equal to y. Returns 1 if x is larger or equal to y, and 0 if not.',
+  'examples': [
+    '2 > 1+1',
+    '2 >= 1+1',
+    'a = 3.2',
+    'b = 6-2.8',
+    '(a > b)'
+  ],
+  'seealso': [
+    'equal', 'unequal', 'smallereq', 'smaller', 'largereq'
+  ]
+};
+
+},{}],35:[function(require,module,exports){
+module.exports = {
+  'name': 'lcm',
+  'category': 'Arithmetic',
+  'syntax': [
+    'lcm(x, y)'
+  ],
+  'description': 'Compute the least common multiple.',
+  'examples': [
+    'lcm(4, 6)',
+    'lcm(6, 21)',
+    'lcm(6, 21, 5)'
+  ],
+  'seealso': [ 'gcd' ]
+};
+
+},{}],36:[function(require,module,exports){
+module.exports = {
+  'name': 'log',
+  'category': 'Arithmetic',
+  'syntax': [
+    'log(x)',
+    'log(x, base)'
+  ],
+  'description': 'Compute the logarithm of a value. If no base is provided, the natural logarithm of x is calculated. If base if provided, the logarithm is calculated for the specified base. log(x, base) is defined as log(x) / log(base).',
+  'examples': [
+    'log(3.5)',
+    'a = log(2.4)',
+    'exp(a)',
+    '10 ^ 3',
+    'log(1000, 10)',
+    'log(1000) / log(10)',
+    'b = logb(1024, 2)',
+    '2 ^ b'
+  ],
+  'seealso': [
+    'exp',
+    'log10'
+  ]
+};
+},{}],37:[function(require,module,exports){
+module.exports = {
+  'name': 'log10',
+  'category': 'Arithmetic',
+  'syntax': [
+    'log10(x)'
+  ],
+  'description': 'Compute the 10-base logarithm of a value.',
+  'examples': [
+    'log10(1000)',
+    '10 ^ 3',
+    'log10(0.01)',
+    'log(1000) / log(10)',
+    'log(1000, 10)'
+  ],
+  'seealso': [
+    'exp',
+    'log'
+  ]
+};
+
+},{}],38:[function(require,module,exports){
+module.exports = {
+  'name': 'mod',
+  'category': 'Operators',
+  'syntax': [
+    'x % y',
+    'x mod y',
+    'mod(x, y)'
+  ],
+  'description':
+      'Calculates the modulus, the remainder of an integer division.',
+  'examples': [
+    '7 % 3',
+    '11 % 2',
+    '10 mod 4',
+    'function isOdd(x) = x % 2',
+    'isOdd(2)',
+    'isOdd(3)'
+  ],
+  'seealso': []
+};
+
+},{}],39:[function(require,module,exports){
+module.exports = {
+  'name': 'multiply',
+  'category': 'Operators',
+  'syntax': [
+    'x * y',
+    'multiply(x, y)'
+  ],
+  'description': 'multiply two values.',
+  'examples': [
+    '2.1 * 3.6',
+    'ans / 3.6',
+    '2 * 3 + 4',
+    '2 * (3 + 4)',
+    '3 * 2.1 km'
+  ],
+  'seealso': [
+    'divide'
+  ]
+};
+
+},{}],40:[function(require,module,exports){
+module.exports = {
+  'name': 'pow',
+  'category': 'Operators',
+  'syntax': [
+    'x ^ y',
+    'pow(x, y)'
+  ],
+  'description':
+      'Calculates the power of x to y, x^y.',
+  'examples': [
+    '2^3 = 8',
+    '2*2*2',
+    '1 + e ^ (pi * i)'
+  ],
+  'seealso': [
+    'unequal', 'smaller', 'larger', 'smallereq', 'largereq'
+  ]
+};
+
+},{}],41:[function(require,module,exports){
+module.exports = {
+  'name': 'round',
+  'category': 'Arithmetic',
+  'syntax': [
+    'round(x)',
+    'round(x, n)'
+  ],
+  'description':
+      'round a value towards the nearest integer.If x is complex, both real and imaginary part are rounded towards the nearest integer. When n is specified, the value is rounded to n decimals.',
+  'examples': [
+    'round(3.2)',
+    'round(3.8)',
+    'round(-4.2)',
+    'round(-4.8)',
+    'round(pi, 3)',
+    'round(123.45678, 2)'
+  ],
+  'seealso': ['ceil', 'floor', 'fix']
+};
+
+},{}],42:[function(require,module,exports){
+module.exports = {
+  'name': 'sign',
+  'category': 'Arithmetic',
+  'syntax': [
+    'sign(x)'
+  ],
+  'description':
+      'Compute the sign of a value. The sign of a value x is 1 when x>1, -1 when x<0, and 0 when x=0.',
+  'examples': [
+    'sign(3.5)',
+    'sign(-4.2)',
+    'sign(0)'
+  ],
+  'seealso': [
+    'abs'
+  ]
+};
+
+},{}],43:[function(require,module,exports){
+module.exports = {
+  'name': 'smaller',
+  'category': 'Operators',
+  'syntax': [
+    'x < y',
+    'smaller(x, y)'
+  ],
+  'description':
+      'Check if value x is smaller than value y. Returns 1 if x is smaller than y, and 0 if not.',
+  'examples': [
+    '2 < 3',
+    '5 < 2*2',
+    'a = 3.3',
+    'b = 6-2.8',
+    '(a < b)',
+    '5 cm < 2 inch'
+  ],
+  'seealso': [
+    'equal', 'unequal', 'larger', 'smallereq', 'largereq'
+  ]
+};
+
+},{}],44:[function(require,module,exports){
+module.exports = {
+  'name': 'smallereq',
+  'category': 'Operators',
+  'syntax': [
+    'x <= y',
+    'smallereq(x, y)'
+  ],
+  'description':
+      'Check if value x is smaller or equal to value y. Returns 1 if x is smaller than y, and 0 if not.',
+  'examples': [
+    '2 < 1+1',
+    '2 <= 1+1',
+    'a = 3.2',
+    'b = 6-2.8',
+    '(a < b)'
+  ],
+  'seealso': [
+    'equal', 'unequal', 'larger', 'smaller', 'largereq'
+  ]
+};
+
+},{}],45:[function(require,module,exports){
+module.exports = {
+  'name': 'sqrt',
+  'category': 'Arithmetic',
+  'syntax': [
+    'sqrt(x)'
+  ],
+  'description':
+      'Compute the square root value. If x = y * y, then y is the square root of x.',
+  'examples': [
+    'sqrt(25)',
+    '5 * 5',
+    'sqrt(-1)'
+  ],
+  'seealso': [
+    'square',
+    'multiply'
+  ]
+};
+
+},{}],46:[function(require,module,exports){
+module.exports = {
+  'name': 'square',
+  'category': 'Arithmetic',
+  'syntax': [
+    'square(x)'
+  ],
+  'description':
+      'Compute the square of a value. The square of x is x * x.',
+  'examples': [
+    'square(3)',
+    'sqrt(9)',
+    '3^2',
+    '3 * 3'
+  ],
+  'seealso': [
+    'multiply',
+    'pow',
+    'sqrt',
+    'cube'
+  ]
+};
+
+},{}],47:[function(require,module,exports){
+module.exports = {
+  'name': 'subtract',
+  'category': 'Operators',
+  'syntax': [
+    'x - y',
+    'subtract(x, y)'
+  ],
+  'description': 'subtract two values.',
+  'examples': [
+    '5.3 - 2',
+    'ans + 2',
+    '2/3 - 1/6',
+    '2 * 3 - 3',
+    '2.1 km - 500m'
+  ],
+  'seealso': [
+    'add'
+  ]
+};
+
+},{}],48:[function(require,module,exports){
+module.exports = {
+  'name': 'unary',
+  'category': 'Operators',
+  'syntax': [
+    '-x',
+    'unary(x)'
+  ],
+  'description':
+      'Inverse the sign of a value.',
+  'examples': [
+    '-4.5',
+    '-(-5.6)'
+  ],
+  'seealso': [
+    'add', 'subtract'
+  ]
+};
+
+},{}],49:[function(require,module,exports){
+module.exports = {
+  'name': 'unequal',
+  'category': 'Operators',
+  'syntax': [
+    'x != y',
+    'unequal(x, y)'
+  ],
+  'description':
+      'Check unequality of two values. Returns 1 if the values are unequal, and 0 if they are equal.',
+  'examples': [
+    '2+2 != 3',
+    '2+2 != 4',
+    'a = 3.2',
+    'b = 6-2.8',
+    'a != b',
+    '50cm != 0.5m',
+    '5 cm != 2 inch'
+  ],
+  'seealso': [
+    'equal', 'smaller', 'larger', 'smallereq', 'largereq'
+  ]
+};
+
+},{}],50:[function(require,module,exports){
+module.exports = {
+  'name': 'xgcd',
+  'category': 'Arithmetic',
+  'syntax': [
+    'xgcd(a, b)'
+  ],
+  'description': 'Calculate the extended greatest common divisor for two values',
+  'examples': [
+    'xgcd(8, 12)',
+    'gcd(8, 12)',
+    'xgcd(36163, 21199)'
+  ],
+  'seealso': [ 'gcd', 'lcm' ]
+};
+
+},{}],51:[function(require,module,exports){
+module.exports = {
+  'name': 'arg',
+  'category': 'Complex',
+  'syntax': [
+    'arg(x)'
+  ],
+  'description':
+      'Compute the argument of a complex value. If x = a+bi, the argument is computed as atan2(b, a).',
+  'examples': [
+    'arg(2 + 2i)',
+    'atan2(3, 2)',
+    'arg(2 - 3i)'
+  ],
+  'seealso': [
+    're',
+    'im',
+    'conj',
+    'abs'
+  ]
+};
+
+},{}],52:[function(require,module,exports){
+module.exports = {
+  'name': 'conj',
+  'category': 'Complex',
+  'syntax': [
+    'conj(x)'
+  ],
+  'description':
+      'Compute the complex conjugate of a complex value. If x = a+bi, the complex conjugate is a-bi.',
+  'examples': [
+    'conj(2 + 3i)',
+    'conj(2 - 3i)',
+    'conj(-5.2i)'
+  ],
+  'seealso': [
+    're',
+    'im',
+    'abs',
+    'arg'
+  ]
+};
+
+},{}],53:[function(require,module,exports){
+module.exports = {
+  'name': 'im',
+  'category': 'Complex',
+  'syntax': [
+    'im(x)'
+  ],
+  'description': 'Get the imaginary part of a complex number.',
+  'examples': [
+    'im(2 + 3i)',
+    're(2 + 3i)',
+    'im(-5.2i)',
+    'im(2.4)'
+  ],
+  'seealso': [
+    're',
+    'conj',
+    'abs',
+    'arg'
+  ]
+};
+
+},{}],54:[function(require,module,exports){
+module.exports = {
+  'name': 're',
+  'category': 'Complex',
+  'syntax': [
+    're(x)'
+  ],
+  'description': 'Get the real part of a complex number.',
+  'examples': [
+    're(2 + 3i)',
+    'im(2 + 3i)',
+    're(-5.2i)',
+    're(2.4)'
+  ],
+  'seealso': [
+    'im',
+    'conj',
+    'abs',
+    'arg'
+  ]
+};
+
+},{}],55:[function(require,module,exports){
+module.exports = {
+  'name': 'bignumber',
+  'category': 'Type',
+  'syntax': [
+    'bignumber(x)'
+  ],
+  'description':
+      'Create a big number from a number or string.',
+  'examples': [
+    '0.1 + 0.2',
+    'bignumber(0.1) + bignumber(0.2)',
+    'bignumber("7.2")',
+    'bignumber("7.2e500")',
+    'bignumber([0.1, 0.2, 0.3])'
+  ],
+  'seealso': [
+    'boolean', 'complex', 'index', 'matrix', 'string', 'unit'
+  ]
+};
+
+},{}],56:[function(require,module,exports){
+module.exports = {
+  'name': 'boolean',
+  'category': 'Type',
+  'syntax': [
+    'x',
+    'boolean(x)'
+  ],
+  'description':
+      'Convert a string or number into a boolean.',
+  'examples': [
+    'boolean(0)',
+    'boolean(1)',
+    'boolean(3)',
+    'boolean("true")',
+    'boolean("false")',
+    'boolean([1, 0, 1, 1])'
+  ],
+  'seealso': [
+    'bignumber', 'complex', 'index', 'matrix', 'number', 'string', 'unit'
+  ]
+};
+
+},{}],57:[function(require,module,exports){
+module.exports = {
+  'name': 'complex',
+  'category': 'Type',
+  'syntax': [
+    'complex()',
+    'complex(re, im)',
+    'complex(string)'
+  ],
+  'description':
+      'Create a complex number.',
+  'examples': [
+    'complex()',
+    'complex(2, 3)',
+    'complex("7 - 2i")'
+  ],
+  'seealso': [
+    'bignumber', 'boolean', 'index', 'matrix', 'number', 'string', 'unit'
+  ]
+};
+
+},{}],58:[function(require,module,exports){
+module.exports = {
+  'name': 'index',
+  'category': 'Type',
+  'syntax': [
+    '[start]',
+    '[start:end]',
+    '[start:step:end]',
+    '[start1, start 2, ...]',
+    '[start1:end1, start2:end2, ...]',
+    '[start1:step1:end1, start2:step2:end2, ...]'
+  ],
+  'description':
+      'Create an index to get or replace a subset of a matrix',
+  'examples': [
+    '[]',
+    '[1, 2, 3]',
+    'A = [1, 2, 3; 4, 5, 6]',
+    'A[1, :]',
+    'A[1, 2] = 50',
+    'A[0:2, 0:2] = ones(2, 2)'
+  ],
+  'seealso': [
+    'bignumber', 'boolean', 'complex', 'matrix,', 'number', 'range', 'string', 'unit'
+  ]
+};
+
+},{}],59:[function(require,module,exports){
+module.exports = {
+  'name': 'matrix',
+  'category': 'Type',
+  'syntax': [
+    '[]',
+    '[a1, b1, ...; a2, b2, ...]',
+    'matrix()',
+    'matrix([...])'
+  ],
+  'description':
+      'Create a matrix.',
+  'examples': [
+    '[]',
+    '[1, 2, 3]',
+    '[1, 2, 3; 4, 5, 6]',
+    'matrix()',
+    'matrix([3, 4])'
+  ],
+  'seealso': [
+    'bignumber', 'boolean', 'complex', 'index', 'number', 'string', 'unit'
+  ]
+};
+
+},{}],60:[function(require,module,exports){
+module.exports = {
+  'name': 'number',
+  'category': 'Type',
+  'syntax': [
+    'x',
+    'number(x)'
+  ],
+  'description':
+      'Create a number or convert a string or boolean into a number.',
+  'examples': [
+    '2',
+    '2e3',
+    '4.05',
+    'number(2)',
+    'number("7.2")',
+    'number(true)',
+    'number([true, false, true, true])'
+  ],
+  'seealso': [
+    'bignumber', 'boolean', 'complex', 'index', 'matrix', 'string', 'unit'
+  ]
+};
+
+},{}],61:[function(require,module,exports){
+module.exports = {
+  'name': 'string',
+  'category': 'Type',
+  'syntax': [
+    '"text"',
+    'string(x)'
+  ],
+  'description':
+      'Create a string or convert a value to a string',
+  'examples': [
+    '"Hello World!"',
+    'string(4.2)',
+    'string(3 + 2i)'
+  ],
+  'seealso': [
+    'bignumber', 'boolean', 'complex', 'index', 'matrix', 'number', 'unit'
+  ]
+};
+
+},{}],62:[function(require,module,exports){
+module.exports = {
+  'name': 'unit',
+  'category': 'Type',
+  'syntax': [
+    'value unit',
+    'unit(value, unit)',
+    'unit(string)'
+  ],
+  'description':
+      'Create a unit.',
+  'examples': [
+    '5.5 mm',
+    '3 inch',
+    'unit(7.1, "kilogram")',
+    'unit("23 deg")'
+  ],
+  'seealso': [
+    'bignumber', 'boolean', 'complex', 'index', 'matrix', 'number', 'string'
+  ]
+};
+
+},{}],63:[function(require,module,exports){
+module.exports = {
+  'name': 'eval',
+  'category': 'Expression',
+  'syntax': [
+    'eval(expression)',
+    'eval([expr1, expr2, expr3, ...])'
+  ],
+  'description': 'Evaluate an expression or an array with expressions.',
+  'examples': [
+    'eval("2 + 3")',
+    'eval("sqrt(" + 4 + ")")'
+  ],
+  'seealso': []
+};
+
+},{}],64:[function(require,module,exports){
+module.exports = {
+  'name': 'help',
+  'category': 'Expression',
+  'syntax': [
+    'help(object)',
+    'help(string)'
+  ],
+  'description': 'Display documentation on a function or data type.',
+  'examples': [
+    'help(sqrt)',
+    'help("complex")'
+  ],
+  'seealso': []
+};
+
+},{}],65:[function(require,module,exports){
+module.exports = {
+  'name': 'concat',
+  'category': 'Matrix',
+  'syntax': [
+    'concat(a, b, c, ...)',
+    'concat(a, b, c, ..., dim)'
+  ],
+  'description': 'Concatenate matrices. By default, the matrices are concatenated by the first dimension. The dimension on which to concatenate can be provided as last argument.',
+  'examples': [
+    'a = [1, 2; 5, 6]',
+    'b = [3, 4; 7, 8]',
+    'concat(a, b)',
+    '[a, b]',
+    'concat(a, b, 2)',
+    '[a; b]'
+  ],
+  'seealso': [
+    'det', 'diag', 'eye', 'inv', 'ones', 'range', 'size', 'squeeze', 'subset', 'transpose', 'zeros'
+  ]
+};
+
+},{}],66:[function(require,module,exports){
+module.exports = {
+  'name': 'det',
+  'category': 'Matrix',
+  'syntax': [
+    'det(x)'
+  ],
+  'description': 'Calculate the determinant of a matrix',
+  'examples': [
+    'det([1, 2; 3, 4])',
+    'det([-2, 2, 3; -1, 1, 3; 2, 0, -1])'
+  ],
+  'seealso': [
+    'concat', 'diag', 'eye', 'inv', 'ones', 'range', 'size', 'squeeze', 'subset', 'transpose', 'zeros'
+  ]
+};
+
+},{}],67:[function(require,module,exports){
+module.exports = {
+  'name': 'diag',
+  'category': 'Matrix',
+  'syntax': [
+    'diag(x)',
+    'diag(x, k)'
+  ],
+  'description': 'Create a diagonal matrix or retrieve the diagonal of a matrix. When x is a vector, a matrix with the vector values on the diagonal will be returned. When x is a matrix, a vector with the diagonal values of the matrix is returned.When k is provided, the k-th diagonal will be filled in or retrieved, if k is positive, the values are placed on the super diagonal. When k is negative, the values are placed on the sub diagonal.',
+  'examples': [
+    'diag(1:3)',
+    'diag(1:3, 1)',
+    'a = [1, 2, 3; 4, 5, 6; 7, 8, 9]',
+    'diag(a)'
+  ],
+  'seealso': [
+    'concat', 'det', 'eye', 'inv', 'ones', 'range', 'size', 'squeeze', 'subset', 'transpose', 'zeros'
+  ]
+};
+
+},{}],68:[function(require,module,exports){
+module.exports = {
+  'name': 'eye',
+  'category': 'Matrix',
+  'syntax': [
+    'eye(n)',
+    'eye(m, n)',
+    'eye([m, n])',
+    'eye'
+  ],
+  'description': 'Returns the identity matrix with size m-by-n. The matrix has ones on the diagonal and zeros elsewhere.',
+  'examples': [
+    'eye(3)',
+    'eye(3, 5)',
+    'a = [1, 2, 3; 4, 5, 6]',
+    'eye(size(a))'
+  ],
+  'seealso': [
+    'concat', 'det', 'diag', 'inv', 'ones', 'range', 'size', 'squeeze', 'subset', 'transpose', 'zeros'
+  ]
+};
+
+},{}],69:[function(require,module,exports){
+module.exports = {
+  'name': 'inv',
+  'category': 'Matrix',
+  'syntax': [
+    'inv(x)'
+  ],
+  'description': 'Calculate the inverse of a matrix',
+  'examples': [
+    'inv([1, 2; 3, 4])',
+    'inv(4)',
+    '1 / 4'
+  ],
+  'seealso': [
+    'concat', 'det', 'diag', 'eye', 'ones', 'range', 'size', 'squeeze', 'subset', 'transpose', 'zeros'
+  ]
+};
+
+},{}],70:[function(require,module,exports){
+module.exports = {
+  'name': 'ones',
+  'category': 'Matrix',
+  'syntax': [
+    'ones(m)',
+    'ones(m, n)',
+    'ones(m, n, p, ...)',
+    'ones([m])',
+    'ones([m, n])',
+    'ones([m, n, p, ...])',
+    'ones'
+  ],
+  'description': 'Create a matrix containing ones.',
+  'examples': [
+    'ones(3)',
+    'ones(3, 5)',
+    'ones([2,3]) * 4.5',
+    'a = [1, 2, 3; 4, 5, 6]',
+    'ones(size(a))'
+  ],
+  'seealso': [
+    'concat', 'det', 'diag', 'eye', 'inv', 'range', 'size', 'squeeze', 'subset', 'transpose', 'zeros'
+  ]
+};
+
+},{}],71:[function(require,module,exports){
+module.exports = {
+  'name': 'range',
+  'category': 'Type',
+  'syntax': [
+    'start:end',
+    'start:step:end',
+    'range(start, end)',
+    'range(start, end, step)',
+    'range(string)'
+  ],
+  'description':
+      'Create a range. Lower bound of the range is included, upper bound is excluded.',
+  'examples': [
+    '1:5',
+    '3:-1:-3',
+    'range(3, 7)',
+    'range(0, 12, 2)',
+    'range("4:10")',
+    'a = [1, 2, 3, 4; 5, 6, 7, 8]',
+    'a(1:2, 1:2)'
+  ],
+  'seealso': [
+    'concat', 'det', 'diag', 'eye', 'inv', 'ones', 'size', 'squeeze', 'subset', 'transpose', 'zeros'
+  ]
+};
+
+},{}],72:[function(require,module,exports){
+module.exports = {
+  'name': 'resize',
+  'category': 'Matrix',
+  'syntax': [
+    'resize(x, size)',
+    'resize(x, size, defaultValue)'
+  ],
+  'description': 'Resize a matrix.',
+  'examples': [
+    'resize([1,2,3,4,5], [3])',
+    'resize([1,2,3], [5], 0)',
+    'resize(2, [2, 3], 0)',
+    'resize("hello", [8], "!")'
+  ],
+  'seealso': [
+    'size', 'subset', 'squeeze'
+  ]
+};
+
+},{}],73:[function(require,module,exports){
+module.exports = {
+  'name': 'size',
+  'category': 'Matrix',
+  'syntax': [
+    'size(x)'
+  ],
+  'description': 'Calculate the size of a matrix.',
+  'examples': [
+    'size(2.3)',
+    'size("hello world")',
+    'a = [1, 2; 3, 4; 5, 6]',
+    'size(a)',
+    'size(1:6)'
+  ],
+  'seealso': [
+    'concat', 'det', 'diag', 'eye', 'inv', 'ones', 'range', 'squeeze', 'subset', 'transpose', 'zeros'
+  ]
+};
+
+},{}],74:[function(require,module,exports){
+module.exports = {
+  'name': 'squeeze',
+  'category': 'Matrix',
+  'syntax': [
+    'squeeze(x)'
+  ],
+  'description': 'Remove singleton dimensions from a matrix.',
+  'examples': [
+    'a = zeros(1,3,2)',
+    'size(squeeze(a))',
+    'b = zeros(3,1,1)',
+    'size(squeeze(b))'
+  ],
+  'seealso': [
+    'concat', 'det', 'diag', 'eye', 'inv', 'ones', 'range', 'size', 'subset', 'transpose', 'zeros'
+  ]
+};
+
+},{}],75:[function(require,module,exports){
+module.exports = {
+  'name': 'subset',
+  'category': 'Matrix',
+  'syntax': [
+    'value(index)',
+    'value(index) = replacement',
+    'subset(value, [index])',
+    'subset(value, [index], replacement)'
+  ],
+  'description': 'Get or set a subset of a matrix or string. ' +
+      'Indexes are one-based. ' +
+      'Both the ranges lower-bound and upper-bound are included.',
+  'examples': [
+    'd = [1, 2; 3, 4]',
+    'e = []',
+    'e(1, 1:2) = [5, 6]',
+    'e(2, :) = [7, 8]',
+    'f = d * e',
+    'f(2, 1)',
+    'f(:, 1)'
+  ],
+  'seealso': [
+    'concat', 'det', 'diag', 'eye', 'inv', 'ones', 'range', 'size', 'squeeze', 'transpose', 'zeros'
+  ]
+};
+
+},{}],76:[function(require,module,exports){
+module.exports = {
+  'name': 'transpose',
+  'category': 'Matrix',
+  'syntax': [
+    'x\'',
+    'transpose(x)'
+  ],
+  'description': 'Transpose a matrix',
+  'examples': [
+    'a = [1, 2, 3; 4, 5, 6]',
+    'a\'',
+    'transpose(a)'
+  ],
+  'seealso': [
+    'concat', 'det', 'diag', 'eye', 'inv', 'ones', 'range', 'size', 'squeeze', 'subset', 'zeros'
+  ]
+};
+
+},{}],77:[function(require,module,exports){
+module.exports = {
+  'name': 'zeros',
+  'category': 'Matrix',
+  'syntax': [
+    'zeros(m)',
+    'zeros(m, n)',
+    'zeros(m, n, p, ...)',
+    'zeros([m])',
+    'zeros([m, n])',
+    'zeros([m, n, p, ...])',
+    'zeros'
+  ],
+  'description': 'Create a matrix containing zeros.',
+  'examples': [
+    'zeros(3)',
+    'zeros(3, 5)',
+    'a = [1, 2, 3; 4, 5, 6]',
+    'zeros(size(a))'
+  ],
+  'seealso': [
+    'concat', 'det', 'diag', 'eye', 'inv', 'ones', 'range', 'size', 'squeeze', 'subset', 'transpose'
+  ]
+};
+
+},{}],78:[function(require,module,exports){
+module.exports = {
+  'name': 'distribution',
+  'category': 'Probability',
+  'syntax': [
+    'distribution(name)',
+    'distribution(name, arg1, arg2, ...)'
+  ],
+  'description':
+      'Create a distribution object of a specific type. ' +
+          'A distribution object contains functions `random([size,] [min,] [max])`, ' +
+          '`randomInt([size,] [min,] [max])`, and `pickRandom(array)`. ' +
+          'Available types of distributions: "uniform", "normal". ' +
+          'Note that the function distribution is currently not available via the expression parser.',
+  'examples': [
+  ],
+  'seealso': ['random', 'randomInt']
+};
+
+},{}],79:[function(require,module,exports){
+module.exports = {
+  'name': 'factorial',
+  'category': 'Probability',
+  'syntax': [
+    'x!',
+    'factorial(x)'
+  ],
+  'description': 'Compute the factorial of a value',
+  'examples': [
+    '5!',
+    '5*4*3*2*1',
+    '3!'
+  ],
+  'seealso': []
+};
+
+},{}],80:[function(require,module,exports){
+module.exports = {
+  'name': 'pickRandom',
+  'category': 'Probability',
+  'syntax': [
+    'pickRandom(array)'
+  ],
+  'description':
+      'Pick a random entry from a given array.',
+  'examples': [
+    'pickRandom(0:10)',
+    'pickRandom([1, 3, 1, 6])'
+  ],
+  'seealso': ['distribution', 'random', 'randomInt']
+};
+
+},{}],81:[function(require,module,exports){
+module.exports = {
+  'name': 'random',
+  'category': 'Probability',
+  'syntax': [
+    'random()',
+    'random(max)',
+    'random(min, max)',
+    'random(size)',
+    'random(size, max)',
+    'random(size, min, max)'
+  ],
+  'description':
+      'Return a random number.',
+  'examples': [
+    'random()',
+    'random(10, 20)',
+    'random([2, 3])'
+  ],
+  'seealso': ['distribution', 'pickRandom', 'randomInt']
+};
+
+},{}],82:[function(require,module,exports){
+module.exports = {
+  'name': 'randInt',
+  'category': 'Probability',
+  'syntax': [
+    'randInt()',
+    'randInt(max)',
+    'randInt(min, max)',
+    'randInt(size)',
+    'randInt(size, max)',
+    'randInt(size, min, max)'
+  ],
+  'description':
+      'Return a random integer number',
+  'examples': [
+    'randInt()',
+    'randInt(10, 20)',
+    'randInt([2, 3], 10)'
+  ],
+  'seealso': ['distribution', 'pickRandom', 'random']
+};
+},{}],83:[function(require,module,exports){
+module.exports = {
+  'name': 'max',
+  'category': 'Statistics',
+  'syntax': [
+    'max(a, b, c, ...)',
+    'max(A)',
+    'max(A, dim)'
+  ],
+  'description': 'Compute the maximum value of a list of values.',
+  'examples': [
+    'max(2, 3, 4, 1)',
+    'max([2, 3, 4, 1])',
+    'max([2, 5; 4, 3], 0)',
+    'max([2, 5; 4, 3], 1)',
+    'max(2.7, 7.1, -4.5, 2.0, 4.1)',
+    'min(2.7, 7.1, -4.5, 2.0, 4.1)'
+  ],
+  'seealso': [
+    //'sum',
+    //'prod',
+    //'avg',
+    //'var',
+    //'std',
+    'mean',
+    //'median',
+    'min'
+  ]
+};
+
+},{}],84:[function(require,module,exports){
+module.exports = {
+  'name': 'mean',
+  'category': 'Statistics',
+  'syntax': [
+    'mean(a, b, c, ...)',
+    'mean(A)',
+    'mean(A, dim)'
+  ],
+  'description': 'Compute the arithmetic mean of a list of values.',
+  'examples': [
+    'mean(2, 3, 4, 1)',
+    'mean([2, 3, 4, 1])',
+    'mean([2, 5; 4, 3], 0)',
+    'mean([2, 5; 4, 3], 1)',
+    'mean([1.0, 2.7, 3.2, 4.0])'
+  ],
+  'seealso': [
+    //'sum',
+    //'prod',
+    //'avg',
+    //'var',
+    //'std',
+	  'max',
+    'min'
+    //'median'
+  ]
+};
+
+},{}],85:[function(require,module,exports){
+module.exports = {
+  'name': 'min',
+  'category': 'Statistics',
+  'syntax': [
+    'min(a, b, c, ...)',
+    'min(A)',
+    'min(A, dim)'
+  ],
+  'description': 'Compute the minimum value of a list of values.',
+  'examples': [
+    'min(2, 3, 4, 1)',
+    'min([2, 3, 4, 1])',
+    'min([2, 5; 4, 3], 0)',
+    'min([2, 5; 4, 3], 1)',
+    'min(2.7, 7.1, -4.5, 2.0, 4.1)',
+    'max(2.7, 7.1, -4.5, 2.0, 4.1)'
+  ],
+  'seealso': [
+    //'sum',
+    //'prod',
+    //'avg',
+    //'var',
+    //'std',
+    'max',
+    'mean',
+    //'median',
+    'min'
+  ]
+};
+
+},{}],86:[function(require,module,exports){
+module.exports = {
+  'name': 'acos',
+  'category': 'Trigonometry',
+  'syntax': [
+    'acos(x)'
+  ],
+  'description': 'Compute the inverse cosine of a value in radians.',
+  'examples': [
+    'acos(0.5)',
+    'acos(cos(2.3))'
+  ],
+  'seealso': [
+    'cos',
+    'acos',
+    'asin'
+  ]
+};
+
+},{}],87:[function(require,module,exports){
+module.exports = {
+  'name': 'asin',
+  'category': 'Trigonometry',
+  'syntax': [
+    'asin(x)'
+  ],
+  'description': 'Compute the inverse sine of a value in radians.',
+  'examples': [
+    'asin(0.5)',
+    'asin(sin(2.3))'
+  ],
+  'seealso': [
+    'sin',
+    'acos',
+    'asin'
+  ]
+};
+
+},{}],88:[function(require,module,exports){
+module.exports = {
+  'name': 'atan',
+  'category': 'Trigonometry',
+  'syntax': [
+    'atan(x)'
+  ],
+  'description': 'Compute the inverse tangent of a value in radians.',
+  'examples': [
+    'atan(0.5)',
+    'atan(tan(2.3))'
+  ],
+  'seealso': [
+    'tan',
+    'acos',
+    'asin'
+  ]
+};
+
+},{}],89:[function(require,module,exports){
+module.exports = {
+  'name': 'atan2',
+  'category': 'Trigonometry',
+  'syntax': [
+    'atan2(y, x)'
+  ],
+  'description':
+      'Computes the principal value of the arc tangent of y/x in radians.',
+  'examples': [
+    'atan2(2, 2) / pi',
+    'angle = 60 deg in rad',
+    'x = cos(angle)',
+    'y = sin(angle)',
+    'atan2(y, x)'
+  ],
+  'seealso': [
+    'sin',
+    'cos',
+    'tan'
+  ]
+};
+
+},{}],90:[function(require,module,exports){
+module.exports = {
+  'name': 'cos',
+  'category': 'Trigonometry',
+  'syntax': [
+    'cos(x)'
+  ],
+  'description': 'Compute the cosine of x in radians.',
+  'examples': [
+    'cos(2)',
+    'cos(pi / 4) ^ 2',
+    'cos(180 deg)',
+    'cos(60 deg)',
+    'sin(0.2)^2 + cos(0.2)^2'
+  ],
+  'seealso': [
+    'acos',
+    'sin',
+    'tan'
+  ]
+};
+
+},{}],91:[function(require,module,exports){
+module.exports = {
+  'name': 'cot',
+  'category': 'Trigonometry',
+  'syntax': [
+    'cot(x)'
+  ],
+  'description': 'Compute the cotangent of x in radians. Defined as 1/tan(x)',
+  'examples': [
+    'cot(2)',
+    '1 / tan(2)'
+  ],
+  'seealso': [
+    'sec',
+    'csc',
+    'tan'
+  ]
+};
+
+},{}],92:[function(require,module,exports){
+module.exports = {
+  'name': 'csc',
+  'category': 'Trigonometry',
+  'syntax': [
+    'csc(x)'
+  ],
+  'description': 'Compute the cosecant of x in radians. Defined as 1/sin(x)',
+  'examples': [
+    'csc(2)',
+    '1 / sin(2)'
+  ],
+  'seealso': [
+    'sec',
+    'cot',
+    'sin'
+  ]
+};
+
+},{}],93:[function(require,module,exports){
+module.exports = {
+  'name': 'sec',
+  'category': 'Trigonometry',
+  'syntax': [
+    'sec(x)'
+  ],
+  'description': 'Compute the secant of x in radians. Defined as 1/cos(x)',
+  'examples': [
+    'sec(2)',
+    '1 / cos(2)'
+  ],
+  'seealso': [
+    'cot',
+    'csc',
+    'cos'
+  ]
+};
+
+},{}],94:[function(require,module,exports){
+module.exports = {
+  'name': 'sin',
+  'category': 'Trigonometry',
+  'syntax': [
+    'sin(x)'
+  ],
+  'description': 'Compute the sine of x in radians.',
+  'examples': [
+    'sin(2)',
+    'sin(pi / 4) ^ 2',
+    'sin(90 deg)',
+    'sin(30 deg)',
+    'sin(0.2)^2 + cos(0.2)^2'
+  ],
+  'seealso': [
+    'asin',
+    'cos',
+    'tan'
+  ]
+};
+
+},{}],95:[function(require,module,exports){
+module.exports = {
+  'name': 'tan',
+  'category': 'Trigonometry',
+  'syntax': [
+    'tan(x)'
+  ],
+  'description': 'Compute the tangent of x in radians.',
+  'examples': [
+    'tan(0.5)',
+    'sin(0.5) / cos(0.5)',
+    'tan(pi / 4)',
+    'tan(45 deg)'
+  ],
+  'seealso': [
+    'atan',
+    'sin',
+    'cos'
+  ]
+};
+
+},{}],96:[function(require,module,exports){
+module.exports = {
+  'name': 'in',
+  'category': 'Units',
+  'syntax': [
+    'x in unit',
+    'in(x, unit)'
+  ],
+  'description': 'Change the unit of a value.',
+  'examples': [
+    '5 inch in cm',
+    '3.2kg in g',
+    '16 bytes in bits'
+  ],
+  'seealso': []
+};
+
+},{}],97:[function(require,module,exports){
+module.exports = {
+  'name': 'clone',
+  'category': 'Utils',
+  'syntax': [
+    'clone(x)'
+  ],
+  'description': 'Clone a variable. Creates a copy of primitive variables,and a deep copy of matrices',
+  'examples': [
+    'clone(3.5)',
+    'clone(2 - 4i)',
+    'clone(45 deg)',
+    'clone([1, 2; 3, 4])',
+    'clone("hello world")'
+  ],
+  'seealso': []
+};
+
+},{}],98:[function(require,module,exports){
+module.exports = {
+  'name': 'forEach',
+  'category': 'Utils',
+  'syntax': [
+    'forEach(x, callback)'
+  ],
+  'description': 'Iterates over all elements of a matrix/array, and executes the given callback.',
+  'examples': [
+    'forEach([1, 2, 3], function(val) { console.log(val) })'
+  ],
+  'seealso': []
+};
+
+},{}],99:[function(require,module,exports){
+module.exports = {
+  'name': 'format',
+  'category': 'Utils',
+  'syntax': [
+    'format(value)',
+    'format(value, precision)'
+  ],
+  'description': 'Format a value of any type as string.',
+  'examples': [
+    'format(2.3)',
+    'format(3 - 4i)',
+    'format([])',
+    'format(pi, 3)'
+  ],
+  'seealso': ['print']
+};
+
+},{}],100:[function(require,module,exports){
+module.exports = {
+  'name': 'import',
+  'category': 'Utils',
+  'syntax': [
+    'import(string)'
+  ],
+  'description': 'Import functions from a file.',
+  'examples': [
+    'import("numbers")',
+    'import("./mylib.js")'
+  ],
+  'seealso': []
+};
+
+},{}],101:[function(require,module,exports){
+module.exports = {
+  'name': 'map',
+  'category': 'Utils',
+  'syntax': [
+    'map(x, callback)'
+  ],
+  'description': 'Create a new matrix or array with the results of the callback function executed on each entry of the matrix/array.',
+  'examples': [
+    'map([1, 2, 3], function(val) { return math.max(val, 1.5) })'
+  ],
+  'seealso': []
+};
+
+},{}],102:[function(require,module,exports){
+module.exports = {
+  'name': 'typeof',
+  'category': 'Utils',
+  'syntax': [
+    'typeof(x)'
+  ],
+  'description': 'Get the type of a variable.',
+  'examples': [
+    'typeof(3.5)',
+    'typeof(2 - 4i)',
+    'typeof(45 deg)',
+    'typeof("hello world")'
+  ],
+  'seealso': []
+};
+
+},{}],103:[function(require,module,exports){
+// constants
+exports.e = require('./constants/e');
+exports.E = require('./constants/e');
+exports['false'] = require('./constants/false');
+exports.i = require('./constants/i');
+exports['Infinity'] = require('./constants/Infinity');
+exports.LN2 = require('./constants/LN2');
+exports.LN10 = require('./constants/LN10');
+exports.LOG2E = require('./constants/LOG2E');
+exports.LOG10E = require('./constants/LOG10E');
+exports.NaN = require('./constants/NaN');
+exports.pi = require('./constants/pi');
+exports.PI = require('./constants/pi');
+exports.SQRT1_2 = require('./constants/SQRT1_2');
+exports.SQRT2 = require('./constants/SQRT2');
+exports.tau = require('./constants/tau');
+exports['true'] = require('./constants/true');
+
+// functions - arithmetic
+exports.abs = require('./function/arithmetic/abs');
+exports.add = require('./function/arithmetic/add');
+exports.ceil = require('./function/arithmetic/ceil');
+exports.cube = require('./function/arithmetic/cube');
+exports.divide = require('./function/arithmetic/divide');
+exports.edivide = require('./function/arithmetic/edivide');
+exports.emultiply = require('./function/arithmetic/emultiply');
+exports.epow = require('./function/arithmetic/epow');
+exports.equal = require('./function/arithmetic/equal');
+exports.exp = require('./function/arithmetic/exp');
+exports.fix = require('./function/arithmetic/fix');
+exports.floor = require('./function/arithmetic/floor');
+exports.gcd = require('./function/arithmetic/gcd');
+exports.larger = require('./function/arithmetic/larger');
+exports.largereq = require('./function/arithmetic/largereq');
+exports.lcm = require('./function/arithmetic/lcm');
+exports.log = require('./function/arithmetic/log');
+exports.log10 = require('./function/arithmetic/log10');
+exports.mod = require('./function/arithmetic/mod');
+exports.multiply = require('./function/arithmetic/multiply');
+exports.pow = require('./function/arithmetic/pow');
+exports.round = require('./function/arithmetic/round');
+exports.sign = require('./function/arithmetic/sign');
+exports.smaller = require('./function/arithmetic/smaller');
+exports.smallereq = require('./function/arithmetic/smallereq');
+exports.sqrt = require('./function/arithmetic/sqrt');
+exports.square = require('./function/arithmetic/square');
+exports.subtract = require('./function/arithmetic/subtract');
+exports.unary = require('./function/arithmetic/unary');
+exports.unequal = require('./function/arithmetic/unequal');
+exports.xgcd = require('./function/arithmetic/xgcd');
+
+// functions - complex
+exports.arg = require('./function/complex/arg');
+exports.conj = require('./function/complex/conj');
+exports.re = require('./function/complex/re');
+exports.im = require('./function/complex/im');
+
+// functions - construction
+exports.bignumber = require('./function/construction/bignumber');
+exports.boolean = require('./function/construction/boolean');
+exports.complex = require('./function/construction/complex');
+exports.index = require('./function/construction/index');
+exports.matrix = require('./function/construction/matrix');
+exports.number = require('./function/construction/number');
+exports.string = require('./function/construction/string');
+exports.unit = require('./function/construction/unit');
+
+// functions - epxression
+exports['eval'] =  require('./function/expression/eval');
+exports.help =  require('./function/expression/help');
+
+// functions - matrix
+exports.concat = require('./function/matrix/concat');
+exports.det = require('./function/matrix/det');
+exports.diag = require('./function/matrix/diag');
+exports.eye = require('./function/matrix/eye');
+exports.inv = require('./function/matrix/inv');
+exports.ones = require('./function/matrix/ones');
+exports.range = require('./function/matrix/range');
+exports.resize = require('./function/matrix/resize');
+exports.size = require('./function/matrix/size');
+exports.squeeze = require('./function/matrix/squeeze');
+exports.subset = require('./function/matrix/subset');
+exports.transpose = require('./function/matrix/transpose');
+exports.zeros = require('./function/matrix/zeros');
+
+// functions - probability
+exports.factorial = require('./function/probability/factorial');
+exports.distribution = require('./function/probability/distribution');
+exports.pickRandom = require('./function/probability/pickRandom');
+exports.random = require('./function/probability/random');
+exports.randomInt = require('./function/probability/randomInt');
+
+// functions - statistics
+exports.min = require('./function/statistics/min');
+exports.mean = require('./function/statistics/mean');
+exports.max = require('./function/statistics/max');
+
+// functions - trigonometry
+exports.acos = require('./function/trigonometry/acos');
+exports.asin = require('./function/trigonometry/asin');
+exports.atan = require('./function/trigonometry/atan');
+exports.atan2 = require('./function/trigonometry/atan2');
+exports.cos = require('./function/trigonometry/cos');
+exports.cot = require('./function/trigonometry/cot');
+exports.csc = require('./function/trigonometry/csc');
+exports.sec = require('./function/trigonometry/sec');
+exports.sin = require('./function/trigonometry/sin');
+exports.tan = require('./function/trigonometry/tan');
+
+// functions - units
+exports['in'] = require('./function/units/in');
+
+// functions - utils
+exports.clone =  require('./function/utils/clone');
+exports.map =  require('./function/utils/map');
+exports.forEach =  require('./function/utils/forEach');
+exports.format =  require('./function/utils/format');
+// exports.print =  require('./function/utils/print'); // TODO: add documentation for print as soon as the parser supports objects.
+exports['import'] =  require('./function/utils/import');
+exports['typeof'] =  require('./function/utils/typeof');
+
+},{"./constants/Infinity":6,"./constants/LN10":7,"./constants/LN2":8,"./constants/LOG10E":9,"./constants/LOG2E":10,"./constants/NaN":11,"./constants/SQRT1_2":12,"./constants/SQRT2":13,"./constants/e":14,"./constants/false":15,"./constants/i":16,"./constants/pi":17,"./constants/tau":18,"./constants/true":19,"./function/arithmetic/abs":20,"./function/arithmetic/add":21,"./function/arithmetic/ceil":22,"./function/arithmetic/cube":23,"./function/arithmetic/divide":24,"./function/arithmetic/edivide":25,"./function/arithmetic/emultiply":26,"./function/arithmetic/epow":27,"./function/arithmetic/equal":28,"./function/arithmetic/exp":29,"./function/arithmetic/fix":30,"./function/arithmetic/floor":31,"./function/arithmetic/gcd":32,"./function/arithmetic/larger":33,"./function/arithmetic/largereq":34,"./function/arithmetic/lcm":35,"./function/arithmetic/log":36,"./function/arithmetic/log10":37,"./function/arithmetic/mod":38,"./function/arithmetic/multiply":39,"./function/arithmetic/pow":40,"./function/arithmetic/round":41,"./function/arithmetic/sign":42,"./function/arithmetic/smaller":43,"./function/arithmetic/smallereq":44,"./function/arithmetic/sqrt":45,"./function/arithmetic/square":46,"./function/arithmetic/subtract":47,"./function/arithmetic/unary":48,"./function/arithmetic/unequal":49,"./function/arithmetic/xgcd":50,"./function/complex/arg":51,"./function/complex/conj":52,"./function/complex/im":53,"./function/complex/re":54,"./function/construction/bignumber":55,"./function/construction/boolean":56,"./function/construction/complex":57,"./function/construction/index":58,"./function/construction/matrix":59,"./function/construction/number":60,"./function/construction/string":61,"./function/construction/unit":62,"./function/expression/eval":63,"./function/expression/help":64,"./function/matrix/concat":65,"./function/matrix/det":66,"./function/matrix/diag":67,"./function/matrix/eye":68,"./function/matrix/inv":69,"./function/matrix/ones":70,"./function/matrix/range":71,"./function/matrix/resize":72,"./function/matrix/size":73,"./function/matrix/squeeze":74,"./function/matrix/subset":75,"./function/matrix/transpose":76,"./function/matrix/zeros":77,"./function/probability/distribution":78,"./function/probability/factorial":79,"./function/probability/pickRandom":80,"./function/probability/random":81,"./function/probability/randomInt":82,"./function/statistics/max":83,"./function/statistics/mean":84,"./function/statistics/min":85,"./function/trigonometry/acos":86,"./function/trigonometry/asin":87,"./function/trigonometry/atan":88,"./function/trigonometry/atan2":89,"./function/trigonometry/cos":90,"./function/trigonometry/cot":91,"./function/trigonometry/csc":92,"./function/trigonometry/sec":93,"./function/trigonometry/sin":94,"./function/trigonometry/tan":95,"./function/units/in":96,"./function/utils/clone":97,"./function/utils/forEach":98,"./function/utils/format":99,"./function/utils/import":100,"./function/utils/map":101,"./function/utils/typeof":102}],104:[function(require,module,exports){
+var Node = require('./Node'),
+    object = require('../../util/object'),
+    string = require('../../util/string'),
+    collection = require('../../type/collection'),
+    Matrix = require('../../type/Matrix');
+
+/**
+ * @constructor ArrayNode
+ * Holds an 1-dimensional array with nodes
+ * @param {Object} settings Object with the math.js configuration settings
+ * @param {Array} nodes    1 dimensional array with nodes
+ * @extends {Node}
+ */
+function ArrayNode(settings, nodes) {
+  this.settings = settings; // math.js settings
+  this.nodes = nodes || [];
+}
+
+ArrayNode.prototype = new Node();
+
+/**
+ * Evaluate the array
+ * @return {Matrix | Array} results
+ * @override
+ */
+ArrayNode.prototype.eval = function() {
+  // evaluate all nodes in the array, and merge the results into a matrix
+  var nodes = this.nodes,
+      results = [];
+
+  for (var i = 0, ii = nodes.length; i < ii; i++) {
+    var node = nodes[i];
+    var result = node.eval();
+    results[i] = (result instanceof Matrix) ? result.valueOf() : result;
+  }
+
+  return (this.settings.matrix.defaultType === 'array') ? results : new Matrix(results);
+};
+
+/**
+ * Find all nodes matching given filter
+ * @param {Object} filter  See Node.find for a description of the filter settings
+ * @returns {Node[]} nodes
+ */
+ArrayNode.prototype.find = function (filter) {
+  var results = [];
+
+  // check itself
+  if (this.match(filter)) {
+    results.push(this);
+  }
+
+  // search in all nodes
+  var nodes = this.nodes;
+  for (var r = 0, rows = nodes.length; r < rows; r++) {
+    var nodes_r = nodes[r];
+    for (var c = 0, cols = nodes_r.length; c < cols; c++) {
+      results = results.concat(nodes_r[c].find(filter));
+    }
+  }
+
+  return results;
+};
+
+/**
+ * Get string representation
+ * @return {String} str
+ * @override
+ */
+ArrayNode.prototype.toString = function() {
+  return string.format(this.nodes);
+};
+
+module.exports = ArrayNode;
+
+},{"../../type/Matrix":205,"../../type/collection":208,"../../util/object":214,"../../util/string":215,"./Node":109}],105:[function(require,module,exports){
+var Node = require('./Node');
+
+/**
+ * @constructor AssignmentNode
+ * Define a symbol, like "a = 3.2"
+ *
+ * @param {String} name       Symbol name
+ * @param {Node} expr         The expression defining the symbol
+ * @param {Scope} scope       Scope to store the result
+ */
+function AssignmentNode(name, expr, scope) {
+  this.name = name;
+  this.expr = expr;
+  this.scope = scope;
+}
+
+AssignmentNode.prototype = new Node();
+
+/**
+ * Evaluate the assignment
+ * @return {*} result
+ */
+AssignmentNode.prototype.eval = function() {
+  if (this.expr === undefined) {
+    throw new Error('Undefined symbol ' + this.name);
+  }
+
+  var result = this.expr.eval();
+  this.scope.set(this.name, result);
+
+  return result;
+};
+
+/**
+ * Find all nodes matching given filter
+ * @param {Object} filter  See Node.find for a description of the filter settings
+ * @returns {Node[]} nodes
+ */
+AssignmentNode.prototype.find = function (filter) {
+  var nodes = [];
+
+  // check itself
+  if (this.match(filter)) {
+    nodes.push(this);
+  }
+
+  // search in expression
+  if (this.expr) {
+    nodes = nodes.concat(this.expr.find(filter));
+  }
+
+  return nodes;
+};
+
+/**
+ * Get string representation
+ * @return {String}
+ */
+AssignmentNode.prototype.toString = function() {
+  return this.name + ' = ' + this.expr.toString();
+};
+
+module.exports = AssignmentNode;
+},{"./Node":109}],106:[function(require,module,exports){
+var Node = require('./Node');
+
+/**
+ * @constructor BlockNode
+ * Holds a set with nodes
+ * @extends {Node}
+ */
+function BlockNode() {
+  this.params = [];
+  this.visible = [];
+}
+
+BlockNode.prototype = new Node();
+
+/**
+ * Add a parameter
+ * @param {Node} param
+ * @param {Boolean} [visible]   true by default
+ */
+BlockNode.prototype.add = function (param, visible) {
+  var index = this.params.length;
+  this.params[index] = param;
+  this.visible[index] = (visible != undefined) ? visible : true;
+};
+
+/**
+ * Evaluate the set
+ * @return {*[]} results
+ * @override
+ */
+BlockNode.prototype.eval = function() {
+  // evaluate the parameters
+  var results = [];
+  for (var i = 0, iMax = this.params.length; i < iMax; i++) {
+    var result = this.params[i].eval();
+    if (this.visible[i]) {
+      results.push(result);
+    }
+  }
+
+  return results;
+};
+
+/**
+ * Find all nodes matching given filter
+ * @param {Object} filter  See Node.find for a description of the filter settings
+ * @returns {Node[]} nodes
+ */
+BlockNode.prototype.find = function (filter) {
+  var nodes = [];
+
+  // check itself
+  if (this.match(filter)) {
+    nodes.push(this);
+  }
+
+  // search in parameters
+  var params = this.params;
+  if (params) {
+    for (var i = 0, len = params.length; i < len; i++) {
+      nodes = nodes.concat(params[i].find(filter));
+    }
+  }
+
+  return nodes;
+};
+
+/**
+ * Get string representation
+ * @return {String} str
+ * @override
+ */
+BlockNode.prototype.toString = function() {
+  var strings = [];
+
+  for (var i = 0, iMax = this.params.length; i < iMax; i++) {
+    if (this.visible[i]) {
+      strings.push('\n  ' + this.params[i].toString());
+    }
+  }
+
+  return '[' + strings.join(',') + '\n]';
+};
+
+module.exports = BlockNode;
+
+},{"./Node":109}],107:[function(require,module,exports){
+var Node = require('./Node'),
+    string = require('../../util/string');
+
+/**
+ * @constructor ConstantNode
+ * @param {*} value
+ * @extends {Node}
+ */
+function ConstantNode(value) {
+  this.value = value;
+}
+
+ConstantNode.prototype = new Node();
+
+/**
+ * Evaluate the constant (just return it)
+ * @return {*} value
+ */
+ConstantNode.prototype.eval = function () {
+  return this.value;
+};
+
+/**
+ * Get string representation
+ * @return {String} str
+ */
+ConstantNode.prototype.toString = function() {
+  return string.format(this.value);
+};
+
+module.exports = ConstantNode;
+
+},{"../../util/string":215,"./Node":109}],108:[function(require,module,exports){
+var Node = require('./Node');
+
+/**
+ * @constructor FunctionNode
+ * Function assignment
+ *
+ * @param {String} name           Function name
+ * @param {String[]} variables    Variable names
+ * @param {Node} expr             The function expression
+ * @param {Scope} functionScope   Scope in which to write variable values
+ * @param {Scope} scope           Scope to store the resulting function assignment
+ */
+function FunctionNode(name, variables, expr, functionScope, scope) {
+  this.name = name;
+  this.variables = variables;
+  this.expr = expr;
+  this.scope = scope;
+
+  // create function
+  this.fn = function () {
+    var num = variables ? variables.length : 0;
+
+    // validate correct number of arguments
+    if (arguments.length != num) {
+      throw new SyntaxError('Wrong number of arguments in function ' + name +
+          ' (' + arguments.length + ' provided, ' + num + ' expected)');
+    }
+
+    // fill in the provided arguments in the functionScope variables
+    for (var i = 0; i < num; i++) {
+      functionScope.set(variables[i], arguments[i]);
+    }
+
+    // evaluate the expression
+    return expr.eval();
+  };
+
+  // TODO: don't override the functions default toString()
+  this.fn.toString = function() {
+    // TODO: what to return as toString?
+    return name + '(' + variables.join(', ') + ')';
+    //return name + '(' + variableNames.join(', ') + ') = ' + expr.toString();
+  };
+}
+
+FunctionNode.prototype = new Node();
+
+/**
+ * Evaluate the function assignment
+ * @return {function} fn
+ */
+FunctionNode.prototype.eval = function() {
+  // put the definition in the scope
+  this.scope.set(this.name, this.fn);
+
+  return this.fn;
+};
+
+/**
+ * Find all nodes matching given filter
+ * @param {Object} filter  See Node.find for a description of the filter settings
+ * @returns {Node[]} nodes
+ */
+FunctionNode.prototype.find = function (filter) {
+  var nodes = [];
+
+  // check itself
+  if (this.match(filter)) {
+    nodes.push(this);
+  }
+
+  // search in expression
+  if (this.expr) {
+    nodes = nodes.concat(this.expr.find(filter));
+  }
+
+  return nodes;
+};
+
+/**
+ * get string representation
+ * @return {String} str
+ */
+FunctionNode.prototype.toString = function() {
+  return this.fn.toString();
+};
+
+module.exports = FunctionNode;
+
+},{"./Node":109}],109:[function(require,module,exports){
+/**
+ * Node
+ */
+function Node() {}
+
+/**
+ * Evaluate the node
+ * @return {*} result
+ */
+Node.prototype.eval = function () {
+  throw new Error('Cannot evaluate a Node interface');
+};
+
+/**
+ * Find any node in the node tree matching given filter. For example, to
+ * find all nodes of type SymbolNode having name 'x':
+ *
+ *     var results = Node.find({
+ *         type: SymbolNode,
+ *         properties: {
+ *             name: 'x'
+ *         }
+ *     });
+ *
+ * @param {Object} filter       Available parameters:
+ *                                  {Function} type
+ *                                  {Object<String, String>} properties
+ * @return {Node[]} nodes       An array with nodes matching given filter criteria
+ */
+Node.prototype.find = function (filter) {
+  return this.match(filter) ? [this] : [];
+};
+
+/**
+ * Test if this object matches given filter
+ * @param {Object} filter       Available parameters:
+ *                              {Function} type
+ *                              {Object<String, String>} properties
+ * @return {Boolean} matches    True if there is a match
+ */
+Node.prototype.match = function (filter) {
+  var match = true;
+
+  if (filter) {
+    if (filter.type && !(this instanceof filter.type)) {
+      match = false;
+    }
+    if (match && filter.properties) {
+      for (var prop in filter.properties) {
+        if (filter.properties.hasOwnProperty(prop)) {
+          if (this[prop] != filter.properties[prop]) {
+            match = false;
+            break;
+          }
+        }
+      }
+    }
+  }
+
+  return match;
+};
+
+/**
+ * Get string representation
+ * @return {String}
+ */
+Node.prototype.toString = function() {
+  return '';
+};
+
+module.exports = Node;
+
+},{}],110:[function(require,module,exports){
+var Node = require('./Node');
+
+/**
+ * @constructor OperatorNode
+ * An operator with two arguments, like 2+3
+ * @param {String} name     Function name, for example '+'
+ * @param {function} fn     Function, for example math.add
+ * @param {Node[]} params   Parameters
+ */
+function OperatorNode (name, fn, params) {
+  this.name = name;
+  this.fn = fn;
+  this.params = params;
+}
+
+OperatorNode.prototype = new Node();
+
+/**
+ * Evaluate the parameters
+ * @return {*} result
+ */
+OperatorNode.prototype.eval = function() {
+  return this.fn.apply(this, this.params.map(function (param) {
+    return param.eval();
+  }));
+};
+
+/**
+ * Find all nodes matching given filter
+ * @param {Object} filter  See Node.find for a description of the filter settings
+ * @returns {Node[]} nodes
+ */
+OperatorNode.prototype.find = function (filter) {
+  var nodes = [];
+
+  // check itself
+  if (this.match(filter)) {
+    nodes.push(this);
+  }
+
+  // search in parameters
+  var params = this.params;
+  if (params) {
+    for (var i = 0, len = params.length; i < len; i++) {
+      nodes = nodes.concat(params[i].find(filter));
+    }
+  }
+
+  return nodes;
+};
+
+/**
+ * Get string representation
+ * @return {String} str
+ */
+OperatorNode.prototype.toString = function() {
+  var params = this.params;
+
+  switch (params.length) {
+    case 1:
+      if (this.name == '-') {
+        // special case: unary minus
+        return '-' + params[0].toString();
+      }
+      else {
+        // for example '5!'
+        return params[0].toString() + this.name;
+      }
+
+    case 2: // for example '2+3'
+      var lhs = params[0].toString();
+      if (params[0] instanceof OperatorNode) {
+        lhs = '(' + lhs + ')';
+      }
+      var rhs = params[1].toString();
+      if (params[1] instanceof OperatorNode) {
+        rhs = '(' + rhs + ')';
+      }
+      return lhs + ' ' + this.name + ' ' + rhs;
+
+    default: // this should occur. format as a function call
+      return this.name + '(' + this.params.join(', ') + ')';
+  }
+};
+
+module.exports = OperatorNode;
+
+},{"./Node":109}],111:[function(require,module,exports){
+var number= require('../../util/number'),
+
+    Node = require('./Node'),
+    RangeNode = require('./RangeNode'),
+    SymbolNode = require('./SymbolNode'),
+
+    BigNumber = require('bignumber.js'),
+    Index = require('../../type/Index'),
+    Range = require('../../type/Range'),
+
+    isNumber = number.isNumber,
+    toNumber = number.toNumber;
+
+/**
+ * @constructor ParamsNode
+ * invoke a list with parameters on the results of a node
+ * @param {Object} math             The math namespace containing all functions
+ * @param {Node} object
+ * @param {Node[]} params
+ * @param {Scope[]} paramScopes     A scope for every parameter, where the
+ *                                  index variable 'end' can be defined.
+ */
+function ParamsNode (math, object, params, paramScopes) {
+  this.math = math;
+
+  this.object = object;
+  this.params = params;
+  this.paramScopes = paramScopes;
+
+  // check whether any of the params expressions uses the context symbol 'end'
+  this.hasContextParams = false;
+  if (params) {
+    var filter = {
+      type: SymbolNode,
+      properties: {
+        name: 'end'
+      }
+    };
+
+    for (var i = 0, len = params.length; i < len; i++) {
+      if (params[i].find(filter).length > 0) {
+        this.hasContextParams = true;
+        break;
+      }
+    }
+  }
+}
+
+ParamsNode.prototype = new Node();
+
+/**
+ * Evaluate the parameters
+ * @return {*} result
+ */
+ParamsNode.prototype.eval = function() {
+  var i, len, params, results;
+
+  // evaluate the object
+  var object = this.object;
+  if (object == undefined) {
+    throw new Error ('Node undefined');
+  }
+  var obj = object.eval();
+
+  // evaluate the values of context parameter 'end' when needed
+  if (this.hasContextParams && typeof obj !== 'function') {
+    var paramScopes = this.paramScopes,
+        size = this.math.size(obj).valueOf();
+
+    if (paramScopes && size) {
+      for (i = 0, len = this.params.length; i < len; i++) {
+        var paramScope = paramScopes[i];
+        if (paramScope) {
+          paramScope.set('end', size[i]);
+        }
+      }
+    }
+  }
+
+  if (typeof obj === 'function') {
+    // evaluate the parameters
+    params = this.params;
+    results = [];
+    for (i = 0, len = this.params.length; i < len; i++) {
+      results[i] = params[i].eval();
+    }
+
+    // invoke a function with the parameters
+    return obj.apply(this, results);
+  }
+  else {
+    // evaluate the parameters as index
+    params = this.params;
+    results = [];
+    for (i = 0, len = this.params.length; i < len; i++) {
+      var param = params[i];
+      var result;
+
+      if (param instanceof RangeNode) {
+        result = param.toRange();
+      }
+      else {
+        result = param.eval();
+      }
+
+      // convert big number to number
+      if (result instanceof BigNumber) result = toNumber(result);
+
+      // TODO: implement support for BigNumber
+
+      // change from one-based to zero-based range
+      if (result instanceof Range) {
+        result.start --;
+        result.end --;
+      }
+      else if (isNumber(result)) {
+        // number
+        result--;
+      }
+      else {
+        throw new TypeError('Number or Range expected');
+      }
+
+      results[i] = result;
+    }
+
+    // get a subset of the object
+    var index = Index.create(results);
+    return this.math.subset(obj, index);
+  }
+};
+
+/**
+ * Find all nodes matching given filter
+ * @param {Object} filter  See Node.find for a description of the filter settings
+ * @returns {Node[]} nodes
+ */
+ParamsNode.prototype.find = function (filter) {
+  var nodes = [];
+
+  // check itself
+  if (this.match(filter)) {
+    nodes.push(this);
+  }
+
+  // search object
+  if (this.object) {
+    nodes = nodes.concat(this.object.find(filter));
+  }
+
+  // search in parameters
+  var params = this.params;
+  if (params) {
+    for (var i = 0, len = params.length; i < len; i++) {
+      nodes = nodes.concat(params[i].find(filter));
+    }
+  }
+
+  return nodes;
+};
+
+/**
+ * Get string representation
+ * @return {String} str
+ */
+ParamsNode.prototype.toString = function() {
+  // format the parameters like "(2, 4.2)"
+  var str = this.object ? this.object.toString() : '';
+  if (this.params) {
+    str += '(' + this.params.join(', ') + ')';
+  }
+  return str;
+};
+
+module.exports = ParamsNode;
+
+},{"../../type/Index":204,"../../type/Range":206,"../../util/number":213,"./Node":109,"./RangeNode":112,"./SymbolNode":113,"bignumber.js":217}],112:[function(require,module,exports){
+var number = require('../../util/number'),
+    Node = require('./Node'),
+
+    BigNumber = require('bignumber.js'),
+    Range = require('../../type/Range'),
+    Matrix = require('../../type/Matrix'),
+
+    toNumber = number.toNumber;
+
+/**
+ * @constructor RangeNode
+ * create a range
+ * @param {Object} math             The math namespace containing all functions
+ * @param {Object} settings         Settings of the math
+ * @param {Node[]} params
+ */
+function RangeNode (math, settings, params) {
+  this.math = math;
+  this.settings = settings;
+
+  this.start = null;  // included lower-bound
+  this.end = null;    // included upper-bound
+  this.step = null;   // optional step
+
+  if (params.length == 2) {
+    this.start = params[0];
+    this.end = params[1];
+  }
+  else if (params.length == 3) {
+    this.start = params[0];
+    this.step = params[1];
+    this.end = params[2];
+  }
+  else {
+    // TODO: better error message
+    throw new SyntaxError('Wrong number of arguments');
+  }
+}
+
+RangeNode.prototype = new Node();
+
+/**
+ * Evaluate the range
+ * @return {*} result
+ */
+RangeNode.prototype.eval = function() {
+  // evaluate the parameters
+  var range = this._evalParams(),
+      start = range.start,
+      step = range.step,
+      end = range.end;
+
+  // generate the range (upper-bound included!)
+  var array = [],
+      x = start;
+  if (step > 0) {
+    while (x <= end) {
+      array.push(x);
+      x += step;
+    }
+  }
+  else if (step < 0) {
+    while (x >= end) {
+      array.push(x);
+      x += step;
+    }
+  }
+
+  return (this.settings.matrix.defaultType === 'array') ? array : new Matrix(array);
+};
+
+/**
+ * Create a Range from a RangeNode
+ * @return {Range} range
+ */
+RangeNode.prototype.toRange = function() {
+  // evaluate the parameters
+  var range = this._evalParams(),
+      start = range.start,
+      step = range.step,
+      end = range.end;
+
+  // upper-bound be included, so compensate for that
+  // NOTE: this only works for integer values!
+  end = this.math.add(end, (step > 0) ? 1 : -1);
+
+  // create the range
+  return new Range(start, end, step);
+};
+
+/**
+ * Evaluate the range parameters start, step, end
+ * @returns {{start: Number, end: Number, step: Number}} range
+ * @private
+ */
+RangeNode.prototype._evalParams = function _evalParams() {
+  var start = this.start.eval();
+  var end = this.end.eval();
+  var step = this.step ? this.step.eval() : 1;
+
+  // TODO: implement support for big numbers
+
+  // convert big numbers to numbers
+  if (start instanceof BigNumber) start = toNumber(start);
+  if (end instanceof BigNumber)   end   = toNumber(end);
+  if (step instanceof BigNumber)  step  = toNumber(step);
+
+  // validate parameters
+  if (!number.isNumber(start)) throw new TypeError('Parameter start must be a number');
+  if (!number.isNumber(end))   throw new TypeError('Parameter end must be a number');
+  if (!number.isNumber(step))  throw new TypeError('Parameter step must be a number');
+
+  return {
+    start: start,
+    end: end,
+    step: step
+  };
+};
+
+/**
+ * Find all nodes matching given filter
+ * @param {Object} filter  See Node.find for a description of the filter settings
+ * @returns {Node[]} nodes
+ */
+RangeNode.prototype.find = function (filter) {
+  var nodes = [];
+
+  // check itself
+  if (this.match(filter)) {
+    nodes.push(this);
+  }
+
+  // search in parameters
+  if (this.start) {
+    nodes = nodes.concat(this.start.find(filter));
+  }
+  if (this.step) {
+    nodes = nodes.concat(this.step.find(filter));
+  }
+  if (this.end) {
+    nodes = nodes.concat(this.end.find(filter));
+  }
+
+  return nodes;
+};
+
+/**
+ * Get string representation
+ * @return {String} str
+ */
+RangeNode.prototype.toString = function() {
+  // format the range like "start:step:end"
+  var str = this.start.toString();
+  if (this.step) {
+    str += ':' + this.step.toString();
+  }
+  str += ':' + this.end.toString();
+
+  return str;
+};
+
+module.exports = RangeNode;
+
+},{"../../type/Matrix":205,"../../type/Range":206,"../../util/number":213,"./Node":109,"bignumber.js":217}],113:[function(require,module,exports){
+var Node = require('./Node');
+
+/**
+ * @constructor SymbolNode
+ * A symbol node can hold and resolve a symbol
+ * @param {String} name
+ * @param {Scope} scope
+ * @extends {Node}
+ */
+function SymbolNode(name, scope) {
+  this.name = name;
+  this.scope = scope;
+}
+
+SymbolNode.prototype = new Node();
+
+/**
+ * Evaluate the symbol. Throws an error when the symbol is undefined.
+ * @return {*} result
+ * @override
+ */
+SymbolNode.prototype.eval = function() {
+  // return the value of the symbol
+  var value = this.scope.get(this.name);
+
+  if (value === undefined) {
+    throw new Error('Undefined symbol ' + this.name);
+  }
+
+  return value;
+};
+
+/**
+ * Get string representation
+ * @return {String} str
+ * @override
+ */
+SymbolNode.prototype.toString = function() {
+  return this.name;
+};
+
+module.exports = SymbolNode;
+
+},{"./Node":109}],114:[function(require,module,exports){
+var number= require('../../util/number'),
+
+    Node = require('./Node'),
+    RangeNode = require('./RangeNode'),
+    SymbolNode = require('./SymbolNode'),
+
+    BigNumber = require('bignumber.js'),
+    Index = require('../../type/Index'),
+    Range = require('../../type/Range'),
+
+    isNumber = number.isNumber,
+    toNumber = number.toNumber;
+
+/**
+ * @constructor UpdateNode
+ * Update a symbol value, like a(2,3) = 4.5
+ *
+ * @param {Object} math                 The math namespace containing all functions
+ * @param {String} name                 Symbol name
+ * @param {Node[] | undefined} params   One or more parameters
+ * @param {Scope[]}  paramScopes        A scope for every parameter, where the
+ *                                      index variable 'end' can be defined.
+ * @param {Node} expr                   The expression defining the symbol
+ * @param {Scope} scope                 Scope to store the result
+ */
+function UpdateNode(math, name, params, paramScopes, expr, scope) {
+  this.math = math;
+
+  this.name = name;
+  this.params = params;
+  this.paramScopes = paramScopes;
+  this.expr = expr;
+  this.scope = scope;
+
+  // check whether any of the params expressions uses the context symbol 'end'
+  this.hasContextParams = false;
+  var filter = {
+    type: SymbolNode,
+    properties: {
+      name: 'end'
+    }
+  };
+
+  for (var i = 0, len = params.length; i < len; i++) {
+    if (params[i].find(filter).length > 0) {
+      this.hasContextParams = true;
+      break;
+    }
+  }
+}
+
+UpdateNode.prototype = new Node();
+
+/**
+ * Evaluate the assignment
+ * @return {*} result
+ */
+UpdateNode.prototype.eval = function() {
+  if (this.expr === undefined) {
+    throw new Error('Undefined symbol ' + this.name);
+  }
+
+  var result;
+
+  // test if definition is currently undefined
+  var prevResult = this.scope.get(this.name);
+  if (prevResult == undefined) {
+    throw new Error('Undefined symbol ' + this.name);
+  }
+
+  // evaluate the values of context parameter 'end' when needed
+  if (this.hasContextParams && typeof prevResult !== 'function') {
+    var paramScopes = this.paramScopes,
+        size = this.math.size(prevResult).valueOf();
+
+    if (paramScopes && size) {
+      for (var i = 0, len = this.params.length; i < len; i++) {
+        var paramScope = paramScopes[i];
+        if (paramScope) {
+          paramScope.set('end', size[i]);
+        }
+      }
+    }
+  }
+
+  // change part of a matrix, for example "a=[]", "a(2,3)=4.5"
+  var paramResults = [];
+  this.params.forEach(function (param) {
+    var result;
+
+    if (param instanceof RangeNode) {
+      result = param.toRange();
+    }
+    else {
+      result = param.eval();
+    }
+
+    // convert big number to number
+    if (result instanceof BigNumber) result = toNumber(result);
+
+    // TODO: implement support for BigNumber
+
+    // change from one-based to zero-based range
+    if (result instanceof Range) {
+      result.start --;
+      result.end --;
+    }
+    else if (isNumber(result)) {
+      // number
+      result--;
+    }
+    else {
+      throw new TypeError('Number or Range expected');
+    }
+
+    paramResults.push(result);
+  });
+
+  // evaluate the expression
+  var exprResult = this.expr.eval();
+
+  // replace subset
+  var index = Index.create(paramResults);
+  result = this.math.subset(prevResult, index, exprResult);
+
+  this.scope.set(this.name, result);
+
+  return result;
+};
+
+/**
+ * Find all nodes matching given filter
+ * @param {Object} filter  See Node.find for a description of the filter settings
+ * @returns {Node[]} nodes
+ */
+UpdateNode.prototype.find = function (filter) {
+  var nodes = [];
+
+  // check itself
+  if (this.match(filter)) {
+    nodes.push(this);
+  }
+
+  // search in parameters
+  var params = this.params;
+  if (params) {
+    for (var i = 0, len = params.length; i < len; i++) {
+      nodes = nodes.concat(params[i].find(filter));
+    }
+  }
+
+  // search in expression
+  if (this.expr) {
+    nodes = nodes.concat(this.expr.find(filter));
+  }
+
+  return nodes;
+};
+
+/**
+ * Get string representation
+ * @return {String}
+ */
+UpdateNode.prototype.toString = function() {
+  var str = '';
+
+  str += this.name;
+  if (this.params && this.params.length) {
+    str += '(' + this.params.join(', ') + ')';
+  }
+  str += ' = ';
+  str += this.expr.toString();
+
+  return str;
+};
+
+module.exports = UpdateNode;
+
+},{"../../type/Index":204,"../../type/Range":206,"../../util/number":213,"./Node":109,"./RangeNode":112,"./SymbolNode":113,"bignumber.js":217}],115:[function(require,module,exports){
+/**
+ * Custom node handlers,
+ * (can be added to the exports object)
+ */
+
+},{}],116:[function(require,module,exports){
+exports.AssignmentNode = require('./AssignmentNode');
+exports.BlockNode = require('./BlockNode');
+exports.ConstantNode = require('./ConstantNode');
+exports.FunctionNode = require('./FunctionNode');
+exports.ArrayNode = require('./ArrayNode');
+exports.Node = require('./Node');
+exports.OperatorNode = require('./OperatorNode');
+exports.ParamsNode = require('./ParamsNode');
+exports.RangeNode = require('./RangeNode');
+exports.SymbolNode = require('./SymbolNode');
+exports.UpdateNode = require('./UpdateNode');
+
+exports.handlers = require('./handlers');
+
+},{"./ArrayNode":104,"./AssignmentNode":105,"./BlockNode":106,"./ConstantNode":107,"./FunctionNode":108,"./Node":109,"./OperatorNode":110,"./ParamsNode":111,"./RangeNode":112,"./SymbolNode":113,"./UpdateNode":114,"./handlers":115}],117:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      Matrix = require('../../type/Matrix'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isComplex = Complex.isComplex,
+      isCollection = collection.isCollection;
+
+  /**
+   * Calculate the absolute value of a value.
+   *
+   *     abs(x)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param  {Number | BigNumber | Boolean | Complex | Array | Matrix} x
+   * @return {Number | BigNumber | Complex | Array | Matrix} res
+   */
+  math.abs = function abs(x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('abs', arguments.length, 1);
+    }
+
+    if (isNumber(x)) {
+      return Math.abs(x);
+    }
+
+    if (isComplex(x)) {
+      return Math.sqrt(x.re * x.re + x.im * x.im);
+    }
+
+    if (x instanceof BigNumber) {
+      return x.abs();
+    }
+
+    if (isCollection(x)) {
+      return collection.deepMap(x, abs);
+    }
+
+    if (isBoolean(x)) {
+      return Math.abs(x);
+    }
+
+    throw new math.error.UnsupportedTypeError('abs', x);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/Matrix":205,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],118:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      Matrix = require('../../type/Matrix'),
+      Unit = require('../../type/Unit'),
+      collection = require('../../type/collection'),
+
+      isBoolean = util.boolean.isBoolean,
+      isNumber = util.number.isNumber,
+      toNumber = util.number.toNumber,
+      toBigNumber = util.number.toBigNumber,
+      isString = util.string.isString,
+      isComplex = Complex.isComplex,
+      isUnit = Unit.isUnit,
+      isCollection = collection.isCollection;
+
+  /**
+   * Add two values
+   *
+   *     x + y
+   *     add(x, y)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param  {Number | BigNumber | Boolean | Complex | Unit | String | Array | Matrix} x
+   * @param  {Number | BigNumber | Boolean | Complex | Unit | String | Array | Matrix} y
+   * @return {Number | BigNumber | Complex | Unit | String | Array | Matrix} res
+   */
+  math.add = function add(x, y) {
+    if (arguments.length != 2) {
+      throw new math.error.ArgumentsError('add', arguments.length, 2);
+    }
+
+    if (isNumber(x)) {
+      if (isNumber(y)) {
+        // number + number
+        return x + y;
+      }
+      else if (isComplex(y)) {
+        // number + complex
+        return new Complex(
+            x + y.re,
+            y.im
+        )
+      }
+    }
+
+    if (isComplex(x)) {
+      if (isComplex(y)) {
+        // complex + complex
+        return new Complex(
+            x.re + y.re,
+            x.im + y.im
+        );
+      }
+      else if (isNumber(y)) {
+        // complex + number
+        return new Complex(
+            x.re + y,
+            x.im
+        )
+      }
+    }
+
+    if (isUnit(x)) {
+      if (isUnit(y)) {
+        if (!x.equalBase(y)) {
+          throw new Error('Units do not match');
+        }
+
+        if (x.value == null) {
+          throw new Error('Unit on left hand side of operator + has an undefined value');
+        }
+
+        if (y.value == null) {
+          throw new Error('Unit on right hand side of operator + has an undefined value');
+        }
+
+        var res = x.clone();
+        res.value += y.value;
+        res.fixPrefix = false;
+        return res;
+      }
+    }
+
+    if (x instanceof BigNumber) {
+      // try to convert to big number
+      if (isNumber(y)) {
+        y = toBigNumber(y);
+      }
+      else if (isBoolean(y)) {
+        y = new BigNumber(y ? 1 : 0);
+      }
+
+      if (y instanceof BigNumber) {
+        return x.plus(y);
+      }
+
+      // downgrade to Number
+      return add(toNumber(x), y);
+    }
+    if (y instanceof BigNumber) {
+      // try to convert to big number
+      if (isNumber(x)) {
+        x = toBigNumber(x);
+      }
+      else if (isBoolean(x)) {
+        x = new BigNumber(x ? 1 : 0);
+      }
+
+      if (x instanceof BigNumber) {
+        return x.plus(y)
+      }
+
+      // downgrade to Number
+      return add(x, toNumber(y));
+    }
+
+    if (isString(x) || isString(y)) {
+      return x + y;
+    }
+
+    if (isCollection(x) || isCollection(y)) {
+      return collection.deepMap2(x, y, add);
+    }
+
+    if (isBoolean(x)) {
+      return add(+x, y);
+    }
+    if (isBoolean(y)) {
+      return add(x, +y);
+    }
+
+    throw new math.error.UnsupportedTypeError('add', x, y);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/Matrix":205,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],119:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isCollection =collection.isCollection,
+      isComplex = Complex.isComplex;
+
+  /**
+   * Round a value towards plus infinity
+   *
+   *     ceil(x)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param  {Number | BigNumber | Boolean | Complex | Array | Matrix} x
+   * @return {Number | BigNumber | Complex | Array | Matrix} res
+   */
+  math.ceil = function ceil(x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('ceil', arguments.length, 1);
+    }
+
+    if (isNumber(x)) {
+      return Math.ceil(x);
+    }
+
+    if (isComplex(x)) {
+      return new Complex (
+          Math.ceil(x.re),
+          Math.ceil(x.im)
+      );
+    }
+
+    if (x instanceof BigNumber) {
+      return x.ceil();
+    }
+
+    if (isCollection(x)) {
+      return collection.deepMap(x, ceil);
+    }
+
+    if (isBoolean(x)) {
+      return Math.ceil(x);
+    }
+
+    throw new math.error.UnsupportedTypeError('ceil', x);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],120:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isComplex = Complex.isComplex,
+      isCollection = collection.isCollection;
+
+  /**
+   * Compute the cube of a value
+   *
+   *     x .* x .* x
+   *     cube(x)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param  {Number | BigNumber | Boolean | Complex | Array | Matrix} x
+   * @return {Number | BigNumber | Complex | Array | Matrix} res
+   */
+  math.cube = function cube(x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('cube', arguments.length, 1);
+    }
+
+    if (isNumber(x)) {
+      return x * x * x;
+    }
+
+    if (isComplex(x)) {
+      return math.multiply(math.multiply(x, x), x);
+    }
+
+    if (x instanceof BigNumber) {
+      return x.times(x).times(x);
+    }
+
+    if (isCollection(x)) {
+      return collection.deepMap(x, cube);
+    }
+
+    if (isBoolean(x)) {
+      return cube(+x);
+    }
+
+    throw new math.error.UnsupportedTypeError('cube', x);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],121:[function(require,module,exports){
+module.exports = function(math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      Matrix = require('../../type/Matrix'),
+      Unit = require('../../type/Unit'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      toNumber = util.number.toNumber,
+      toBigNumber = util.number.toBigNumber,
+      isBoolean = util.boolean.isBoolean,
+      isComplex = Complex.isComplex,
+      isUnit = Unit.isUnit,
+      isCollection = collection.isCollection;
+
+  /**
+   * Divide two values.
+   *
+   *     x / y
+   *     divide(x, y)
+   *
+   * @param  {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix} x
+   * @param  {Number | BigNumber | Boolean | Complex} y
+   * @return {Number | BigNumber | Complex | Unit | Array | Matrix} res
+   */
+  math.divide = function divide(x, y) {
+    if (arguments.length != 2) {
+      throw new math.error.ArgumentsError('divide', arguments.length, 2);
+    }
+
+    if (isNumber(x)) {
+      if (isNumber(y)) {
+        // number / number
+        return x / y;
+      }
+      else if (isComplex(y)) {
+        // number / complex
+        return _divideComplex(new Complex(x, 0), y);
+      }
+    }
+
+    if (isComplex(x)) {
+      if (isComplex(y)) {
+        // complex / complex
+        return _divideComplex(x, y);
+      }
+      else if (isNumber(y)) {
+        // complex / number
+        return _divideComplex(x, new Complex(y, 0));
+      }
+    }
+
+    if (x instanceof BigNumber) {
+      // try to convert to big number
+      if (isNumber(y)) {
+        y = toBigNumber(y);
+      }
+      else if (isBoolean(y)) {
+        y = new BigNumber(y ? 1 : 0);
+      }
+
+      if (y instanceof BigNumber) {
+        return x.div(y);
+      }
+
+      // downgrade to Number
+      return divide(toNumber(x), y);
+    }
+    if (y instanceof BigNumber) {
+      // try to convert to big number
+      if (isNumber(x)) {
+        x = toBigNumber(x);
+      }
+      else if (isBoolean(x)) {
+        x = new BigNumber(x ? 1 : 0);
+      }
+
+      if (x instanceof BigNumber) {
+        return x.div(y)
+      }
+
+      // downgrade to Number
+      return divide(x, toNumber(y));
+    }
+
+    if (isUnit(x)) {
+      if (isNumber(y)) {
+        var res = x.clone();
+        res.value /= y;
+        return res;
+      }
+    }
+
+    if (isCollection(x)) {
+      if (isCollection(y)) {
+        // TODO: implement matrix right division using pseudo inverse
+        // http://www.mathworks.nl/help/matlab/ref/mrdivide.html
+        // http://www.gnu.org/software/octave/doc/interpreter/Arithmetic-Ops.html
+        // http://stackoverflow.com/questions/12263932/how-does-gnu-octave-matrix-division-work-getting-unexpected-behaviour
+        return math.multiply(x, math.inv(y));
+      }
+      else {
+        // matrix / scalar
+        return collection.deepMap2(x, y, divide);
+      }
+    }
+
+    if (isCollection(y)) {
+      // TODO: implement matrix right division using pseudo inverse
+      return math.multiply(x, math.inv(y));
+    }
+
+    if (isBoolean(x)) {
+      return divide(+x, y);
+    }
+    if (isBoolean(y)) {
+      return divide(x, +y);
+    }
+
+    throw new math.error.UnsupportedTypeError('divide', x, y);
+  };
+
+  /**
+   * Divide two complex numbers. x / y or divide(x, y)
+   * @param {Complex} x
+   * @param {Complex} y
+   * @return {Complex} res
+   * @private
+   */
+  function _divideComplex (x, y) {
+    var den = y.re * y.re + y.im * y.im;
+    if (den != 0) {
+      return new Complex(
+          (x.re * y.re + x.im * y.im) / den,
+          (x.im * y.re - x.re * y.im) / den
+      );
+    }
+    else {
+      // both y.re and y.im are zero
+      return new Complex(
+          (x.re != 0) ? (x.re / 0) : 0,
+          (x.im != 0) ? (x.im / 0) : 0
+      );
+    }
+  }
+};
+
+},{"../../type/Complex":202,"../../type/Matrix":205,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],122:[function(require,module,exports){
+module.exports = function (math) {
+  var collection = require('../../type/collection');
+
+  /**
+   * Divide two values element wise.
+   *
+   *     x ./ y
+   *     edivide(x, y)
+   *
+   * @param  {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix} x
+   * @param  {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix} y
+   * @return {Number | BigNumber | Complex | Unit | Array | Matrix} res
+   */
+  math.edivide = function edivide(x, y) {
+    if (arguments.length != 2) {
+      throw new math.error.ArgumentsError('edivide', arguments.length, 2);
+    }
+
+    return collection.deepMap2(x, y, math.divide);
+  };
+};
+
+},{"../../type/collection":208}],123:[function(require,module,exports){
+module.exports = function (math) {
+  var collection = require('../../type/collection');
+
+  /**
+   * Multiply two values element wise.
+   *
+   *     x .* y
+   *     emultiply(x, y)
+   *
+   * @param  {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix} x
+   * @param  {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix} y
+   * @return {Number | BigNumber | Complex | Unit | Array | Matrix} res
+   */
+  math.emultiply = function emultiply(x, y) {
+    if (arguments.length != 2) {
+      throw new math.error.ArgumentsError('emultiply', arguments.length, 2);
+    }
+
+    return collection.deepMap2(x, y, math.multiply);
+  };
+};
+
+},{"../../type/collection":208}],124:[function(require,module,exports){
+module.exports = function (math) {
+  var collection = require('../../type/collection');
+
+  /**
+   * Calculates the power of x to y element wise
+   *
+   *     x .^ y
+   *     epow(x, y)
+   *
+   * @param  {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix} x
+   * @param  {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix} y
+   * @return {Number | BigNumber | Complex | Unit | Array | Matrix} res
+   */
+  math.epow = function epow(x, y) {
+    if (arguments.length != 2) {
+      throw new math.error.ArgumentsError('epow', arguments.length, 2);
+    }
+
+    return collection.deepMap2(x, y, math.pow);
+  };
+};
+
+},{"../../type/collection":208}],125:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      Unit = require('../../type/Unit'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      toNumber = util.number.toNumber,
+      toBigNumber = util.number.toBigNumber,
+      isBoolean = util.boolean.isBoolean,
+      isString = util.string.isString,
+      isComplex = Complex.isComplex,
+      isUnit = Unit.isUnit,
+      isCollection = collection.isCollection;
+
+  /**
+   * Check if value x equals y,
+   *
+   *     x == y
+   *     equal(x, y)
+   *
+   * For matrices, the function is evaluated element wise.
+   * In case of complex numbers, x.re must equal y.re, and x.im must equal y.im.
+   *
+   * @param  {Number | BigNumber | Boolean | Complex | Unit | String | Array | Matrix} x
+   * @param  {Number | BigNumber | Boolean | Complex | Unit | String | Array | Matrix} y
+   * @return {Boolean | Array | Matrix} res
+   */
+  math.equal = function equal(x, y) {
+    if (arguments.length != 2) {
+      throw new math.error.ArgumentsError('equal', arguments.length, 2);
+    }
+
+    if (isNumber(x)) {
+      if (isNumber(y)) {
+        return x == y;
+      }
+      else if (isComplex(y)) {
+        return (x == y.re) && (y.im == 0);
+      }
+    }
+
+    if (isComplex(x)) {
+      if (isNumber(y)) {
+        return (x.re == y) && (x.im == 0);
+      }
+      else if (isComplex(y)) {
+        return (x.re == y.re) && (x.im == y.im);
+      }
+    }
+
+    if (x instanceof BigNumber) {
+      // try to convert to big number
+      if (isNumber(y)) {
+        y = toBigNumber(y);
+      }
+      else if (isBoolean(y)) {
+        y = new BigNumber(y ? 1 : 0);
+      }
+
+      if (y instanceof BigNumber) {
+        return x.eq(y);
+      }
+
+      // downgrade to Number
+      return equal(toNumber(x), y);
+    }
+    if (y instanceof BigNumber) {
+      // try to convert to big number
+      if (isNumber(x)) {
+        x = toBigNumber(x);
+      }
+      else if (isBoolean(x)) {
+        x = new BigNumber(x ? 1 : 0);
+      }
+
+      if (x instanceof BigNumber) {
+        return x.eq(y)
+      }
+
+      // downgrade to Number
+      return equal(x, toNumber(y));
+    }
+
+    if ((isUnit(x)) && (isUnit(y))) {
+      if (!x.equalBase(y)) {
+        throw new Error('Cannot compare units with different base');
+      }
+      return x.value == y.value;
+    }
+
+    if (isString(x) || isString(y)) {
+      return x == y;
+    }
+
+    if (isCollection(x) || isCollection(y)) {
+      return collection.deepMap2(x, y, equal);
+    }
+
+    if (isBoolean(x)) {
+      return equal(+x, y);
+    }
+    if (isBoolean(y)) {
+      return equal(x, +y);
+    }
+
+    throw new math.error.UnsupportedTypeError('equal', x, y);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],126:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      Matrix = require('../../type/Matrix'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isComplex = Complex.isComplex,
+      isCollection = collection.isCollection;
+
+  /**
+   * Calculate the exponent of a value
+   *
+   *     exp(x)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param {Number | Boolean | Complex | Array | Matrix} x
+   * @return {Number | Complex | Array | Matrix} res
+   */
+  math.exp = function exp (x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('exp', arguments.length, 1);
+    }
+
+    if (isNumber(x)) {
+      return Math.exp(x);
+    }
+
+    if (isComplex(x)) {
+      var r = Math.exp(x.re);
+      return new Complex(
+          r * Math.cos(x.im),
+          r * Math.sin(x.im)
+      );
+    }
+
+    if (x instanceof BigNumber) {
+      // TODO: implement BigNumber support
+      // downgrade to Number
+      return exp(util.number.toNumber(x));
+    }
+
+    if (isCollection(x)) {
+      return collection.deepMap(x, exp);
+    }
+
+    if (isBoolean(x)) {
+      return Math.exp(x);
+    }
+
+    throw new math.error.UnsupportedTypeError('exp', x);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/Matrix":205,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],127:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isComplex = Complex.isComplex,
+      isCollection = collection.isCollection;
+
+  /**
+   * Round a value towards zero
+   *
+   *     fix(x)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param {Number | Boolean | Complex | Array | Matrix} x
+   * @return {Number | Complex | Array | Matrix} res
+   */
+  math.fix = function fix(x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('fix', arguments.length, 1);
+    }
+
+    if (isNumber(x)) {
+      return (x > 0) ? Math.floor(x) : Math.ceil(x);
+    }
+
+    if (isComplex(x)) {
+      return new Complex(
+          (x.re > 0) ? Math.floor(x.re) : Math.ceil(x.re),
+          (x.im > 0) ? Math.floor(x.im) : Math.ceil(x.im)
+      );
+    }
+
+    if (x instanceof BigNumber) {
+      return x.isNegative() ? x.ceil() : x.floor();
+    }
+
+    if (isCollection(x)) {
+      return collection.deepMap(x, fix);
+    }
+
+    if (isBoolean(x)) {
+      return fix(+x);
+    }
+
+    throw new math.error.UnsupportedTypeError('fix', x);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],128:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isComplex = Complex.isComplex,
+      isCollection = collection.isCollection;
+
+  /**
+   * Round a value towards minus infinity
+   *
+   *     floor(x)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param  {Number | BigNumber | Boolean | Complex | Array | Matrix} x
+   * @return {Number | BigNumber | Complex | Array | Matrix} res
+   */
+  math.floor = function floor(x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('floor', arguments.length, 1);
+    }
+
+    if (isNumber(x)) {
+      return Math.floor(x);
+    }
+
+    if (isComplex(x)) {
+      return new Complex (
+          Math.floor(x.re),
+          Math.floor(x.im)
+      );
+    }
+
+    if (x instanceof BigNumber) {
+      return x.floor();
+    }
+
+    if (isCollection(x)) {
+      return collection.deepMap(x, floor);
+    }
+
+    if (isBoolean(x)) {
+      return floor(+x);
+    }
+
+    throw new math.error.UnsupportedTypeError('floor', x);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],129:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      toNumber = util.number.toNumber,
+      isBoolean = util.boolean.isBoolean,
+      isInteger = util.number.isInteger,
+      isCollection = collection.isCollection;
+
+  /**
+   * Calculate the greatest common divisor for two or more values or arrays.
+   *
+   *     gcd(a, b)
+   *     gcd(a, b, c, ...)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param {... Number | Boolean | Array | Matrix} args    two or more integer numbers
+   * @return {Number | Array | Matrix} greatest common divisor
+   */
+  math.gcd = function gcd(args) {
+    var a = arguments[0],
+        b = arguments[1],
+        r; // remainder
+
+    if (arguments.length == 2) {
+      // two arguments
+      if (isNumber(a) && isNumber(b)) {
+        if (!isInteger(a) || !isInteger(b)) {
+          throw new Error('Parameters in function gcd must be integer numbers');
+        }
+
+        // http://en.wikipedia.org/wiki/Euclidean_algorithm
+        while (b != 0) {
+          r = a % b;
+          a = b;
+          b = r;
+        }
+        return (a < 0) ? -a : a;
+      }
+
+      // evaluate gcd element wise
+      if (isCollection(a) || isCollection(b)) {
+        return collection.deepMap2(a, b, gcd);
+      }
+
+      // TODO: implement BigNumber support for gcd
+
+      // downgrade bignumbers to numbers
+      if (a instanceof BigNumber) {
+        return gcd(toNumber(a), b);
+      }
+      if (b instanceof BigNumber) {
+        return gcd(a, toNumber(b));
+      }
+
+      if (isBoolean(a)) {
+        return gcd(+a, b);
+      }
+      if (isBoolean(b)) {
+        return gcd(a, +b);
+      }
+
+      throw new math.error.UnsupportedTypeError('gcd', a, b);
+    }
+
+    if (arguments.length > 2) {
+      // multiple arguments. Evaluate them iteratively
+      for (var i = 1; i < arguments.length; i++) {
+        a = gcd(a, arguments[i]);
+      }
+      return a;
+    }
+
+    // zero or one argument
+    throw new SyntaxError('Function gcd expects two or more arguments');
+  };
+};
+
+},{"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],130:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      Unit = require('../../type/Unit'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      toNumber = util.number.toNumber,
+      toBigNumber = util.number.toBigNumber,
+      isBoolean = util.boolean.isBoolean,
+      isString = util.string.isString,
+      isComplex = Complex.isComplex,
+      isUnit = Unit.isUnit,
+      isCollection = collection.isCollection;
+
+  /**
+   * Check if value x is larger y
+   *
+   *    x > y
+   *    larger(x, y)
+   *
+   * For matrices, the function is evaluated element wise.
+   * In case of complex numbers, the absolute values of a and b are compared.
+   *
+   * @param  {Number | BigNumber | Boolean | Unit | String | Array | Matrix} x
+   * @param  {Number | BigNumber | Boolean | Unit | String | Array | Matrix} y
+   * @return {Boolean | Array | Matrix} res
+   */
+  math.larger = function larger(x, y) {
+    if (arguments.length != 2) {
+      throw new math.error.ArgumentsError('larger', arguments.length, 2);
+    }
+
+    if (isNumber(x) && isNumber(y)) {
+      return x > y;
+    }
+
+    if (x instanceof BigNumber) {
+      // try to convert to big number
+      if (isNumber(y)) {
+        y = toBigNumber(y);
+      }
+      else if (isBoolean(y)) {
+        y = new BigNumber(y ? 1 : 0);
+      }
+
+      if (y instanceof BigNumber) {
+        return x.gt(y);
+      }
+
+      // downgrade to Number
+      return larger(toNumber(x), y);
+    }
+    if (y instanceof BigNumber) {
+      // try to convert to big number
+      if (isNumber(x)) {
+        x = toBigNumber(x);
+      }
+      else if (isBoolean(x)) {
+        x = new BigNumber(x ? 1 : 0);
+      }
+
+      if (x instanceof BigNumber) {
+        return x.gt(y)
+      }
+
+      // downgrade to Number
+      return larger(x, toNumber(y));
+    }
+
+    if ((isUnit(x)) && (isUnit(y))) {
+      if (!x.equalBase(y)) {
+        throw new Error('Cannot compare units with different base');
+      }
+      return x.value > y.value;
+    }
+
+    if (isString(x) || isString(y)) {
+      return x > y;
+    }
+
+    if (isCollection(x) || isCollection(y)) {
+      return collection.deepMap2(x, y, larger);
+    }
+
+    if (isBoolean(x)) {
+      return larger(+x, y);
+    }
+    if (isBoolean(y)) {
+      return larger(x, +y);
+    }
+
+    if (isComplex(x) || isComplex(y)) {
+      throw new TypeError('No ordering relation is defined for complex numbers');
+    }
+
+    throw new math.error.UnsupportedTypeError('larger', x, y);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],131:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      Unit = require('../../type/Unit'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      toNumber = util.number.toNumber,
+      toBigNumber = util.number.toBigNumber,
+      isBoolean = util.boolean.isBoolean,
+      isString = util.string.isString,
+      isComplex = Complex.isComplex,
+      isUnit = Unit.isUnit,
+      isCollection = collection.isCollection;
+
+  /**
+   * Check if value x is larger or equal to y
+   *
+   *     x >= y
+   *     largereq(x, y)
+   *
+   * For matrices, the function is evaluated element wise.
+   * In case of complex numbers, the absolute values of a and b are compared.
+   *
+   * @param  {Number | BigNumber | Boolean | Unit | String | Array | Matrix} x
+   * @param  {Number | BigNumber | Boolean | Unit | String | Array | Matrix} y
+   * @return {Boolean | Array | Matrix} res
+   */
+  math.largereq = function largereq(x, y) {
+    if (arguments.length != 2) {
+      throw new math.error.ArgumentsError('largereq', arguments.length, 2);
+    }
+
+    if (isNumber(x) && isNumber(y)) {
+      return x >= y;
+    }
+
+    if (x instanceof BigNumber) {
+      // try to convert to big number
+      if (isNumber(y)) {
+        y = toBigNumber(y);
+      }
+      else if (isBoolean(y)) {
+        y = new BigNumber(y ? 1 : 0);
+      }
+
+      if (y instanceof BigNumber) {
+        return x.gte(y);
+      }
+
+      // downgrade to Number
+      return largereq(toNumber(x), y);
+    }
+    if (y instanceof BigNumber) {
+      // try to convert to big number
+      if (isNumber(x)) {
+        x = toBigNumber(x);
+      }
+      else if (isBoolean(x)) {
+        x = new BigNumber(x ? 1 : 0);
+      }
+
+      if (x instanceof BigNumber) {
+        return x.gte(y)
+      }
+
+      // downgrade to Number
+      return largereq(x, toNumber(y));
+    }
+
+    if ((isUnit(x)) && (isUnit(y))) {
+      if (!x.equalBase(y)) {
+        throw new Error('Cannot compare units with different base');
+      }
+      return x.value >= y.value;
+    }
+
+    if (isString(x) || isString(y)) {
+      return x >= y;
+    }
+
+    if (isCollection(x) || isCollection(y)) {
+      return collection.deepMap2(x, y, largereq);
+    }
+
+    if (isBoolean(x)) {
+      return largereq(+x, y);
+    }
+    if (isBoolean(y)) {
+      return largereq(x, +y);
+    }
+
+    if (isComplex(x) || isComplex(y)) {
+      throw new TypeError('No ordering relation is defined for complex numbers');
+    }
+
+    throw new math.error.UnsupportedTypeError('largereq', x, y);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],132:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      toNumber = util.number.toNumber,
+      isBoolean = util.boolean.isBoolean,
+      isInteger = util.number.isInteger,
+      isCollection = collection.isCollection;
+
+  /**
+   * Calculate the least common multiple for two or more values or arrays.
+   *
+   *     lcm(a, b)
+   *     lcm(a, b, c, ...)
+   *
+   * lcm is defined as:
+   *     lcm(a, b) = abs(a * b) / gcd(a, b)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param {... Number | Boolean | Array | Matrix} args    two or more integer numbers
+   * @return {Number | Array | Matrix} least common multiple
+   */
+  math.lcm = function lcm(args) {
+    var a = arguments[0],
+        b = arguments[1],
+        t;
+
+    if (arguments.length == 2) {
+      // two arguments
+      if (isNumber(a) && isNumber(b)) {
+        if (!isInteger(a) || !isInteger(b)) {
+          throw new Error('Parameters in function lcm must be integer numbers');
+        }
+
+        if (a == 0 || b == 0) {
+          return 0;
+        }
+
+        // http://en.wikipedia.org/wiki/Euclidean_algorithm
+        // evaluate gcd here inline to reduce overhead
+        var prod = a * b;
+        while (b != 0) {
+          t = b;
+          b = a % t;
+          a = t;
+        }
+        return Math.abs(prod / a);
+      }
+
+      // evaluate lcm element wise
+      if (isCollection(a) || isCollection(b)) {
+        return collection.deepMap2(a, b, lcm);
+      }
+
+      if (isBoolean(a)) {
+        return lcm(+a, b);
+      }
+      if (isBoolean(b)) {
+        return lcm(a, +b);
+      }
+
+      // TODO: implement BigNumber support for lcm
+
+      // downgrade bignumbers to numbers
+      if (a instanceof BigNumber) {
+        return lcm(toNumber(a), b);
+      }
+      if (b instanceof BigNumber) {
+        return lcm(a, toNumber(b));
+      }
+
+      throw new math.error.UnsupportedTypeError('lcm', a, b);
+    }
+
+    if (arguments.length > 2) {
+      // multiple arguments. Evaluate them iteratively
+      for (var i = 1; i < arguments.length; i++) {
+        a = lcm(a, arguments[i]);
+      }
+      return a;
+    }
+
+    // zero or one argument
+    throw new SyntaxError('Function lcm expects two or more arguments');
+  };
+};
+
+},{"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],133:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isComplex = Complex.isComplex,
+      isCollection = collection.isCollection;
+
+  /**
+   * Calculate the logarithm of a value
+   *
+   *     log(x)
+   *     log(x, base)
+   *
+   * base is optional. If not provided, the natural logarithm of x is calculated.
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param {Number | Boolean | Complex | Array | Matrix} x
+   * @param {Number | Boolean | Complex} [base]
+   * @return {Number | Complex | Array | Matrix} res
+   */
+  math.log = function log(x, base) {
+    if (arguments.length == 1) {
+      // calculate natural logarithm, log(x)
+      if (isNumber(x)) {
+        if (x >= 0) {
+          return Math.log(x);
+        }
+        else {
+          // negative value -> complex value computation
+          return log(new Complex(x, 0));
+        }
+      }
+
+      if (isComplex(x)) {
+        return new Complex (
+            Math.log(Math.sqrt(x.re * x.re + x.im * x.im)),
+            Math.atan2(x.im, x.re)
+        );
+      }
+
+      if (x instanceof BigNumber) {
+        // TODO: implement BigNumber support
+        // downgrade to Number
+        return log(util.number.toNumber(x));
+      }
+
+      if (isCollection(x)) {
+        return collection.deepMap(x, log);
+      }
+
+      if (isBoolean(x)) {
+        return log(+x);
+      }
+
+      throw new math.error.UnsupportedTypeError('log', x);
+    }
+    else if (arguments.length == 2) {
+      // calculate logarithm for a specified base, log(x, base)
+      return math.divide(log(x), log(base));
+    }
+    else {
+      throw new math.error.ArgumentsError('log', arguments.length, 1, 2);
+    }
+  };
+};
+
+},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],134:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isComplex = Complex.isComplex,
+      isCollection = collection.isCollection;
+
+  /**
+   * Calculate the 10-base logarithm of a value
+   *
+   *     log10(x)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param {Number | Boolean | Complex | Array | Matrix} x
+   * @return {Number | Complex | Array | Matrix} res
+   */
+  math.log10 = function log10(x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('log10', arguments.length, 1);
+    }
+
+    if (isNumber(x)) {
+      if (x >= 0) {
+        return Math.log(x) / Math.LN10;
+      }
+      else {
+        // negative value -> complex value computation
+        return log10(new Complex(x, 0));
+      }
+    }
+
+    if (x instanceof BigNumber) {
+      // TODO: implement BigNumber support
+      // downgrade to Number
+      return log10(util.number.toNumber(x));
+    }
+
+    if (isComplex(x)) {
+      return new Complex (
+          Math.log(Math.sqrt(x.re * x.re + x.im * x.im)) / Math.LN10,
+          Math.atan2(x.im, x.re) / Math.LN10
+      );
+    }
+
+    if (isCollection(x)) {
+      return collection.deepMap(x, log10);
+    }
+
+    if (isBoolean(x)) {
+      return log10(+x);
+    }
+
+    throw new math.error.UnsupportedTypeError('log10', x);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],135:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      toNumber = util.number.toNumber,
+      toBigNumber = util.number.toBigNumber,
+      isBoolean = util.boolean.isBoolean,
+      isCollection = collection.isCollection;
+
+  /**
+   * Calculates the modulus, the remainder of an integer division.
+   *
+   *     x % y
+   *     mod(x, y)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param  {Number | BigNumber | Boolean | Array | Matrix} x
+   * @param  {Number | BigNumber | Boolean | Array | Matrix} y
+   * @return {Number | BigNumber | Array | Matrix} res
+   */
+  math.mod = function mod(x, y) {
+    if (arguments.length != 2) {
+      throw new math.error.ArgumentsError('mod', arguments.length, 2);
+    }
+
+    // see http://functions.wolfram.com/IntegerFunctions/Mod/
+
+    if (isNumber(x)) {
+      if (isNumber(y)) {
+        // number % number
+        return _mod(x, y);
+      }
+    }
+
+    if (x instanceof BigNumber) {
+      // try to convert to big number
+      if (isNumber(y)) {
+        y = toBigNumber(y);
+      }
+      else if (isBoolean(y)) {
+        y = new BigNumber(y ? 1 : 0);
+      }
+
+      if (y instanceof BigNumber) {
+        return x.mod(y);
+      }
+
+      // downgrade to Number
+      return mod(toNumber(x), y);
+    }
+    if (y instanceof BigNumber) {
+      // try to convert to big number
+      if (isNumber(x)) {
+        x = toBigNumber(x);
+      }
+      else if (isBoolean(x)) {
+        x = new BigNumber(x ? 1 : 0);
+      }
+
+      if (x instanceof BigNumber) {
+        return x.mod(y)
+      }
+
+      // downgrade to Number
+      return mod(x, toNumber(y));
+    }
+
+    // TODO: implement mod for complex values
+
+    if (isCollection(x) || isCollection(y)) {
+      return collection.deepMap2(x, y, mod);
+    }
+
+    if (isBoolean(x)) {
+      return mod(+x, y);
+    }
+    if (isBoolean(y)) {
+      return mod(x, +y);
+    }
+
+    throw new math.error.UnsupportedTypeError('mod', x, y);
+  };
+
+  /**
+   * Calculate the modulus of two numbers
+   * @param {Number} x
+   * @param {Number} y
+   * @returns {number} res
+   * @private
+   */
+  function _mod(x, y) {
+    if (y > 0) {
+      if (x > 0) {
+        return x % y;
+      }
+      else if (x == 0) {
+        return 0;
+      }
+      else { // x < 0
+        return x - y * Math.floor(x / y);
+      }
+    }
+    else if (y == 0) {
+      return x;
+    }
+    else { // y < 0
+      // TODO: implement mod for a negative divisor
+      throw new Error('Cannot calculate mod for a negative divisor');
+    }
+  }
+};
+
+},{"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],136:[function(require,module,exports){
+module.exports = function(math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      Matrix = require('../../type/Matrix'),
+      Unit = require('../../type/Unit'),
+      collection = require('../../type/collection'),
+
+      array = util.array,
+      isNumber = util.number.isNumber,
+      toNumber = util.number.toNumber,
+      toBigNumber = util.number.toBigNumber,
+      isBoolean = util.boolean.isBoolean,
+      isComplex = Complex.isComplex,
+      isArray = Array.isArray,
+      isUnit = Unit.isUnit;
+
+  /**
+   * Multiply two values.
+   *
+   *     x * y
+   *     multiply(x, y)
+   *
+   * @param  {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix} x
+   * @param  {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix} y
+   * @return {Number | BigNumber | Complex | Unit | Array | Matrix} res
+   */
+  math.multiply = function multiply(x, y) {
+    if (arguments.length != 2) {
+      throw new math.error.ArgumentsError('multiply', arguments.length, 2);
+    }
+
+    if (isNumber(x)) {
+      if (isNumber(y)) {
+        // number * number
+        return x * y;
+      }
+      else if (isComplex(y)) {
+        // number * complex
+        return _multiplyComplex (new Complex(x, 0), y);
+      }
+      else if (isUnit(y)) {
+        res = y.clone();
+        res.value *= x;
+        return res;
+      }
+    }
+
+    if (isComplex(x)) {
+      if (isNumber(y)) {
+        // complex * number
+        return _multiplyComplex (x, new Complex(y, 0));
+      }
+      else if (isComplex(y)) {
+        // complex * complex
+        return _multiplyComplex (x, y);
+      }
+    }
+
+    if (x instanceof BigNumber) {
+      // try to convert to big number
+      if (isNumber(y)) {
+        y = toBigNumber(y);
+      }
+      else if (isBoolean(y)) {
+        y = new BigNumber(y ? 1 : 0);
+      }
+
+      if (y instanceof BigNumber) {
+        return x.times(y);
+      }
+
+      // downgrade to Number
+      return multiply(toNumber(x), y);
+    }
+    if (y instanceof BigNumber) {
+      // try to convert to big number
+      if (isNumber(x)) {
+        x = toBigNumber(x);
+      }
+      else if (isBoolean(x)) {
+        x = new BigNumber(x ? 1 : 0);
+      }
+
+      if (x instanceof BigNumber) {
+        return x.times(y)
+      }
+
+      // downgrade to Number
+      return multiply(x, toNumber(y));
+    }
+
+    if (isUnit(x)) {
+      if (isNumber(y)) {
+        res = x.clone();
+        res.value *= y;
+        return res;
+      }
+    }
+
+    if (isArray(x)) {
+      if (isArray(y)) {
+        // array * array
+        var sizeX = array.size(x);
+        var sizeY = array.size(y);
+
+        if (sizeX.length == 1) {
+          if (sizeY.length == 1) {
+            // vector * vector
+            if (sizeX[0] != sizeY[0]) {
+              throw new RangeError('Dimensions mismatch in multiplication. ' +
+                  'Length of A must match length of B ' +
+                  '(A is ' + sizeX[0] +
+                  ', B is ' + sizeY[0] +
+                  sizeX[0] + ' != ' + sizeY[0] + ')');
+            }
+
+            return _multiplyVectorVector(x, y);
+          }
+          else if (sizeY.length == 2) {
+            // vector * matrix
+            if (sizeX[0] != sizeY[0]) {
+              throw new RangeError('Dimensions mismatch in multiplication. ' +
+                  'Length of A must match rows of B ' +
+                  '(A is ' + sizeX[0] +
+                  ', B is ' + sizeY[0] + 'x' + sizeY[1] + ', ' +
+                  sizeX[0] + ' != ' + sizeY[0] + ')');
+            }
+
+            return _multiplyVectorMatrix(x, y);
+          }
+          else {
+            throw new Error('Can only multiply a 1 or 2 dimensional matrix ' +
+                '(B has ' + sizeY.length + ' dimensions)');
+          }
+        }
+        else if (sizeX.length == 2) {
+          if (sizeY.length == 1) {
+            // matrix * vector
+            if (sizeX[1] != sizeY[0]) {
+              throw new RangeError('Dimensions mismatch in multiplication. ' +
+                  'Columns of A must match length of B ' +
+                  '(A is ' + sizeX[0] + 'x' + sizeX[0] +
+                  ', B is ' + sizeY[0] + ', ' +
+                  sizeX[1] + ' != ' + sizeY[0] + ')');
+            }
+
+            return _multiplyMatrixVector(x, y);
+          }
+          else if (sizeY.length == 2) {
+            // matrix * matrix
+            if (sizeX[1] != sizeY[0]) {
+              throw new RangeError('Dimensions mismatch in multiplication. ' +
+                  'Columns of A must match rows of B ' +
+                  '(A is ' + sizeX[0] + 'x' + sizeX[1] +
+                  ', B is ' + sizeY[0] + 'x' + sizeY[1] + ', ' +
+                  sizeX[1] + ' != ' + sizeY[0] + ')');
+            }
+
+            return _multiplyMatrixMatrix(x, y);
+          }
+          else {
+            throw new Error('Can only multiply a 1 or 2 dimensional matrix ' +
+                '(B has ' + sizeY.length + ' dimensions)');
+          }
+        }
+        else {
+          throw new Error('Can only multiply a 1 or 2 dimensional matrix ' +
+              '(A has ' + sizeX.length + ' dimensions)');
+        }
+      }
+      else if (y instanceof Matrix) {
+        // array * matrix
+        return new Matrix(multiply(x, y.valueOf()));
+      }
+      else {
+        // array * scalar
+        return collection.deepMap2(x, y, multiply);
+      }
+    }
+
+    if (x instanceof Matrix) {
+      if (y instanceof Matrix) {
+        // matrix * matrix
+        return new Matrix(multiply(x.valueOf(), y.valueOf()));
+      }
+      else {
+        // matrix * array
+        // matrix * scalar
+        return new Matrix(multiply(x.valueOf(), y));
+      }
+    }
+
+    if (isArray(y)) {
+      // scalar * array
+      return collection.deepMap2(x, y, multiply);
+    }
+    else if (y instanceof Matrix) {
+      // scalar * matrix
+      return new Matrix(collection.deepMap2(x, y.valueOf(), multiply));
+    }
+
+    if (isBoolean(x)) {
+      return multiply(+x, y);
+    }
+    if (isBoolean(y)) {
+      return multiply(x, +y);
+    }
+
+    throw new math.error.UnsupportedTypeError('multiply', x, y);
+  };
+
+  /**
+   * Multiply two 2-dimensional matrices.
+   * The size of the matrices is not validated.
+   * @param {Array} x   A 2d matrix
+   * @param {Array} y   A 2d matrix
+   * @return {Array} result
+   * @private
+   */
+  function _multiplyMatrixMatrix(x, y) {
+    // TODO: performance of matrix multiplication can be improved
+    var res = [],
+        rows = x.length,
+        cols = y[0].length,
+        num = x[0].length;
+
+    for (var r = 0; r < rows; r++) {
+      res[r] = [];
+      for (var c = 0; c < cols; c++) {
+        var result = null;
+        for (var n = 0; n < num; n++) {
+          var p = math.multiply(x[r][n], y[n][c]);
+          result = (result === null) ? p : math.add(result, p);
+        }
+        res[r][c] = result;
+      }
+    }
+
+    return res;
+  }
+
+  /**
+   * Multiply a vector with a 2-dimensional matrix
+   * The size of the matrices is not validated.
+   * @param {Array} x   A vector
+   * @param {Array} y   A 2d matrix
+   * @return {Array} result
+   * @private
+   */
+  function _multiplyVectorMatrix(x, y) {
+    // TODO: performance of matrix multiplication can be improved
+    var res = [],
+        rows = y.length,
+        cols = y[0].length;
+
+    for (var c = 0; c < cols; c++) {
+      var result = null;
+      for (var r = 0; r < rows; r++) {
+        var p = math.multiply(x[r], y[r][c]);
+        result = (r === 0) ? p : math.add(result, p);
+      }
+      res[c] = result;
+    }
+
+    return res;
+  }
+
+  /**
+   * Multiply a 2-dimensional matrix with a vector
+   * The size of the matrices is not validated.
+   * @param {Array} x   A 2d matrix
+   * @param {Array} y   A vector
+   * @return {Array} result
+   * @private
+   */
+  function _multiplyMatrixVector(x, y) {
+    // TODO: performance of matrix multiplication can be improved
+    var res = [],
+        rows = x.length,
+        cols = x[0].length;
+
+    for (var r = 0; r < rows; r++) {
+      var result = null;
+      for (var c = 0; c < cols; c++) {
+        var p = math.multiply(x[r][c], y[c]);
+        result = (c === 0) ? p : math.add(result, p);
+      }
+      res[r] = result;
+    }
+
+    return res;
+  }
+
+  /**
+   * Multiply two vectors, calculate the dot product
+   * The size of the matrices is not validated.
+   * @param {Array} x   A vector
+   * @param {Array} y   A vector
+   * @return {Number} dotProduct
+   * @private
+   */
+  function _multiplyVectorVector(x, y) {
+    // TODO: performance of matrix multiplication can be improved
+    var len = x.length,
+        dot = null;
+
+    if (len) {
+      dot = 0;
+
+      for (var i = 0, ii = x.length; i < ii; i++) {
+        dot = math.add(dot, math.multiply(x[i], y[i]));
+      }
+    }
+
+    return dot;
+  }
+
+  /**
+   * Multiply two complex numbers. x * y or multiply(x, y)
+   * @param {Complex} x
+   * @param {Complex} y
+   * @return {Complex | Number} res
+   * @private
+   */
+  function _multiplyComplex (x, y) {
+    // Note: we test whether x or y are pure real or pure complex,
+    // to prevent unnecessary NaN values. For example, Infinity*i should
+    // result in Infinity*i, and not in NaN+Infinity*i
+
+    if (x.im == 0) {
+      // x is pure real
+      if (y.im == 0) {
+        // y is pure real
+        return x.re * y.re;
+      }
+      else if (y.re == 0) {
+        // y is pure complex
+        return new Complex(
+            0,
+            x.re * y.im
+        );
+      }
+      else {
+        // y has a real and complex part
+        return new Complex(
+            x.re * y.re,
+            x.re * y.im
+        );
+      }
+    }
+    else if (x.re == 0) {
+      // x is pure complex
+      if (y.im == 0) {
+        // y is pure real
+        return new Complex(
+            0,
+            x.im * y.re
+        );
+      }
+      else if (y.re == 0) {
+        // y is pure complex
+        return -x.im * y.im;
+      }
+      else {
+        // y has a real and complex part
+        return new Complex(
+            -x.im * y.im,
+            x.im * y.re
+        );
+      }
+    }
+    else {
+      // x has a real and complex part
+      if (y.im == 0) {
+        // y is pure real
+        return new Complex(
+            x.re * y.re,
+            x.im * y.re
+        );
+      }
+      else if (y.re == 0) {
+        // y is pure complex
+        return new Complex(
+            -x.im * y.im,
+            x.re * y.im
+        );
+      }
+      else {
+        // y has a real and complex part
+        return new Complex(
+            x.re * y.re - x.im * y.im,
+            x.re * y.im + x.im * y.re
+        );
+      }
+    }
+  }
+};
+
+},{"../../type/Complex":202,"../../type/Matrix":205,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],137:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      Matrix = require('../../type/Matrix'),
+      collection = require('../../type/collection'),
+
+      array = util.array,
+      isNumber = util.number.isNumber,
+      toNumber = util.number.toNumber,
+      toBigNumber = util.number.toBigNumber,
+      isBoolean = util.boolean.isBoolean,
+      isArray = Array.isArray,
+      isInteger = util.number.isInteger,
+      isComplex = Complex.isComplex;
+
+  /**
+   * Calculates the power of x to y
+   *
+   *     x ^ y
+   *     pow(x, y)
+   *
+   * @param  {Number | BigNumber | Boolean | Complex | Array | Matrix} x
+   * @param  {Number | BigNumber | Boolean | Complex} y
+   * @return {Number | BigNumber | Complex | Array | Matrix} res
+   */
+  math.pow = function pow(x, y) {
+    if (arguments.length != 2) {
+      throw new math.error.ArgumentsError('pow', arguments.length, 2);
+    }
+
+    if (isNumber(x)) {
+      if (isNumber(y)) {
+        if (isInteger(y) || x >= 0) {
+          // real value computation
+          return Math.pow(x, y);
+        }
+        else {
+          return powComplex(new Complex(x, 0), new Complex(y, 0));
+        }
+      }
+      else if (isComplex(y)) {
+        return powComplex(new Complex(x, 0), y);
+      }
+    }
+
+    if (isComplex(x)) {
+      if (isNumber(y)) {
+        return powComplex(x, new Complex(y, 0));
+      }
+      else if (isComplex(y)) {
+        return powComplex(x, y);
+      }
+    }
+
+    // TODO: pow for complex numbers and bignumbers
+
+    if (x instanceof BigNumber) {
+      // try to convert to big number
+      if (isNumber(y)) {
+        y = toBigNumber(y);
+      }
+      else if (isBoolean(y)) {
+        y = new BigNumber(y ? 1 : 0);
+      }
+
+      if (y instanceof BigNumber) {
+        return x.pow(y);
+      }
+
+      // downgrade to Number
+      return pow(toNumber(x), y);
+    }
+    if (y instanceof BigNumber) {
+      // try to convert to big number
+      if (isNumber(x)) {
+        x = toBigNumber(x);
+      }
+      else if (isBoolean(x)) {
+        x = new BigNumber(x ? 1 : 0);
+      }
+
+      if (x instanceof BigNumber) {
+        return x.pow(y)
+      }
+
+      // downgrade to Number
+      return pow(x, toNumber(y));
+    }
+
+
+    if (isArray(x)) {
+      if (!isNumber(y) || !isInteger(y) || y < 0) {
+        throw new TypeError('For A^b, b must be a positive integer ' +
+            '(value is ' + y + ')');
+      }
+      // verify that A is a 2 dimensional square matrix
+      var s = array.size(x);
+      if (s.length != 2) {
+        throw new Error('For A^b, A must be 2 dimensional ' +
+            '(A has ' + s.length + ' dimensions)');
+      }
+      if (s[0] != s[1]) {
+        throw new Error('For A^b, A must be square ' +
+            '(size is ' + s[0] + 'x' + s[1] + ')');
+      }
+
+      if (y == 0) {
+        // return the identity matrix
+        return math.eye(s[0]);
+      }
+      else {
+        // value > 0
+        var res = x;
+        for (var i = 1; i < y; i++) {
+          res = math.multiply(x, res);
+        }
+        return res;
+      }
+    }
+    else if (x instanceof Matrix) {
+      return new Matrix(pow(x.valueOf(), y));
+    }
+
+    if (isBoolean(x)) {
+      return pow(+x, y);
+    }
+    if (isBoolean(y)) {
+      return pow(x, +y);
+    }
+
+    throw new math.error.UnsupportedTypeError('pow', x, y);
+  };
+
+  /**
+   * Calculates the power of x to y, x^y, for two complex numbers.
+   * @param {Complex} x
+   * @param {Complex} y
+   * @return {Complex} res
+   * @private
+   */
+  function powComplex (x, y) {
+    // complex computation
+    // x^y = exp(log(x)*y) = exp((abs(x)+i*arg(x))*y)
+    var temp1 = math.log(x);
+    var temp2 = math.multiply(temp1, y);
+    return math.exp(temp2);
+  }
+};
+
+},{"../../type/Complex":202,"../../type/Matrix":205,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],138:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      isInteger = util.number.isInteger,
+      isBoolean = util.boolean.isBoolean,
+      isComplex = Complex.isComplex,
+      isCollection = collection.isCollection;
+
+  /**
+   * Round a value towards the nearest integer
+   *
+   *     round(x)
+   *     round(x, n)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param  {Number | BigNumber | Boolean | Complex | Array | Matrix} x
+   * @param  {Number | BigNumber | Boolean | Array} [n] number of decimals (by default n=0)
+   * @return {Number | BigNumber | Complex | Array | Matrix} res
+   */
+  math.round = function round(x, n) {
+    if (arguments.length != 1 && arguments.length != 2) {
+      throw new math.error.ArgumentsError('round', arguments.length, 1, 2);
+    }
+
+    if (n == undefined) {
+      // round (x)
+      if (isNumber(x)) {
+        return Math.round(x);
+      }
+
+      if (isComplex(x)) {
+        return new Complex (
+            Math.round(x.re),
+            Math.round(x.im)
+        );
+      }
+
+      if (x instanceof BigNumber) {
+        return x.round();
+      }
+
+      if (isCollection(x)) {
+        return collection.deepMap(x, round);
+      }
+
+      if (isBoolean(x)) {
+        return Math.round(x);
+      }
+
+      throw new math.error.UnsupportedTypeError('round', x);
+    }
+    else {
+      // round (x, n)
+      if (n instanceof BigNumber) {
+        n = parseFloat(n.valueOf());
+      }
+
+      if (!isNumber(n) || !isInteger(n)) {
+        throw new TypeError('Number of decimals in function round must be an integer');
+      }
+      if (n < 0 || n > 9) {
+        throw new Error ('Number of decimals in function round must be in te range of 0-9');
+      }
+
+      if (isNumber(x)) {
+        return roundNumber(x, n);
+      }
+
+      if (isComplex(x)) {
+        return new Complex (
+            roundNumber(x.re, n),
+            roundNumber(x.im, n)
+        );
+      }
+
+      if (x instanceof BigNumber) {
+        if (isNumber(n)) {
+          return x.round(n);
+        }
+      }
+
+      if (isCollection(x) || isCollection(n)) {
+        return collection.deepMap2(x, n, round);
+      }
+
+      if (isBoolean(x)) {
+        return round(+x, n);
+      }
+      if (isBoolean(n)) {
+        return round(x, +n);
+      }
+
+      throw new math.error.UnsupportedTypeError('round', x, n);
+    }
+  };
+
+  /**
+   * round a number to the given number of decimals, or to zero if decimals is
+   * not provided
+   * @param {Number} value
+   * @param {Number} [decimals]  number of decimals, between 0 and 15 (0 by default)
+   * @return {Number} roundedValue
+   */
+  function roundNumber (value, decimals) {
+    if (decimals) {
+      var p = Math.pow(10, decimals);
+      return Math.round(value * p) / p;
+    }
+    else {
+      return Math.round(value);
+    }
+  }
+};
+
+},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],139:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      collection = require('../../type/collection'),
+
+      number = util.number,
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isComplex = Complex.isComplex,
+      isCollection = collection.isCollection;
+
+  /**
+   * Compute the sign of a value.
+   *
+   *     sign(x)
+   *
+   * The sign of a value x is 1 when x > 1, -1 when x < 0, and 0 when x == 0
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param {Number | BigNumber | Boolean | Complex | Array | Matrix} x
+   * @return {Number | BigNumber | Complex | Array | Matrix} res
+   */
+  math.sign = function sign(x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('sign', arguments.length, 1);
+    }
+
+    if (isNumber(x)) {
+      return number.sign(x);
+    }
+
+    if (isComplex(x)) {
+      var abs = Math.sqrt(x.re * x.re + x.im * x.im);
+      return new Complex(x.re / abs, x.im / abs);
+    }
+
+    if (x instanceof BigNumber) {
+      return new BigNumber(x.cmp(0));
+    }
+
+    if (isCollection(x)) {
+      return collection.deepMap(x, sign);
+    }
+
+    if (isBoolean(x)) {
+      return number.sign(x);
+    }
+
+    throw new math.error.UnsupportedTypeError('sign', x);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],140:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      Unit = require('../../type/Unit'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      toNumber = util.number.toNumber,
+      toBigNumber = util.number.toBigNumber,
+      isBoolean = util.boolean.isBoolean,
+      isString = util.string.isString,
+      isComplex = Complex.isComplex,
+      isUnit = Unit.isUnit,
+      isCollection = collection.isCollection;
+
+  /**
+   * Check if value x is smaller y
+   *
+   *     x < y
+   *     smaller(x, y)
+   *
+   * For matrices, the function is evaluated element wise.
+   * In case of complex numbers, the absolute values of a and b are compared.
+   *
+   * @param  {Number | BigNumber | Boolean | Unit | String | Array | Matrix} x
+   * @param  {Number | BigNumber | Boolean | Unit | String | Array | Matrix} y
+   * @return {Boolean | Array | Matrix} res
+   */
+  math.smaller = function smaller(x, y) {
+    if (arguments.length != 2) {
+      throw new math.error.ArgumentsError('smaller', arguments.length, 2);
+    }
+
+    if (isNumber(x) && isNumber(y)) {
+      return x < y;
+    }
+
+    if (x instanceof BigNumber) {
+      // try to convert to big number
+      if (isNumber(y)) {
+        y = toBigNumber(y);
+      }
+      else if (isBoolean(y)) {
+        y = new BigNumber(y ? 1 : 0);
+      }
+
+      if (y instanceof BigNumber) {
+        return x.lt(y);
+      }
+
+      // downgrade to Number
+      return smaller(toNumber(x), y);
+    }
+    if (y instanceof BigNumber) {
+      // try to convert to big number
+      if (isNumber(x)) {
+        x = toBigNumber(x);
+      }
+      else if (isBoolean(x)) {
+        x = new BigNumber(x ? 1 : 0);
+      }
+
+      if (x instanceof BigNumber) {
+        return x.lt(y)
+      }
+
+      // downgrade to Number
+      return smaller(x, toNumber(y));
+    }
+
+    if ((isUnit(x)) && (isUnit(y))) {
+      if (!x.equalBase(y)) {
+        throw new Error('Cannot compare units with different base');
+      }
+      return x.value < y.value;
+    }
+
+    if (isString(x) || isString(y)) {
+      return x < y;
+    }
+
+    if (isCollection(x) || isCollection(y)) {
+      return collection.deepMap2(x, y, smaller);
+    }
+
+    if (isBoolean(x)) {
+      return smaller(+x, y);
+    }
+    if (isBoolean(y)) {
+      return smaller(x, +y);
+    }
+
+    if (isComplex(x) || isComplex(y)) {
+      throw new TypeError('No ordering relation is defined for complex numbers');
+    }
+
+    throw new math.error.UnsupportedTypeError('smaller', x, y);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],141:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      Unit = require('../../type/Unit'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      toNumber = util.number.toNumber,
+      toBigNumber = util.number.toBigNumber,
+      isBoolean = util.boolean.isBoolean,
+      isString = util.string.isString,
+      isComplex = Complex.isComplex,
+      isUnit = Unit.isUnit,
+      isCollection = collection.isCollection;
+
+  /**
+   * Check if value a is smaller or equal to b
+   *
+   *     a <= b
+   *     smallereq(a, b)
+   *
+   * For matrices, the function is evaluated element wise.
+   * In case of complex numbers, the absolute values of a and b are compared.
+   *
+   * @param  {Number | BigNumber | Boolean | Complex | Unit | String | Array | Matrix} x
+   * @param  {Number | BigNumber | Boolean | Complex | Unit | String | Array | Matrix} y
+   * @return {Boolean | Array | Matrix} res
+   */
+  math.smallereq = function smallereq(x, y) {
+    if (arguments.length != 2) {
+      throw new math.error.ArgumentsError('smallereq', arguments.length, 2);
+    }
+
+    if (isNumber(x) && isNumber(y)) {
+      return x <= y;
+    }
+
+    if (x instanceof BigNumber) {
+      // try to convert to big number
+      if (isNumber(y)) {
+        y = toBigNumber(y);
+      }
+      else if (isBoolean(y)) {
+        y = new BigNumber(y ? 1 : 0);
+      }
+
+      if (y instanceof BigNumber) {
+        return x.lte(y);
+      }
+
+      // downgrade to Number
+      return smallereq(toNumber(x), y);
+    }
+    if (y instanceof BigNumber) {
+      // try to convert to big number
+      if (isNumber(x)) {
+        x = toBigNumber(x);
+      }
+      else if (isBoolean(x)) {
+        x = new BigNumber(x ? 1 : 0);
+      }
+
+      if (x instanceof BigNumber) {
+        return x.lte(y)
+      }
+
+      // downgrade to Number
+      return smallereq(x, toNumber(y));
+    }
+
+    if ((isUnit(x)) && (isUnit(y))) {
+      if (!x.equalBase(y)) {
+        throw new Error('Cannot compare units with different base');
+      }
+      return x.value <= y.value;
+    }
+
+    if (isString(x) || isString(y)) {
+      return x <= y;
+    }
+
+    if (isCollection(x) || isCollection(y)) {
+      return collection.deepMap2(x, y, smallereq);
+    }
+
+    if (isBoolean(x)) {
+      return smallereq(+x, y);
+    }
+    if (isBoolean(y)) {
+      return smallereq(x, +y);
+    }
+
+    if (isComplex(x) || isComplex(y)) {
+      throw new TypeError('No ordering relation is defined for complex numbers');
+    }
+
+    throw new math.error.UnsupportedTypeError('smallereq', x, y);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],142:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isComplex = Complex.isComplex,
+      isCollection = collection.isCollection;
+
+  /**
+   * Calculate the square root of a value
+   *
+   *     sqrt(x)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param {Number | Boolean | Complex | Array | Matrix} x
+   * @return {Number | Complex | Array | Matrix} res
+   */
+  math.sqrt = function sqrt (x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('sqrt', arguments.length, 1);
+    }
+
+    if (isNumber(x)) {
+      if (x >= 0) {
+        return Math.sqrt(x);
+      }
+      else {
+        return sqrt(new Complex(x, 0));
+      }
+    }
+
+    if (isComplex(x)) {
+      var r = Math.sqrt(x.re * x.re + x.im * x.im);
+      if (x.im >= 0) {
+        return new Complex(
+            0.5 * Math.sqrt(2.0 * (r + x.re)),
+            0.5 * Math.sqrt(2.0 * (r - x.re))
+        );
+      }
+      else {
+        return new Complex(
+            0.5 * Math.sqrt(2.0 * (r + x.re)),
+            -0.5 * Math.sqrt(2.0 * (r - x.re))
+        );
+      }
+    }
+
+    if (x instanceof BigNumber) {
+      return x.sqrt();
+    }
+
+    if (isCollection(x)) {
+      return collection.deepMap(x, sqrt);
+    }
+
+    if (isBoolean(x)) {
+      return sqrt(+x);
+    }
+
+    throw new math.error.UnsupportedTypeError('sqrt', x);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],143:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isComplex = Complex.isComplex,
+      isCollection = collection.isCollection;
+
+  /**
+   * Compute the square of a value
+   *
+   *     x .* x
+   *     square(x)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param  {Number | BigNumber | Boolean | Complex | Array | Matrix} x
+   * @return {Number | BigNumber | Complex | Array | Matrix} res
+   */
+  math.square = function square(x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('square', arguments.length, 1);
+    }
+
+    if (isNumber(x)) {
+      return x * x;
+    }
+
+    if (isComplex(x)) {
+      return math.multiply(x, x);
+    }
+
+    if (x instanceof BigNumber) {
+      return x.times(x);
+    }
+
+    if (isCollection(x)) {
+      return collection.deepMap(x, square);
+    }
+
+    if (isBoolean(x)) {
+      return x * x;
+    }
+
+    throw new math.error.UnsupportedTypeError('square', x);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],144:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      Matrix = require('../../type/Matrix'),
+      Unit = require('../../type/Unit'),
+      collection = require('../../type/collection'),
+
+      toNumber = util.number.toNumber,
+      toBigNumber = util.number.toBigNumber,
+      isBoolean = util.boolean.isBoolean,
+      isNumber = util.number.isNumber,
+      isComplex = Complex.isComplex,
+      isUnit = Unit.isUnit,
+      isCollection = collection.isCollection;
+
+  /**
+   * Subtract two values
+   *
+   *     x - y
+   *     subtract(x, y)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param  {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix} x
+   * @param  {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix} y
+   * @return {Number | BigNumber | Complex | Unit | Array | Matrix} res
+   */
+  math.subtract = function subtract(x, y) {
+    if (arguments.length != 2) {
+      throw new math.error.ArgumentsError('subtract', arguments.length, 2);
+    }
+
+    if (isNumber(x)) {
+      if (isNumber(y)) {
+        // number - number
+        return x - y;
+      }
+      else if (isComplex(y)) {
+        // number - complex
+        return new Complex (
+            x - y.re,
+            - y.im
+        );
+      }
+    }
+    else if (isComplex(x)) {
+      if (isNumber(y)) {
+        // complex - number
+        return new Complex (
+            x.re - y,
+            x.im
+        )
+      }
+      else if (isComplex(y)) {
+        // complex - complex
+        return new Complex (
+            x.re - y.re,
+            x.im - y.im
+        )
+      }
+    }
+
+    if (x instanceof BigNumber) {
+      // try to convert to big number
+      if (isNumber(y)) {
+        y = toBigNumber(y);
+      }
+      else if (isBoolean(y)) {
+        y = new BigNumber(y ? 1 : 0);
+      }
+
+      if (y instanceof BigNumber) {
+        return x.minus(y);
+      }
+
+      // downgrade to Number
+      return subtract(toNumber(x), y);
+    }
+    if (y instanceof BigNumber) {
+      // try to convert to big number
+      if (isNumber(x)) {
+        x = toBigNumber(x);
+      }
+      else if (isBoolean(x)) {
+        x = new BigNumber(x ? 1 : 0);
+      }
+
+      if (x instanceof BigNumber) {
+        return x.minus(y)
+      }
+
+      // downgrade to Number
+      return subtract(x, toNumber(y));
+    }
+
+    if (isUnit(x)) {
+      if (isUnit(y)) {
+        if (!x.equalBase(y)) {
+          throw new Error('Units do not match');
+        }
+
+        if (x.value == null) {
+          throw new Error('Unit on left hand side of operator - has an undefined value');
+        }
+
+        if (y.value == null) {
+          throw new Error('Unit on right hand side of operator - has an undefined value');
+        }
+
+        var res = x.clone();
+        res.value -= y.value;
+        res.fixPrefix = false;
+
+        return res;
+      }
+    }
+
+    if (isCollection(x) || isCollection(y)) {
+      return collection.deepMap2(x, y, subtract);
+    }
+
+    if (isBoolean(x)) {
+      return subtract(+x, y);
+    }
+    if (isBoolean(y)) {
+      return subtract(x, +y);
+    }
+
+    throw new math.error.UnsupportedTypeError('subtract', x, y);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/Matrix":205,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],145:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      Unit = require('../../type/Unit'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isComplex = Complex.isComplex,
+      isUnit = Unit.isUnit,
+      isCollection = collection.isCollection;
+
+  /**
+   * Inverse the sign of a value.
+   *
+   *     -x
+   *     unary(x)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param  {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix} x
+   * @return {Number | BigNumber | Complex | Unit | Array | Matrix} res
+   */
+  math.unary = function unary(x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('unary', arguments.length, 1);
+    }
+
+    if (isNumber(x)) {
+      return -x;
+    }
+
+    if (isComplex(x)) {
+      return new Complex(
+          -x.re,
+          -x.im
+      );
+    }
+
+    if (x instanceof BigNumber) {
+      return x.neg();
+    }
+
+    if (isUnit(x)) {
+      var res = x.clone();
+      res.value = -x.value;
+      return res;
+    }
+
+    if (isCollection(x)) {
+      return collection.deepMap(x, unary);
+    }
+
+    if (isBoolean(x)) {
+      return -x;
+    }
+
+    throw new math.error.UnsupportedTypeError('unary', x);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],146:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      Unit = require('../../type/Unit'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      toNumber = util.number.toNumber,
+      toBigNumber = util.number.toBigNumber,
+      isBoolean = util.boolean.isBoolean,
+      isString = util.string.isString,
+      isComplex = Complex.isComplex,
+      isUnit = Unit.isUnit,
+      isCollection = collection.isCollection;
+
+  /**
+   * Check if value x unequals y, x != y
+   * In case of complex numbers, x.re must unequal y.re, or x.im must unequal y.im
+   * @param  {Number | BigNumber | Boolean | Complex | Unit | String | Array | Matrix} x
+   * @param  {Number | BigNumber | Boolean | Complex | Unit | String | Array | Matrix} y
+   * @return {Boolean | Array | Matrix} res
+   */
+  math.unequal = function unequal(x, y) {
+    if (arguments.length != 2) {
+      throw new math.error.ArgumentsError('unequal', arguments.length, 2);
+    }
+
+    if (isNumber(x)) {
+      if (isNumber(y)) {
+        return x != y;
+      }
+      else if (isComplex(y)) {
+        return (x != y.re) || (y.im != 0);
+      }
+    }
+
+    if (isComplex(x)) {
+      if (isNumber(y)) {
+        return (x.re != y) || (x.im != 0);
+      }
+      else if (isComplex(y)) {
+        return (x.re != y.re) || (x.im != y.im);
+      }
+    }
+
+    if (x instanceof BigNumber) {
+      // try to convert to big number
+      if (isNumber(y)) {
+        y = toBigNumber(y);
+      }
+      else if (isBoolean(y)) {
+        y = new BigNumber(y ? 1 : 0);
+      }
+
+      if (y instanceof BigNumber) {
+        return !x.eq(y);
+      }
+
+      // downgrade to Number
+      return unequal(toNumber(x), y);
+    }
+    if (y instanceof BigNumber) {
+      // try to convert to big number
+      if (isNumber(x)) {
+        x = toBigNumber(x);
+      }
+      else if (isBoolean(x)) {
+        x = new BigNumber(x ? 1 : 0);
+      }
+
+      if (x instanceof BigNumber) {
+        return !x.eq(y)
+      }
+
+      // downgrade to Number
+      return unequal(x, toNumber(y));
+    }
+
+    if ((isUnit(x)) && (isUnit(y))) {
+      if (!x.equalBase(y)) {
+        throw new Error('Cannot compare units with different base');
+      }
+      return x.value != y.value;
+    }
+
+    if (isString(x) || isString(y)) {
+      return x != y;
+    }
+
+    if (isCollection(x) || isCollection(y)) {
+      return collection.deepMap2(x, y, unequal);
+    }
+
+    if (isBoolean(x)) {
+      return unequal(+x, y);
+    }
+    if (isBoolean(y)) {
+      return unequal(x, +y);
+    }
+
+    throw new math.error.UnsupportedTypeError('unequal', x, y);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],147:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+
+      toNumber = util.number.toNumber,
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isInteger = util.number.isInteger;
+
+  /**
+   * Calculate the extended greatest common divisor for two values.
+   *
+   *     xgcd(a, b)
+   *
+   * @param {Number | Boolean} a  An integer number
+   * @param {Number | Boolean} b  An integer number
+   * @return {Array}              An array containing 3 integers [div, m, n]
+   *                              where div = gcd(a, b) and a*m + b*n = div
+   *
+   * @see http://en.wikipedia.org/wiki/Extended_Euclidean_algorithm
+   */
+  math.xgcd = function xgcd(a, b) {
+    if (arguments.length == 2) {
+      // two arguments
+      if (isNumber(a) && isNumber(b)) {
+        if (!isInteger(a) || !isInteger(b)) {
+          throw new Error('Parameters in function xgcd must be integer numbers');
+        }
+
+        return _xgcd(a, b);
+      }
+
+      // TODO: implement BigNumber support for xgcd
+
+      // downgrade bignumbers to numbers
+      if (a instanceof BigNumber) {
+        return xgcd(toNumber(a), b);
+      }
+      if (b instanceof BigNumber) {
+        return xgcd(a, toNumber(b));
+      }
+
+      if (isBoolean(a)) {
+        return xgcd(+a, b);
+      }
+      if (isBoolean(b)) {
+        return xgcd(a, +b);
+      }
+
+      throw new math.error.UnsupportedTypeError('xgcd', a, b);
+    }
+
+    // zero or one argument
+    throw new SyntaxError('Function xgcd expects two arguments');
+  };
+
+  /**
+   * Calculate xgcd for two numbers
+   * @param {Number} a
+   * @param {Number} b
+   * @private
+   */
+  function _xgcd(a, b) {
+    //*
+    // source: http://en.wikipedia.org/wiki/Extended_Euclidean_algorithm
+    var t, // used to swap two variables
+        q, // quotient
+        r, // remainder
+        x = 0, lastx = 1,
+        y = 1, lasty = 0;
+
+    while (b) {
+      q = Math.floor(a / b);
+      r = a % b;
+
+      t = x;
+      x = lastx - q * x;
+      lastx = t;
+
+      t = y;
+      y = lasty - q * y;
+      lasty = t;
+
+      a = b;
+      b = r;
+    }
+
+    if (a < 0) {
+      return [-a, a ? -lastx : 0, -lasty];
+    }
+    else {
+      return [a, a ? lastx : 0, lasty];
+    }
+  }
+};
+
+},{"../../util/index":212,"bignumber.js":217}],148:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isCollection = collection.isCollection,
+      isComplex = Complex.isComplex;
+
+  /**
+   * Compute the argument of a complex value.
+   * If x = a + bi, the argument is computed as atan2(b, a).
+   *
+   *     arg(x)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param {Number | Complex | Array | Matrix | Boolean} x
+   * @return {Number | Array | Matrix} res
+   */
+  math.arg = function arg(x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('arg', arguments.length, 1);
+    }
+
+    if (isNumber(x)) {
+      return Math.atan2(0, x);
+    }
+
+    if (isComplex(x)) {
+      return Math.atan2(x.im, x.re);
+    }
+
+    if (isCollection(x)) {
+      return collection.deepMap(x, arg);
+    }
+
+    if (isBoolean(x)) {
+      return arg(+x);
+    }
+
+    if (x instanceof BigNumber) {
+      // downgrade to Number
+      // TODO: implement BigNumber support
+      return arg(util.number.toNumber(x));
+    }
+
+    throw new math.error.UnsupportedTypeError('arg', x);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],149:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      collection = require('../../type/collection'),
+
+      object = util.object,
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isCollection =collection.isCollection,
+      isComplex = Complex.isComplex;
+
+  /**
+   * Compute the complex conjugate of a complex value.
+   * If x = a+bi, the complex conjugate is a-bi.
+   *
+   *     conj(x)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param {Number | BigNumber | Complex | Array | Matrix | Boolean} x
+   * @return {Number | BigNumber | Complex | Array | Matrix} res
+   */
+  math.conj = function conj(x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('conj', arguments.length, 1);
+    }
+
+    if (isNumber(x)) {
+      return x;
+    }
+
+    if (x instanceof BigNumber) {
+      return new BigNumber(x);
+    }
+
+    if (isComplex(x)) {
+      return new Complex(x.re, -x.im);
+    }
+
+    if (isCollection(x)) {
+      return collection.deepMap(x, conj);
+    }
+
+    if (isBoolean(x)) {
+      return +x;
+    }
+
+    // return a clone of the value for non-complex values
+    return object.clone(x);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],150:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isCollection =collection.isCollection,
+      isComplex = Complex.isComplex;
+
+  /**
+   * Get the imaginary part of a complex number.
+   *
+   *     im(x)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param {Number | BigNumber | Complex | Array | Matrix | Boolean} x
+   * @return {Number | BigNumber | Array | Matrix} im
+   */
+  math.im = function im(x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('im', arguments.length, 1);
+    }
+
+    if (isNumber(x)) {
+      return 0;
+    }
+
+    if (x instanceof BigNumber) {
+      return new BigNumber(0);
+    }
+
+    if (isComplex(x)) {
+      return x.im;
+    }
+
+    if (isCollection(x)) {
+      return collection.deepMap(x, im);
+    }
+
+    if (isBoolean(x)) {
+      return 0;
+    }
+
+    // return 0 for all non-complex values
+    return 0;
+  };
+};
+
+},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],151:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      collection = require('../../type/collection'),
+
+      object = util.object,
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isCollection = collection.isCollection,
+      isComplex = Complex.isComplex;
+
+  /**
+   * Get the real part of a complex number.
+   *
+   *     re(x)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param {Number | BigNumber | Complex | Array | Matrix | Boolean} x
+   * @return {Number | BigNumber | Array | Matrix} re
+   */
+  math.re = function re(x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('re', arguments.length, 1);
+    }
+
+    if (isNumber(x)) {
+      return x;
+    }
+
+    if (x instanceof BigNumber) {
+      return new BigNumber(x);
+    }
+
+    if (isComplex(x)) {
+      return x.re;
+    }
+
+    if (isCollection(x)) {
+      return collection.deepMap(x, re);
+    }
+
+    if (isBoolean(x)) {
+      return +x;
+    }
+
+    // return a clone of the value itself for all non-complex values
+    return object.clone(x);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],152:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      collection = require('../../type/collection'),
+
+      isCollection = collection.isCollection,
+      isNumber = util.number.isNumber,
+      isString = util.string.isString,
+      isBoolean = util.boolean.isBoolean;
+
+  // extend BigNumber with a function clone
+  if (typeof BigNumber.prototype.clone !== 'function') {
+    /**
+     * Clone a bignumber
+     * @return {BigNumber} clone
+     */
+    BigNumber.prototype.clone = function clone () {
+      return new BigNumber(this);
+    };
+  }
+
+  /**
+   * Create a big number, which can store numbers with higher precision than
+   * a JavaScript Number.
+   * When value is a matrix, all elements will be converted to bignumber.
+   *
+   * @param {Number | String | Array | Matrix} [value]  Value for the big number,
+   *                                                    0 by default.
+   */
+  math.bignumber = function bignumber(value) {
+    if (arguments.length > 1) {
+      throw new math.error.ArgumentsError('bignumber', arguments.length, 0, 1);
+    }
+
+    if ((value instanceof BigNumber) || isNumber(value) || isString(value)) {
+      return new BigNumber(value);
+    }
+
+    if (isBoolean(value)) {
+      return new BigNumber(+value);
+    }
+
+    if (isCollection(value)) {
+      return collection.deepMap(value, bignumber);
+    }
+
+    if (arguments.length == 0) {
+      return new BigNumber(0);
+    }
+
+    throw new math.error.UnsupportedTypeError('bignumber', value);
+  };
+};
+
+},{"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],153:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      collection = require('../../type/collection'),
+
+      isCollection = collection.isCollection,
+      isNumber = util.number.isNumber,
+      isString = util.string.isString;
+
+  /**
+   * Create a boolean or convert a string or number to a boolean.
+   * In case of a number, true is returned for non-zero numbers, and false in
+   * case of zero.
+   * Strings can be 'true' or 'false', or can contain a number.
+   * When value is a matrix, all elements will be converted to boolean.
+   * @param {String | Number | Boolean | Array | Matrix} value
+   * @return {Boolean | Array | Matrix} bool
+   */
+  math['boolean'] = function bool (value) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('boolean', arguments.length, 0, 1);
+    }
+
+    if (value === 'true' || value === true) {
+      return true;
+    }
+
+    if (value === 'false' || value === false) {
+      return false;
+    }
+
+    if (value instanceof Boolean) {
+      return value ? true : false;
+    }
+
+    if (isNumber(value)) {
+      return (value !== 0);
+    }
+
+    if (value instanceof BigNumber) {
+      return !value.isZero();
+    }
+
+    if (isString(value)) {
+      // try case insensitive
+      var lcase = value.toLowerCase();
+      if (lcase === 'true') {
+        return true;
+      }
+      else if (lcase === 'false') {
+        return false;
+      }
+
+      // test whether value is a valid number
+      var num = Number(value);
+      if (value != '' && !isNaN(num)) {
+        return (num !== 0);
+      }
+    }
+
+    if (isCollection(value)) {
+      return collection.deepMap(value, bool);
+    }
+
+    throw new SyntaxError(value.toString() + ' is no valid boolean');
+  };
+};
+
+},{"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],154:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      collection = require('../../type/collection'),
+
+      isCollection = collection.isCollection,
+      isNumber = util.number.isNumber,
+      toNumber = util.number.toNumber,
+      isString = util.string.isString,
+      isComplex = Complex.isComplex;
+
+  /**
+   * Create a complex value or convert a value to a complex value.
+   *
+   * The method accepts the following arguments:
+   *     complex()                           creates a complex value with zero
+   *                                         as real and imaginary part.
+   *     complex(re : number, im : string)   creates a complex value with provided
+   *                                         values for real and imaginary part.
+   *     complex(re : number)                creates a complex value with provided
+   *                                         real value and zero imaginary part.
+   *     complex(complex : Complex)          clones the provided complex value.
+   *     complex(arg : string)               parses a string into a complex value.
+   *     complex(array : Array)              converts the elements of the array
+   *                                         or matrix element wise into a
+   *                                         complex value.
+   *
+   * Example usage:
+   *     var a = math.complex(3, -4);     // 3 - 4i
+   *     a.re = 5;                        // a = 5 - 4i
+   *     var i = a.im;                    // -4;
+   *     var b = math.complex('2 + 6i');  // 2 + 6i
+   *     var c = math.complex();          // 0 + 0i
+   *     var d = math.add(a, b);          // 5 + 2i
+   *
+   * @param {* | Array | Matrix} [args]
+   * @return {Complex | Array | Matrix} value
+   */
+  math.complex = function complex(args) {
+    switch (arguments.length) {
+      case 0:
+        // no parameters. Set re and im zero
+        return new Complex(0, 0);
+        break;
+
+      case 1:
+        // parse string into a complex number
+        var arg = arguments[0];
+
+        if (isNumber(arg)) {
+          return new Complex(arg, 0);
+        }
+
+        if (arg instanceof BigNumber) {
+          // convert to Number
+          return new Complex(toNumber(arg), 0);
+        }
+
+        if (isComplex(arg)) {
+          // create a clone
+          return arg.clone();
+        }
+
+        if (isString(arg)) {
+          var c = Complex.parse(arg);
+          if (c) {
+            return c;
+          }
+          else {
+            throw new SyntaxError('String "' + arg + '" is no valid complex number');
+          }
+        }
+
+        if (isCollection(arg)) {
+          return collection.deepMap(arg, complex);
+        }
+
+        throw new TypeError(
+            'Two numbers or a single string expected in function complex');
+        break;
+
+      case 2:
+        // re and im provided
+        var re = arguments[0],
+            im = arguments[1];
+
+        // convert re to number
+        if (re instanceof BigNumber) {
+          re = toNumber(re);
+        }
+
+        // convert im to number
+        if (im instanceof BigNumber) {
+          im = toNumber(im);
+        }
+
+        if (isNumber(re) && isNumber(im)) {
+          return new Complex(re, im);
+        }
+        else {
+          throw new TypeError(
+              'Two numbers or a single string expected in function complex');
+        }
+
+        break;
+
+      default:
+        throw new math.error.ArgumentsError('complex', arguments.length, 0, 2);
+    }
+  };
+};
+
+},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],155:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Index = require('../../type/Index'),
+
+      toNumber = util.number.toNumber;
+
+  /**
+   * Create an index. An Index can store ranges having start, step, and end
+   * for multiple dimensions.
+   * Matrix.get, Matrix.set, and math.subset accept an Index as input.
+   *
+   * Usage:
+   *     var index = math.index(range1, range2, ...);
+   *
+   * Where each range can be any of:
+   *     An array [start, end]
+   *     An array [start, end, step]
+   *     A number
+   *     null, this will create select the whole dimension
+   *
+   * The parameters start, end, and step must be integer numbers.
+   *
+   * @param {...*} ranges
+   */
+  math.index = function matrix(ranges) {
+    var i = new Index();
+
+    // downgrade BigNumber to Number
+    var args = Array.prototype.slice.apply(arguments).map(function (arg) {
+      if (arg instanceof BigNumber) {
+        return toNumber(arg);
+      }
+      else if (Array.isArray(arg)) {
+        return arg.map(function (elem) {
+          return (elem instanceof BigNumber) ? toNumber (elem) : elem;
+        });
+      }
+      else {
+        return arg;
+      }
+    });
+
+    Index.apply(i, args);
+    return i;
+  };
+};
+
+},{"../../type/Index":204,"../../util/index":212,"bignumber.js":217}],156:[function(require,module,exports){
+module.exports = function (math) {
+  var Matrix = require('../../type/Matrix');
+
+  /**
+   * Create a matrix. The function creates a new math.type.Matrix object.
+   *
+   * The method accepts the following arguments:
+   *     matrix()       creates an empty matrix
+   *     matrix(data)   creates a matrix with initial data.
+   *
+   * Example usage:
+   *     var m = matrix([[1, 2], [3, 4]);
+   *     m.size();                        // [2, 2]
+   *     m.resize([3, 2], 5);
+   *     m.valueOf();                     // [[1, 2], [3, 4], [5, 5]]
+   *     m.get([1, 0])                    // 3
+   *
+   * @param {Array | Matrix} [data]    A multi dimensional array
+   * @return {Matrix} matrix
+   */
+  math.matrix = function matrix(data) {
+    if (arguments.length > 1) {
+      throw new math.error.ArgumentsError('matrix', arguments.length, 0, 1);
+    }
+
+    return new Matrix(data);
+  };
+};
+
+},{"../../type/Matrix":205}],157:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      collection = require('../../type/collection'),
+
+      isCollection = collection.isCollection,
+      toNumber = util.number.toNumber;
+
+  /**
+   * Create a number or convert a string to a number.
+   * When value is a matrix, all elements will be converted to number.
+   * @param {String | Number | Boolean | Array | Matrix} [value]
+   * @return {Number | Array | Matrix} num
+   */
+  math.number = function number (value) {
+    switch (arguments.length) {
+      case 0:
+        return 0;
+
+      case 1:
+        if (isCollection(value)) {
+          return collection.deepMap(value, number);
+        }
+
+        if (value instanceof BigNumber) {
+          return toNumber(value);
+        }
+
+        var num = Number(value);
+        if (isNaN(num)) {
+          num = Number(value.valueOf());
+        }
+        if (isNaN(num)) {
+          throw new SyntaxError(value.toString() + ' is no valid number');
+        }
+        return num;
+      default:
+        throw new math.error.ArgumentsError('number', arguments.length, 0, 1);
+    }
+  };
+};
+
+},{"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],158:[function(require,module,exports){
+module.exports = function (math) {
+  var Parser = require('../../expression/Parser');
+
+  /**
+   * Create a parser. The function creates a new math.expression.Parser object.
+   *
+   *    parser()
+   *
+   * Example usage:
+   *     var parser = new math.parser();
+   *
+   *     // evaluate expressions
+   *     var a = parser.eval('sqrt(3^2 + 4^2)'); // 5
+   *     var b = parser.eval('sqrt(-4)');        // 2i
+   *     var c = parser.eval('2 inch in cm');    // 5.08 cm
+   *     var d = parser.eval('cos(45 deg)');     // 0.7071067811865476
+   *
+   *     // define variables and functions
+   *     parser.eval('x = 7 / 2');               // 3.5
+   *     parser.eval('x + 3');                   // 6.5
+   *     parser.eval('function f(x, y) = x^y');  // f(x, y)
+   *     parser.eval('f(2, 3)');                 // 8
+   *
+   *     // get and set variables and functions
+   *     var x = parser.get('x');                // 7
+   *     var f = parser.get('f');                // function
+   *     var g = f(3, 2);                        // 9
+   *     parser.set('h', 500);
+   *     var i = parser.eval('h / 2');           // 250
+   *     parser.set('hello', function (name) {
+ *         return 'hello, ' + name + '!';
+ *     });
+   *     parser.eval('hello("user")');           // "hello, user!"
+   *
+   *     // clear defined functions and variables
+   *     parser.clear();
+   *
+   * @return {Parser} Parser
+   */
+  math.parser = function parser() {
+    return new Parser(math);
+  };
+};
+
+},{"../../expression/Parser":4}],159:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      collection = require('../../type/collection'),
+
+      number = util.number,
+      isNumber = util.number.isNumber,
+      isCollection = collection.isCollection;
+
+  /**
+   * Create a string or convert any object into a string.
+   * Elements of Arrays and Matrices are processed element wise
+   * @param {* | Array | Matrix} [value]
+   * @return {String | Array | Matrix} str
+   */
+  math.string = function string (value) {
+    switch (arguments.length) {
+      case 0:
+        return '';
+
+      case 1:
+        if (isNumber(value)) {
+          return number.format(value);
+        }
+
+        if (isCollection(value)) {
+          return collection.deepMap(value, string);
+        }
+
+        if (value === null) {
+          return 'null';
+        }
+
+        return value.toString();
+
+      default:
+        throw new math.error.ArgumentsError('string', arguments.length, 0, 1);
+    }
+  };
+};
+
+},{"../../type/collection":208,"../../util/index":212}],160:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Unit = require('../../type/Unit'),
+      collection = require('../../type/collection'),
+
+      isCollection = collection.isCollection,
+      toNumber = util.number.toNumber,
+      isString = util.string.isString;
+
+  /**
+   * Create a unit. Depending on the passed arguments, the function
+   * will create and return a new math.type.Unit object.
+   * When a matrix is provided, all elements will be converted to units.
+   *
+   * The method accepts the following arguments:
+   *     unit(unit : string)
+   *     unit(value : number, unit : string)
+   *
+   * Example usage:
+   *     var a = math.unit(5, 'cm');          // 50 mm
+   *     var b = math.unit('23 kg');          // 23 kg
+   *     var c = math.in(a, math.unit('m');   // 0.05 m
+   *
+   * @param {* | Array | Matrix} args
+   * @return {Unit | Array | Matrix} value
+   */
+  math.unit = function unit(args) {
+    switch(arguments.length) {
+      case 1:
+        // parse a string
+        var arg = arguments[0];
+
+        if (arg instanceof Unit) {
+          // create a clone of the unit
+          return arg.clone();
+        }
+
+        if (isString(arg)) {
+          if (Unit.isPlainUnit(arg)) {
+            return new Unit(null, arg); // a pure unit
+          }
+
+          var u = Unit.parse(arg);        // a unit with value, like '5cm'
+          if (u) {
+            return u;
+          }
+
+          throw new SyntaxError('String "' + arg + '" is no valid unit');
+        }
+
+        if (isCollection(args)) {
+          return collection.deepMap(args, unit);
+        }
+
+        throw new TypeError('A string or a number and string expected in function unit');
+        break;
+
+      case 2:
+        // a number and a unit
+
+        if (arguments[0] instanceof BigNumber) {
+          // convert value to number
+          return new Unit(toNumber(arguments[0]), arguments[1]);
+        }
+        else {
+          return new Unit(arguments[0], arguments[1]);
+        }
+        break;
+
+      default:
+        throw new math.error.ArgumentsError('unit', arguments.length, 1, 2);
+    }
+  };
+};
+
+},{"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],161:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      Scope = require('../../expression/Scope'),
+
+      collection = require('../../type/collection'),
+
+      isString = util.string.isString,
+      isCollection = collection.isCollection;
+
+  /**
+   * Evaluate an expression.
+   *
+   * 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]
+   *
+   *     var scope = {a:3, b:4};
+   *     math.eval('a * b', scope);           // 12
+   *
+   * @param {String | String[] | Matrix} expr
+   * @param {Scope | Object} [scope]
+   * @return {*} res
+   * @throws {Error}
+   */
+  math.eval = function _eval (expr, scope) {
+    if (arguments.length != 1 && arguments.length != 2) {
+      throw new math.error.ArgumentsError('eval', arguments.length, 1, 2);
+    }
+
+    // instantiate a scope
+    var evalScope;
+    if (scope) {
+      if (scope instanceof Scope) {
+        evalScope = scope;
+      }
+      else {
+        evalScope = new Scope(math, scope);
+      }
+    }
+    else {
+      evalScope = new Scope(math);
+    }
+
+    if (isString(expr)) {
+      // evaluate a single expression
+      var node = math.parse(expr, evalScope);
+      return node.eval();
+    }
+    else if (isCollection(expr)) {
+      // evaluate an array or matrix with expressions
+      return collection.deepMap(expr, function (elem) {
+        var node = math.parse(elem, evalScope);
+        return node.eval();
+      });
+    }
+    else {
+      // oops
+      throw new TypeError('String or matrix expected');
+    }
+  };
+};
+
+},{"../../expression/Scope":5,"../../type/collection":208,"../../util/index":212}],162:[function(require,module,exports){
+module.exports = function (math) {
+  var Help = require('../../type/Help');
+
+  /**
+   * Retrieve help on a function or data type.
+   * Help files are retrieved from the documentation in math.expression.docs.
+   * @param {function | string | Object} search
+   * @return {Help} help
+   */
+  math.help = function help(search) {
+    if (arguments.length != 1) {
+      throw new SyntaxError('Wrong number of arguments in function help ' +
+          '(' + arguments.length + ' provided, 1 expected)');
+    }
+
+    var text = null;
+    if ((search instanceof String) || (typeof(search) === 'string')) {
+      text = search;
+    }
+    else {
+      var prop;
+      for (prop in math) {
+        // search in functions and constants
+        if (math.hasOwnProperty(prop)) {
+          if (search === math[prop]) {
+            text = prop;
+            break;
+          }
+        }
+      }
+
+      if (!text) {
+        // search data type
+        for (prop in math.type) {
+          if (math.type.hasOwnProperty(prop)) {
+            if (search === math.type[prop]) {
+              text = prop;
+              break;
+            }
+          }
+        }
+      }
+    }
+
+    if (!text) {
+      throw new Error('Could not find search term "' + search + '"');
+    }
+    else {
+      var doc = math.expression.docs[text];
+      if (!doc) {
+        throw new Error('No documentation found on "' + text + '"');
+      }
+      return new Help(math, doc);
+    }
+  };
+};
+
+},{"../../type/Help":203}],163:[function(require,module,exports){
+module.exports = function (math, settings) {
+  var util = require('../../util/index'),
+
+      toNumber = util.number.toNumber,
+      isString = util.string.isString,
+      isArray = Array.isArray,
+
+      // types
+      BigNumber = require('bignumber.js'),
+      Complex = require('./../../type/Complex'),
+      Matrix = require('./../../type/Matrix'),
+      Unit = require('./../../type/Unit'),
+      collection = require('../../type/collection'),
+
+      // scope and nodes
+      Scope = require('./../../expression/Scope'),
+      AssignmentNode = require('../../expression/node/AssignmentNode'),
+      BlockNode = require('../../expression/node/BlockNode'),
+      ConstantNode = require('../../expression/node/ConstantNode'),
+      FunctionNode = require('../../expression/node/FunctionNode'),
+      ArrayNode = require('../../expression/node/ArrayNode'),
+      OperatorNode = require('../../expression/node/OperatorNode'),
+      ParamsNode = require('../../expression/node/ParamsNode'),
+      RangeNode = require('../../expression/node/RangeNode'),
+      SymbolNode = require('../../expression/node/SymbolNode'),
+      UpdateNode = require('../../expression/node/UpdateNode'),
+      handlers = require('../../expression/node/handlers');
+
+  /**
+   * Parse an expression. Returns a node tree, which can be evaluated by
+   * invoking node.eval();
+   *
+   * Syntax:
+   *
+   *     math.parse(expr)
+   *     math.parse(expr, scope)
+   *     math.parse([expr1, expr2, expr3, ...])
+   *     math.parse([expr1, expr2, expr3, ...], scope)
+   *
+   * Example:
+   *
+   *     var node = math.parse('sqrt(3^2 + 4^2)');
+   *     node.eval(); // 5
+   *
+   *     var scope = {a:3, b:4}
+   *     var node = math.parse('a * b', scope); // 12
+   *     node.eval(); // 12
+   *     scope.a = 5;
+   *     node.eval(); // 20
+   *
+   *     var nodes = math.parse(['a = 3', 'b = 4', 'a * b']);
+   *     nodes[2].eval(); // 12
+   *
+   * @param {String | String[] | Matrix} expr
+   * @param {Scope | Object} [scope]
+   * @return {Node | Node[]} node
+   * @throws {Error}
+   */
+  math.parse = function parse (expr, scope) {
+    if (arguments.length != 1 && arguments.length != 2) {
+      throw new math.error.ArgumentsError('parse', arguments.length, 1, 2);
+    }
+
+    // instantiate a scope
+    var parseScope;
+    if (scope) {
+      if (scope instanceof Scope) {
+        parseScope = scope;
+      }
+      else {
+        parseScope = new Scope(math, scope);
+      }
+    }
+    else {
+      parseScope = new Scope(math);
+    }
+
+    if (isString(expr)) {
+      // parse a single expression
+      expression = expr || '';
+      return parseStart(parseScope);
+    }
+    else if (isArray(expr) || expr instanceof Matrix) {
+      // parse an array or matrix with expressions
+      return collection.deepMap(expr, function (elem) {
+        expression = elem || '';
+        return parseStart(parseScope);
+      });
+    }
+    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,
+    '\n': 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,
+      'in': true
+  };
+
+  var expression = '';  // current expression
+  var index = 0;        // current index in expr
+  var c = '';           // current token character in expr
+  var token = '';       // current token
+  var token_type = TOKENTYPE.NULL; // type of the token
+
+  /**
+   * Get the first 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 first() {
+    index = 0;
+    c = expression.charAt(0);
+  }
+
+  /**
+   * 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() {
+    index++;
+    c = expression.charAt(index);
+  }
+
+  /**
+   * Preview the next character from the expression.
+   * @return {String} cNext
+   * @private
+   */
+  function nextPreview() {
+    return expression.charAt(index + 1);
+  }
+
+  /**
+   * Get next token in the current string expr.
+   * The token and token type are available as token and token_type
+   * @private
+   */
+  function getToken() {
+    token_type = TOKENTYPE.NULL;
+    token = '';
+
+    // skip over whitespaces
+    while (c == ' ' || c == '\t') {  // space or tab
+      next();
+    }
+
+    // skip comment
+    if (c == '#') {
+      while (c != '\n' && c != '') {
+        next();
+      }
+    }
+
+    // check for end of expression
+    if (c == '') {
+      // token is still empty
+      token_type = TOKENTYPE.DELIMITER;
+      return;
+    }
+
+    // check for delimiters consisting of 2 characters
+    var c2 = c + nextPreview();
+    if (DELIMITERS[c2]) {
+      token_type = TOKENTYPE.DELIMITER;
+      token = c2;
+      next();
+      next();
+      return;
+    }
+
+    // check for delimiters consisting of 1 character
+    if (DELIMITERS[c]) {
+      token_type = TOKENTYPE.DELIMITER;
+      token = c;
+      next();
+      return;
+    }
+
+    // check for a number
+    if (isDigitDot(c)) {
+      token_type = TOKENTYPE.NUMBER;
+
+      // get number, can have a single dot
+      if (c == '.') {
+        token += c;
+        next();
+
+        if (!isDigit(c)) {
+          // this is no legal number, it is just a dot
+          token_type = TOKENTYPE.UNKNOWN;
+        }
+      }
+      else {
+        while (isDigit(c)) {
+          token += c;
+          next();
+        }
+        if (c == '.') {
+          token += c;
+          next();
+        }
+      }
+      while (isDigit(c)) {
+        token += c;
+        next();
+      }
+
+      // check for exponential notation like "2.3e-4" or "1.23e50"
+      if (c == 'E' || c == 'e') {
+        token += c;
+        next();
+
+        if (c == '+' || c == '-') {
+          token += c;
+          next();
+        }
+
+        // Scientific notation MUST be followed by an exponent
+        if (!isDigit(c)) {
+          // this is no legal number, exponent is missing.
+          token_type = TOKENTYPE.UNKNOWN;
+        }
+
+        while (isDigit(c)) {
+          token += c;
+          next();
+        }
+      }
+
+      return;
+    }
+
+    // check for variables, functions, named operators
+    if (isAlpha(c)) {
+      while (isAlpha(c) || isDigit(c)) {
+        token += c;
+        next();
+      }
+
+      if (NAMED_DELIMITERS[token]) {
+        token_type = TOKENTYPE.DELIMITER;
+      }
+      else {
+        token_type = TOKENTYPE.SYMBOL;
+      }
+
+      return;
+    }
+
+    // something unknown is found, wrong characters -> a syntax error
+    token_type = TOKENTYPE.UNKNOWN;
+    while (c != '') {
+      token += c;
+      next();
+    }
+    throw createSyntaxError('Syntax error in part "' + token + '"');
+  }
+
+  /**
+   * Check if a given name is valid
+   * if not, an error is thrown
+   * @param {String} name
+   * @return {boolean} valid
+   * @private
+   */
+    // TODO: check for valid symbol name
+  function isValidSymbolName (name) {
+    for (var i = 0, iMax = name.length; i < iMax; i++) {
+      var c = name.charAt(i);
+      //var valid = (isAlpha(c) || (i > 0 && isDigit(c))); // TODO: allow digits in symbol name
+      var valid = (isAlpha(c));
+      if (!valid) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * checks if the given char c is a letter (upper or lower case)
+   * or underscore
+   * @param {String} c   a string with one character
+   * @return {Boolean}
+   * @private
+   */
+  function isAlpha (c) {
+    return ((c >= 'a' && c <= 'z') ||
+        (c >= 'A' && c <= 'Z') ||
+        c == '_');
+  }
+
+  /**
+   * checks if the given char c is a digit or dot
+   * @param {String} c   a string with one character
+   * @return {Boolean}
+   * @private
+   */
+  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}
+   * @private
+   */
+  function isDigit (c) {
+    return ((c >= '0' && c <= '9'));
+  }
+
+  /**
+   * Start of the parse levels below, in order of precedence
+   * @param {Scope} scope
+   * @return {Node} node
+   * @private
+   */
+  function parseStart (scope) {
+    // get the first character in expression
+    first();
+
+    getToken();
+
+    var node;
+    if (token == '') {
+      // empty expression
+      node = new ConstantNode(undefined);
+    }
+    else {
+      node = parseBlock(scope);
+    }
+
+    // check for garbage at the end of the expression
+    // an expression ends with a empty character '' and token_type DELIMITER
+    if (token != '') {
+      if (token_type == 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('Unknown operator ' + token);
+      }
+      else {
+        throw createSyntaxError('Unexpected part "' + 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.
+   * @param {Scope} scope
+   * @return {Node} node
+   * @private
+   */
+  function parseBlock (scope) {
+    var node, block, visible;
+
+    if (token != '\n' && token != ';' && token != '') {
+      node = parseAns(scope);
+    }
+
+    while (token == '\n' || token == ';') {
+      if (!block) {
+        // initialize the block
+        block = new BlockNode();
+        if (node) {
+          visible = (token != ';');
+          block.add(node, visible);
+        }
+      }
+
+      getToken();
+      if (token != '\n' && token != ';' && token != '') {
+        node = parseAns(scope);
+
+        visible = (token != ';');
+        block.add(node, visible);
+      }
+    }
+
+    if (block) {
+      return block;
+    }
+
+    if (!node) {
+      node = parseAns(scope);
+    }
+
+    return node;
+  }
+
+  /**
+   * Parse assignment of ans.
+   * Ans is assigned when the expression itself is no variable or function
+   * assignment
+   * @param {Scope} scope
+   * @return {Node} node
+   * @private
+   */
+  function parseAns (scope) {
+    var expression = parseFunctionAssignment(scope);
+
+    // create a variable definition for ans
+    var name = 'ans';
+    return new AssignmentNode(name, expression, scope);
+  }
+
+  /**
+   * Parse a function assignment like "function f(a,b) = a*b"
+   * @param {Scope} scope
+   * @return {Node} node
+   * @private
+   */
+  function parseFunctionAssignment (scope) {
+    // TODO: keyword 'function' must become a reserved keyword
+    // TODO: replace the 'function' keyword with an assignment operator '=>'
+    if (token_type == TOKENTYPE.SYMBOL && token == 'function') {
+      // get function name
+      getToken();
+      if (token_type != TOKENTYPE.SYMBOL) {
+        throw createSyntaxError('Function name expected');
+      }
+      var name = token;
+
+      // get parenthesis open
+      getToken();
+      if (token != '(') {
+        throw createSyntaxError('Opening parenthesis ( expected');
+      }
+
+      // get function variables
+      var functionScope = scope.createSubScope();
+      var variables = [];
+      while (true) {
+        getToken();
+        if (token_type == TOKENTYPE.SYMBOL) {
+          // store variable name
+          variables.push(token);
+
+          getToken();
+        }
+
+        if (token == ',') {
+          // ok, nothing to do, read next variable
+        }
+        else if (token == ')') {
+          // end of variable list encountered. break loop
+          break;
+        }
+        else {
+          throw createSyntaxError('Comma , or closing parenthesis ) expected"');
+        }
+      }
+
+      getToken();
+      if (token != '=') {
+        throw createSyntaxError('Equal sign = expected');
+      }
+
+      // parse the expression, with the correct function scope
+      getToken();
+      var expression = parseAssignment(functionScope);
+
+      return new FunctionNode(name, variables, expression, functionScope, scope);
+    }
+
+    return parseAssignment(scope);
+  }
+
+  /**
+   * Assignment of a variable, can be a variable like "a=2.3" or a updating an
+   * existing variable like "matrix(2,3:5)=[6,7,8]"
+   * @param {Scope} scope
+   * @return {Node} node
+   * @private
+   */
+  function parseAssignment (scope) {
+    var name, params, paramScopes, expr;
+
+    var node = parseRange(scope);
+
+    if (token == '=') {
+      if (node instanceof SymbolNode) {
+        // parse the expression, with the correct function scope
+        getToken();
+        name = node.name;
+        params = null;
+        expr = parseAssignment(scope);
+        return new AssignmentNode(name, expr, scope);
+      }
+      else if ((node instanceof ParamsNode) && (node.object instanceof SymbolNode)) {
+        // parse the expression, with the correct function scope
+        getToken();
+        name = node.object.name;
+        params = node.params;
+        paramScopes = node.paramScopes;
+        expr = parseAssignment(scope);
+        return new UpdateNode(math, name, params, paramScopes, expr, scope);
+      }
+      else {
+        throw createSyntaxError('Symbol expected at the left hand side ' +
+            'of assignment operator =');
+      }
+    }
+
+    return node;
+  }
+
+  /**
+   * parse range, "start:end", "start:step:end", ":", "start:", ":end", etc
+   * @param {Scope} scope
+   * @return {Node} node
+   * @private
+   */
+  function parseRange (scope) {
+    var node, params = [];
+
+    if (token == ':') {
+      // implicit start=1 (one-based)
+      var one = (settings.number.defaultType === 'bignumber') ? new BigNumber(1) : 1;
+      node = new ConstantNode(one);
+    }
+    else {
+      // explicit start
+      node = parseBitwiseConditions(scope);
+    }
+
+    if (token == ':') {
+      params.push(node);
+
+      // parse step and end
+      while (token == ':') {
+        getToken();
+        if (token == ')' || token == ',' || token == '') {
+          // implicit end
+          params.push(new SymbolNode('end', scope));
+        }
+        else {
+          // explicit end
+          params.push(parseBitwiseConditions(scope));
+        }
+      }
+
+      if (params.length) {
+        node = new RangeNode(math, settings, params);
+      }
+    }
+
+    return node;
+  }
+
+  /**
+   * conditional operators and bitshift
+   * @param {Scope} scope
+   * @return {Node} node
+   * @private
+   */
+  function parseBitwiseConditions (scope) {
+    var node = parseComparison(scope);
+
+    /* TODO: implement bitwise conditions
+     var operators = {
+     '&' : bitwiseand,
+     '|' : bitwiseor,
+     // todo: bitwise xor?
+     '<<': bitshiftleft,
+     '>>': bitshiftright
+     };
+     while (operators[token] !== undefined) {
+     var name = token;
+     var fn = operators[name];
+
+     getToken();
+     var params = [node, parseComparison()];
+     node = new OperatorNode(name, fn, params);
+     }
+     */
+
+    return node;
+  }
+
+  /**
+   * comparison operators
+   * @param {Scope} scope
+   * @return {Node} node
+   * @private
+   */
+  function parseComparison (scope) {
+    var node, operators, name, fn, params;
+
+    node = parseConditions(scope);
+
+    operators = {
+      '==': math.equal,
+      '!=': math.unequal,
+      '<': math.smaller,
+      '>': math.larger,
+      '<=': math.smallereq,
+      '>=': math.largereq
+    };
+    while (operators[token] !== undefined) {
+      name = token;
+      fn = operators[name];
+
+      getToken();
+      params = [node, parseConditions(scope)];
+      node = new OperatorNode(name, fn, params);
+    }
+
+    return node;
+  }
+
+  /**
+   * conditions like and, or, in
+   * @param {Scope} scope
+   * @return {Node} node
+   * @private
+   */
+  function parseConditions (scope) {
+    var node, operators, name, fn, params;
+
+    node = parseAddSubtract(scope);
+
+    // TODO: precedence of And above Or?
+    // TODO: implement a method for unit to number conversion
+    operators = {
+      'in' : math['in']
+      /* TODO: implement conditions
+       'and' : 'and',
+       '&&' : 'and',
+       'or': 'or',
+       '||': 'or',
+       'xor': 'xor'
+       */
+    };
+
+    while (operators[token] !== undefined) {
+      name = token;
+      fn = operators[name];
+
+      getToken();
+      params = [node, parseAddSubtract(scope)];
+      node = new OperatorNode(name, fn, params);
+    }
+
+    return node;
+  }
+
+  /**
+   * add or subtract
+   * @param {Scope} scope
+   * @return {Node} node
+   * @private
+   */
+  function parseAddSubtract (scope)  {
+    var node, operators, name, fn, params;
+
+    node = parseMultiplyDivide(scope);
+
+    operators = {
+      '+': math.add,
+      '-': math.subtract
+    };
+    while (operators[token] !== undefined) {
+      name = token;
+      fn = operators[name];
+
+      getToken();
+      params = [node, parseMultiplyDivide(scope)];
+      node = new OperatorNode(name, fn, params);
+    }
+
+    return node;
+  }
+
+  /**
+   * multiply, divide, modulus
+   * @param {Scope} scope
+   * @return {Node} node
+   * @private
+   */
+  function parseMultiplyDivide (scope) {
+    var node, operators, name, fn, params;
+
+    node = parseUnary(scope);
+
+    operators = {
+      '*': math.multiply,
+      '.*': math.emultiply,
+      '/': math.divide,
+      './': math.edivide,
+      '%': math.mod,
+      'mod': math.mod
+    };
+
+    while (operators[token] !== undefined) {
+      name = token;
+      fn = operators[name];
+
+      getToken();
+      params = [node, parseUnary(scope)];
+      node = new OperatorNode(name, fn, params);
+    }
+
+    return node;
+  }
+
+  /**
+   * Unary minus
+   * @param {Scope} scope
+   * @return {Node} node
+   * @private
+   */
+  function parseUnary (scope) {
+    var name, fn, params;
+
+    if (token == '-') {
+      name = token;
+      fn = math.unary;
+      getToken();
+      params = [parseUnary(scope)];
+
+      return new OperatorNode(name, fn, params);
+    }
+
+    return parsePow(scope);
+  }
+
+  /**
+   * power
+   * Note: power operator is right associative
+   * @param {Scope} scope
+   * @return {Node} node
+   * @private
+   */
+  function parsePow (scope) {
+    var node, leftNode, nodes, ops, name, fn, params;
+
+    nodes = [
+      parseFactorial(scope)
+    ];
+    ops = [];
+
+    // stack all operands of a chained power operator (like '2^3^3')
+    while (token == '^' || token == '.^') {
+      ops.push(token);
+      getToken();
+      nodes.push(parseFactorial(scope));
+    }
+
+    // evaluate the operands from right to left (right associative)
+    node = nodes.pop();
+    while (nodes.length) {
+      leftNode = nodes.pop();
+      name = ops.pop();
+      fn = (name == '^') ? math.pow : math.epow;
+      params = [leftNode, node];
+      node = new OperatorNode(name, fn, params);
+    }
+
+    return node;
+  }
+
+  /**
+   * Factorial
+   * @param {Scope} scope
+   * @return {Node} node
+   * @private
+   */
+  function parseFactorial (scope)  {
+    var node, name, fn, params;
+
+    node = parseTranspose(scope);
+
+    while (token == '!') {
+      name = token;
+      fn = math.factorial;
+      getToken();
+      params = [node];
+
+      node = new OperatorNode(name, fn, params);
+    }
+
+    return node;
+  }
+
+  /**
+   * Transpose
+   * @param {Scope} scope
+   * @return {Node} node
+   * @private
+   */
+  function parseTranspose (scope)  {
+    var node, name, fn, params;
+
+    node = parseNodeHandler(scope);
+
+    while (token == '\'') {
+      name = token;
+      fn = math.transpose;
+      getToken();
+      params = [node];
+
+      node = new OperatorNode(name, fn, params);
+    }
+
+    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 defined in the namespace math.expression.node.handlers,
+   * and must extend math.expression.node.Node, and the handler must contain
+   * functions eval(), find(filter), and toString().
+   *
+   * For example:
+   *
+   *     math.expression.node.handlers['plot'] = PlotHandler;
+   *
+   * The constructor of the handler is called as:
+   *
+   *     node = new PlotHandler(params, paramScopes);
+   *
+   * The handler will be invoked when evaluating an expression like:
+   *
+   *     node = math.parse('plot(sin(x), x)');
+   *
+   * @param {Scope} scope
+   * @return {Node} node
+   * @private
+   */
+  function parseNodeHandler (scope) {
+    var params,
+        paramScopes,
+        paramScope,
+        handler;
+
+    if (token_type == TOKENTYPE.SYMBOL && handlers[token]) {
+      handler = handlers[token];
+
+      getToken();
+
+      // parse parameters
+      if (token == '(') {
+        params = [];
+        paramScopes = [];
+
+        getToken();
+
+        if (token != ')') {
+          paramScope = scope.createSubScope();
+          paramScopes.push(paramScope);
+          params.push(parseRange(paramScope));
+
+          // parse a list with parameters
+          while (token == ',') {
+            getToken();
+
+            paramScope = scope.createSubScope();
+            paramScopes.push(paramScope);
+            params.push(parseRange(paramScope));
+          }
+        }
+
+        if (token != ')') {
+          throw createSyntaxError('Parenthesis ) expected');
+        }
+        getToken();
+      }
+
+      // create a new node handler
+      //noinspection JSValidateTypes
+      return new handler(params, paramScopes);
+    }
+
+    return parseSymbol(scope);
+  }
+
+  /**
+   * parse symbols: functions, variables, constants, units
+   * @param {Scope} scope
+   * @return {Node} node
+   * @private
+   */
+  function parseSymbol (scope) {
+    var node, name;
+
+    if (token_type == TOKENTYPE.SYMBOL) {
+      name = token;
+
+      getToken();
+
+      // create a symbol
+      node = new SymbolNode(name, scope);
+
+      // parse parameters
+      return parseParams(scope, node);
+    }
+
+    return parseString(scope);
+  }
+
+  /**
+   * parse parameters, enclosed in parenthesis
+   * @param {Scope} scope
+   * @param {Node} node    Node on which to apply the parameters. If there
+   *                       are no parameters in the expression, the node
+   *                       itself is returned
+   * @return {Node} node
+   * @private
+   */
+  function parseParams (scope, node) {
+    var bracket,
+        params,
+        paramScopes,
+        paramScope;
+
+    while (token == '(') {
+      bracket = token;
+      params = [];
+      paramScopes = [];
+
+      getToken();
+
+      if (token != ')') {
+        paramScope = scope.createSubScope();
+        paramScopes.push(paramScope);
+        params.push(parseRange(paramScope));
+
+        // parse a list with parameters
+        while (token == ',') {
+          getToken();
+
+          paramScope = scope.createSubScope();
+          paramScopes.push(paramScope);
+          params.push(parseRange(paramScope));
+        }
+      }
+
+      if ((bracket == '(' && token != ')')) {
+        throw createSyntaxError('Parenthesis ) expected');
+      }
+      getToken();
+
+      node = new ParamsNode(math, node, params, paramScopes);
+    }
+
+    return node;
+  }
+
+  /**
+   * parse a string.
+   * A string is enclosed by double quotes
+   * @param {Scope} scope
+   * @return {Node} node
+   * @private
+   */
+  function parseString (scope) {
+    var node, str, tPrev;
+
+    if (token == '"') {
+      // string "..."
+      str = '';
+      tPrev = '';
+      while (c != '' && (c != '\"' || tPrev == '\\')) { // also handle escape character
+        str += c;
+        tPrev = c;
+        next();
+      }
+
+      getToken();
+      if (token != '"') {
+        throw createSyntaxError('End of string " expected');
+      }
+      getToken();
+
+      // create constant
+      node = new ConstantNode(str);
+
+      // parse parameters
+      node = parseParams(scope, node);
+
+      return node;
+    }
+
+    return parseMatrix(scope);
+  }
+
+  /**
+   * parse the matrix
+   * @param {Scope} scope
+   * @return {Node} node
+   * @private
+   */
+  function parseMatrix (scope) {
+    var array, params, rows, cols;
+
+    if (token == '[') {
+      // matrix [...]
+
+      // skip newlines
+      getToken();
+      while (token == '\n') {
+        getToken();
+      }
+
+      if (token != ']') {
+        // this is a non-empty matrix
+        var row = parseRow(scope);
+
+        if (token == ';') {
+          // 2 dimensional array
+          rows = 1;
+          params = [row];
+
+          // the rows of the matrix are separated by dot-comma's
+          while (token == ';') {
+            getToken();
+
+            // skip newlines
+            while (token == '\n') {
+              getToken();
+            }
+
+            params[rows] = parseRow(scope);
+            rows++;
+
+            // skip newlines
+            while (token == '\n') {
+              getToken();
+            }
+          }
+
+          if (token != ']') {
+            throw createSyntaxError('End of matrix ] expected');
+          }
+          getToken();
+
+          // check if the number of columns matches in all rows
+          cols = (params.length > 0) ? params[0].length : 0;
+          for (var r = 1; r < rows; r++) {
+            if (params[r].length != cols) {
+              throw createError('Number of columns must match ' +
+                  '(' + params[r].length + ' != ' + cols + ')');
+            }
+          }
+
+          array = new ArrayNode(settings, params);
+        }
+        else {
+          // 1 dimensional vector
+          if (token != ']') {
+            throw createSyntaxError('End of matrix ] expected');
+          }
+          getToken();
+
+          array = row;
+        }
+      }
+      else {
+        // this is an empty matrix "[ ]"
+        getToken();
+        array = new ArrayNode(settings, []);
+      }
+
+      // parse parameters
+      array = parseParams(scope, array);
+
+      return array;
+    }
+
+    return parseNumber(scope);
+  }
+
+  /**
+   * Parse a single comma-separated row from a matrix, like 'a, b, c'
+   * @param {Scope} scope
+   * @return {ArrayNode} node
+   */
+  function parseRow (scope) {
+    var params = [parseAssignment(scope)];
+    var len = 1;
+
+    while (token == ',') {
+      getToken();
+
+      // skip newlines
+      while (token == '\n') {
+        getToken();
+      }
+
+      // parse expression
+      params[len] = parseAssignment(scope);
+      len++;
+
+      // skip newlines
+      while (token == '\n') {
+        getToken();
+      }
+    }
+
+    return new ArrayNode(settings, params);
+  }
+
+  /**
+   * parse a number
+   * @param {Scope} scope
+   * @return {Node} node
+   * @private
+   */
+  function parseNumber (scope) {
+    var node, value, number;
+
+    if (token_type == TOKENTYPE.NUMBER) {
+      // this is a number
+      if (settings.number.defaultType == 'bignumber') {
+        // parse a big number
+        number = new BigNumber((token == '.') ? 0 : token);
+      }
+      else {
+        // parse a regular number
+        number = (token == '.') ? 0 : Number(token);
+      }
+      getToken();
+
+      /* TODO: implicit multiplication?
+       // TODO: how to calculate a=3; 2/2a ? is this (2/2)*a or 2/(2*a) ?
+       // check for implicit multiplication
+       if (token_type == TOKENTYPE.VARIABLE) {
+       node = multiply(node, parsePow());
+       }
+       //*/
+
+      if (token_type == TOKENTYPE.SYMBOL) {
+        // convert bignumber to number as both Complex and Unit don't support BigNumber
+        number = (number instanceof BigNumber) ? toNumber(number) : number;
+
+        // create a complex number
+        if (token == 'i' || token == 'I') {
+          value = new Complex(0, number);
+          getToken();
+          return new ConstantNode(value);
+        }
+
+        // create a unit
+        if (Unit.isPlainUnit(token)) {
+          value = new Unit(number, token);
+          getToken();
+          return new ConstantNode(value);
+        }
+
+        throw createTypeError('Unknown unit "' + token + '"');
+      }
+
+      // just a regular number
+      node = new ConstantNode(number);
+
+      // parse parameters
+      node = parseParams(scope, node);
+
+      return node;
+    }
+
+    return parseParentheses(scope);
+  }
+
+  /**
+   * parentheses
+   * @param {Scope} scope
+   * @return {Node} node
+   * @private
+   */
+  function parseParentheses (scope) {
+    var node;
+
+    // check if it is a parenthesized expression
+    if (token == '(') {
+      // parentheses (...)
+      getToken();
+      node = parseAssignment(scope); // start again
+
+      if (token != ')') {
+        throw createSyntaxError('Parenthesis ) expected');
+      }
+      getToken();
+
+      /* TODO: implicit multiplication?
+       // TODO: how to calculate a=3; 2/2a ? is this (2/2)*a or 2/(2*a) ?
+       // check for implicit multiplication
+       if (token_type == TOKENTYPE.VARIABLE) {
+       node = multiply(node, parsePow());
+       }
+       //*/
+
+      // parse parameters
+      node = parseParams(scope, node);
+
+      return node;
+    }
+
+    return parseEnd(scope);
+  }
+
+  /**
+   * Evaluated when the expression is not yet ended but expected to end
+   * @param {Scope} scope
+   * @return {Node} res
+   * @private
+   */
+  function parseEnd (scope) {
+    if (token == '') {
+      // syntax error or unexpected end of expression
+      throw createSyntaxError('Unexpected end of expression');
+    } else {
+      throw createSyntaxError('Value expected');
+    }
+  }
+
+  /**
+   * Shortcut for getting the current row value (one based)
+   * Returns the line of the currently handled expression
+   * @private
+   */
+  function row () {
+    // TODO: also register row number during parsing
+    return undefined;
+  }
+
+  /**
+   * Shortcut for getting the current col value (one based)
+   * Returns the column (position) where the last token starts
+   * @private
+   */
+  function col () {
+    return index - token.length + 1;
+  }
+
+  /**
+   * Build up an error message
+   * @param {String} message
+   * @return {String} message with row and column information
+   * @private
+   */
+  function createErrorMessage (message) {
+    var r = row();
+    var c = col();
+    if (r === undefined) {
+      if (c === undefined) {
+        return message;
+      } else {
+        return message + ' (char ' + c + ')';
+      }
+    } else {
+      return message + ' (line ' + r + ', char ' + c + ')';
+    }
+  }
+
+  /**
+   * Create an error
+   * @param {String} message
+   * @return {SyntaxError} instantiated error
+   * @private
+   */
+  function createSyntaxError (message) {
+    return new SyntaxError(createErrorMessage(message));
+  }
+
+  /**
+   * Create an error
+   * @param {String} message
+   * @return {TypeError} instantiated error
+   * @private
+   */
+  function createTypeError(message) {
+    return new TypeError(createErrorMessage(message));
+  }
+
+  /**
+   * Create an error
+   * @param {String} message
+   * @return {Error} instantiated error
+   * @private
+   */
+  function createError (message) {
+    return new Error(createErrorMessage(message));
+  }
+};
+
+},{"../../expression/node/ArrayNode":104,"../../expression/node/AssignmentNode":105,"../../expression/node/BlockNode":106,"../../expression/node/ConstantNode":107,"../../expression/node/FunctionNode":108,"../../expression/node/OperatorNode":110,"../../expression/node/ParamsNode":111,"../../expression/node/RangeNode":112,"../../expression/node/SymbolNode":113,"../../expression/node/UpdateNode":114,"../../expression/node/handlers":115,"../../type/collection":208,"../../util/index":212,"./../../expression/Scope":5,"./../../type/Complex":202,"./../../type/Matrix":205,"./../../type/Unit":207,"bignumber.js":217}],164:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      Matrix = require('../../type/Matrix'),
+      collection = require('../../type/collection'),
+
+      object = util.object,
+      array = util.array,
+      isNumber = util.number.isNumber,
+      isInteger = util.number.isInteger,
+      isCollection = collection.isCollection;
+
+  /**
+   * Concatenate two or more matrices
+   * Usage:
+   *     math.concat(A, B, C, ...)
+   *     math.concat(A, B, C, ..., dim)
+   *
+   * Where the optional dim is the zero-based number of the dimension to be
+   * concatenated.
+   *
+   * @param {... Array | Matrix} args
+   * @return {Array | Matrix} res
+   */
+  math.concat = function concat (args) {
+    var i,
+        len = arguments.length,
+        dim = -1,  // zero-based dimension
+        prevDim,
+        asMatrix = false,
+        matrices = [];  // contains multi dimensional arrays
+
+    for (i = 0; i < len; i++) {
+      var arg = arguments[i];
+
+      // test whether we need to return a Matrix (if not we return an Array)
+      if (arg instanceof Matrix) {
+        asMatrix = true;
+      }
+
+      if ((i == len - 1) && isNumber(arg)) {
+        // last argument contains the dimension on which to concatenate
+        prevDim = dim;
+        dim = arg;
+
+        if (!isInteger(dim) || dim < 0) {
+          throw new TypeError('Dimension number must be a positive integer ' +
+              '(dim = ' + dim + ')');
+        }
+
+        if (i > 0 && dim > prevDim) {
+          throw new RangeError('Dimension out of range ' +
+              '(' + dim + ' > ' + prevDim + ')');
+        }
+      }
+      else if (isCollection(arg)) {
+        // this is a matrix or array
+        var matrix = object.clone(arg).valueOf();
+        var size = array.size(arg.valueOf());
+        matrices[i] = matrix;
+        prevDim = dim;
+        dim = size.length - 1;
+
+        // verify whether each of the matrices has the same number of dimensions
+        if (i > 0 && dim != prevDim) {
+          throw new RangeError('Dimension mismatch ' +
+              '(' + prevDim + ' != ' + dim + ')');
+        }
+      }
+      else {
+        throw new math.error.UnsupportedTypeError('concat', arg);
+      }
+    }
+
+    if (matrices.length == 0) {
+      throw new SyntaxError('At least one matrix expected');
+    }
+
+    var res = matrices.shift();
+    while (matrices.length) {
+      res = _concat(res, matrices.shift(), dim, 0);
+    }
+
+    return asMatrix ? new Matrix(res) : res;
+  };
+
+  /**
+   * Recursively concatenate two matrices.
+   * The contents of the matrices is not cloned.
+   * @param {Array} a             Multi dimensional array
+   * @param {Array} b             Multi dimensional array
+   * @param {Number} concatDim    The dimension on which to concatenate (zero-based)
+   * @param {Number} dim          The current dim (zero-based)
+   * @return {Array} c            The concatenated matrix
+   * @private
+   */
+  function _concat(a, b, concatDim, dim) {
+    if (dim < concatDim) {
+      // recurse into next dimension
+      if (a.length != b.length) {
+        throw new Error('Dimensions mismatch (' + a.length + ' != ' + b.length + ')');
+      }
+
+      var c = [];
+      for (var i = 0; i < a.length; i++) {
+        c[i] = _concat(a[i], b[i], concatDim, dim + 1);
+      }
+      return c;
+    }
+    else {
+      // concatenate this dimension
+      return a.concat(b);
+    }
+  }
+};
+
+},{"../../type/Matrix":205,"../../type/collection":208,"../../util/index":212}],165:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      Matrix = require('../../type/Matrix'),
+
+      object = util.object,
+      array = util.array,
+      string = util.string;
+
+  /**
+   * @constructor det
+   * Calculate the determinant of a matrix
+   *
+   *     det(x)
+   *
+   * @param {Array | Matrix} x
+   * @return {Number} determinant
+   */
+  math.det = function det (x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('det', arguments.length, 1);
+    }
+
+    var size = array.size(x.valueOf());
+    switch (size.length) {
+      case 0:
+        // scalar
+        return object.clone(x);
+        break;
+
+      case 1:
+        // vector
+        if (size[0] == 1) {
+          return object.clone(x.valueOf()[0]);
+        }
+        else {
+          throw new RangeError('Matrix must be square ' +
+              '(size: ' + string.format(size) + ')');
+        }
+        break;
+
+      case 2:
+        // two dimensional array
+        var rows = size[0];
+        var cols = size[1];
+        if (rows == cols) {
+          return _det(x.valueOf(), rows, cols);
+        }
+        else {
+          throw new RangeError('Matrix must be square ' +
+              '(size: ' + string.format(size) + ')');
+        }
+        break;
+
+      default:
+        // multi dimensional array
+        throw new RangeError('Matrix must be two dimensional ' +
+            '(size: ' + string.format(size) + ')');
+    }
+  };
+
+  /**
+   * Calculate the determinant of a matrix
+   * @param {Array[]} matrix  A square, two dimensional matrix
+   * @param {Number} rows     Number of rows of the matrix (zero-based)
+   * @param {Number} cols     Number of columns of the matrix (zero-based)
+   * @returns {Number} det
+   * @private
+   */
+  function _det (matrix, rows, cols) {
+    if (rows == 1) {
+      // this is a 1 x 1 matrix
+      return matrix[0][0];
+    }
+    else if (rows == 2) {
+      // this is a 2 x 2 matrix
+      // the determinant of [a11,a12;a21,a22] is det = a11*a22-a21*a12
+      return math.subtract(
+          math.multiply(matrix[0][0], matrix[1][1]),
+          math.multiply(matrix[1][0], matrix[0][1])
+      );
+    }
+    else {
+      // this is an n x n matrix
+      var d = 1;
+      var lead = 0;
+      for (var r = 0; r < rows; r++) {
+        if (lead >= cols) {
+          break;
+        }
+        var i = r;
+        // Find the pivot element.
+        while (matrix[i][lead] == 0) {
+          i++;
+          if (i == rows) {
+            i = r;
+            lead++;
+            if (lead == cols) {
+              // We found the last pivot.
+              if (object.deepEqual(matrix, eye(rows).valueOf())) {
+                return math.round(d, 6);
+              } else {
+                return 0;
+              }
+            }
+          }
+        }
+        if (i != r) {
+          // Swap rows i and r, which negates the determinant.
+          for (var a = 0; a < cols; a++) {
+            var temp = matrix[i][a];
+            matrix[i][a] = matrix[r][a];
+            matrix[r][a] = temp;
+          }
+          d *= -1;
+        }
+        // Scale row r and the determinant simultaneously.
+        var div = matrix[r][lead];
+        for (var a = 0; a < cols; a++) {
+          matrix[r][a] = matrix[r][a] / div;
+        }
+        d *= div;
+        // Back-substitute upwards.
+        for (var j = 0; j < rows; j++) {
+          if (j != r) {
+            // Taking linear combinations does not change the det.
+            var c = matrix[j][lead];
+            for (var a = 0; a < cols; a++) {
+              matrix[j][a] = matrix[j][a] - matrix[r][a] * c;
+            }
+          }
+        }
+        lead++; // Now looking for a pivot further right.
+      }
+      // If reduction did not result in the identity, the matrix is singular.
+      if (object.deepEqual(matrix, math.eye(rows).valueOf())) {
+        return math.round(d, 6);
+      } else {
+        return 0;
+      }
+    }
+  }
+};
+
+},{"../../type/Matrix":205,"../../util/index":212}],166:[function(require,module,exports){
+module.exports = function (math, settings) {
+  var util = require('../../util/index'),
+
+      Matrix = require('../../type/Matrix'),
+      collection = require('../../type/collection'),
+
+      object = util.object,
+      isArray = util.array.isArray,
+      isNumber = util.number.isNumber,
+      isInteger = util.number.isInteger;
+
+  /**
+   * Create a diagonal matrix or retrieve the diagonal of a matrix
+   *
+   *     diag(v)
+   *     diag(v, k)
+   *     diag(X)
+   *     diag(X, k)
+   *
+   * TODO: more documentation on diag
+   *
+   * @param {Matrix | Array} x
+   * @param {Number} [k]
+   * @return {Matrix | Array} matrix
+   */
+  math.diag = function diag (x, k) {
+    var data, vector, i, iMax;
+
+    if (arguments.length != 1 && arguments.length != 2) {
+      throw new math.error.ArgumentsError('diag', arguments.length, 1, 2);
+    }
+
+    if (k) {
+      if (!isNumber(k) || !isInteger(k)) {
+        throw new TypeError ('Second parameter in function diag must be an integer');
+      }
+    }
+    else {
+      k = 0;
+    }
+    var kSuper = k > 0 ? k : 0;
+    var kSub = k < 0 ? -k : 0;
+
+    // check type of input
+    if (x instanceof Matrix) {
+      // nice, nothing to do
+    }
+    else if (isArray(x)) {
+      // convert to matrix
+      x = new Matrix(x);
+    }
+    else {
+      throw new TypeError ('First parameter in function diag must be a Matrix or Array');
+    }
+
+    var s = x.size();
+    switch (s.length) {
+      case 1:
+        // x is a vector. create diagonal matrix
+        vector = x.valueOf();
+        var matrix = new Matrix();
+        var defaultValue = 0;
+        matrix.resize([vector.length + kSub, vector.length + kSuper], defaultValue);
+        data = matrix.valueOf();
+        iMax = vector.length;
+        for (i = 0; i < iMax; i++) {
+          data[i + kSub][i + kSuper] = object.clone(vector[i]);
+        }
+        return (settings.matrix.defaultType === 'array') ? matrix.valueOf() : matrix;
+        break;
+
+      case 2:
+        // x is a matrix get diagonal from matrix
+        vector = [];
+        data = x.valueOf();
+        iMax = Math.min(s[0] - kSub, s[1] - kSuper);
+        for (i = 0; i < iMax; i++) {
+          vector[i] = object.clone(data[i + kSub][i + kSuper]);
+        }
+        return (settings.matrix.defaultType === 'array') ? vector : new Matrix(vector);
+        break;
+
+      default:
+        throw new RangeError('Matrix for function diag must be 2 dimensional');
+    }
+  };
+};
+
+},{"../../type/Matrix":205,"../../type/collection":208,"../../util/index":212}],167:[function(require,module,exports){
+module.exports = function (math, settings) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Matrix = require('../../type/Matrix'),
+      collection = require('../../type/collection'),
+
+      toNumber = util.number.toNumber,
+      isNumber = util.number.isNumber,
+      isInteger = util.number.isInteger,
+      isArray = Array.isArray;
+
+  /**
+   * Create a 2-dimensional identity matrix with size m x n or n x n
+   *
+   *     eye(n)
+   *     eye(m, n)
+   *     eye([m, n])
+   *
+   * TODO: more documentation on eye
+   *
+   * @param {...Number | Matrix | Array} size
+   * @return {Matrix | Array | Number} matrix
+   */
+  math.eye = function eye (size) {
+    var args = collection.argsToArray(arguments),
+        asMatrix = (size instanceof Matrix) ? true :
+        (isArray(size) ? false : (settings.matrix.defaultType === 'matrix'));
+
+
+    if (args.length == 0) {
+      // return an empty array
+      return asMatrix ? new Matrix() : [];
+    }
+    else if (args.length == 1) {
+      // change to a 2-dimensional square
+      args[1] = args[0];
+    }
+    else if (args.length > 2) {
+      // error in case of an n-dimensional size
+      throw new math.error.ArgumentsError('eye', args.length, 0, 2);
+    }
+
+    var asBigNumber = args[0] instanceof BigNumber,
+        rows = args[0],
+        cols = args[1];
+
+    if (rows instanceof BigNumber) {
+      rows = toNumber(rows);
+    }
+    if (cols instanceof BigNumber) {
+      cols = toNumber(cols);
+    }
+
+    if (!isNumber(rows) || !isInteger(rows) || rows < 1) {
+      throw new Error('Parameters in function eye must be positive integers');
+    }
+    if (cols) {
+      if (!isNumber(cols) || !isInteger(cols) || cols < 1) {
+        throw new Error('Parameters in function eye must be positive integers');
+      }
+    }
+
+    // create and args the matrix
+    var matrix = new Matrix();
+    var one = asBigNumber ? new BigNumber(1) : 1;
+    var defaultValue = asBigNumber ? new BigNumber(0) : 0;
+    matrix.resize(args.map(toNumber), defaultValue);
+
+    // fill in ones on the diagonal
+    var minimum = math.min(args);
+    var data = matrix.valueOf();
+    for (var d = 0; d < minimum; d++) {
+      data[d][d] = one;
+    }
+
+    return asMatrix ? matrix : matrix.valueOf();
+  };
+};
+
+},{"../../type/Matrix":205,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],168:[function(require,module,exports){
+module.exports = function (math) {
+  var string = require('../../util/string'),
+
+      Matrix = require('../../type/Matrix'),
+      collection = require('../../type/collection');
+
+  /**
+   * Calculate the inverse of a matrix
+   *
+   *     inv(x)
+   *
+   * TODO: more documentation on inv
+   *
+   * @param {Number | Complex | Array | Matrix} x
+   * @return {Number | Complex | Array | Matrix} inv
+   */
+  math.inv = function inv (x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('inv', arguments.length, 1);
+    }
+    var size = math.size(x).valueOf();
+    switch (size.length) {
+      case 0:
+        // scalar
+        return math.divide(1, x);
+        break;
+
+      case 1:
+        // vector
+        if (size[0] == 1) {
+          if (x instanceof Matrix) {
+            return new Matrix([
+              math.divide(1, x.valueOf()[0])
+            ]);
+          }
+          else {
+            return [
+              math.divide(1, x[0])
+            ];
+          }
+        }
+        else {
+          throw new RangeError('Matrix must be square ' +
+              '(size: ' + string.format(size) + ')');
+        }
+        break;
+
+      case 2:
+        // two dimensional array
+        var rows = size[0];
+        var cols = size[1];
+        if (rows == cols) {
+          if (x instanceof Matrix) {
+            return new Matrix(
+                _inv(x.valueOf(), rows, cols)
+            );
+          }
+          else {
+            // return an Array
+            return _inv(x, rows, cols);
+          }
+        }
+        else {
+          throw new RangeError('Matrix must be square ' +
+              '(size: ' + string.format(size) + ')');
+        }
+        break;
+
+      default:
+        // multi dimensional array
+        throw new RangeError('Matrix must be two dimensional ' +
+            '(size: ' + string.format(size) + ')');
+    }
+  };
+
+  /**
+   * Calculate the inverse of a square matrix
+   * @param {Array[]} matrix  A square matrix
+   * @param {Number} rows     Number of rows
+   * @param {Number} cols     Number of columns, must equal rows
+   * @return {Array[]} inv    Inverse matrix
+   * @private
+   */
+  function _inv (matrix, rows, cols){
+    var r, s, f, value, temp;
+
+    if (rows == 1) {
+      // this is a 1 x 1 matrix
+      value = matrix[0][0];
+      if (value == 0) {
+        throw Error('Cannot calculate inverse, determinant is zero');
+      }
+      return [[
+        math.divide(1, value)
+      ]];
+    }
+    else if (rows == 2) {
+      // this is a 2 x 2 matrix
+      var d = math.det(matrix);
+      if (d == 0) {
+        throw Error('Cannot calculate inverse, determinant is zero');
+      }
+      return [
+        [
+          math.divide(matrix[1][1], d),
+          math.divide(math.unary(matrix[0][1]), d)
+        ],
+        [
+          math.divide(math.unary(matrix[1][0]), d),
+          math.divide(matrix[0][0], d)
+        ]
+      ];
+    }
+    else {
+      // this is a matrix of 3 x 3 or larger
+      // calculate inverse using gauss-jordan elimination
+      //      http://en.wikipedia.org/wiki/Gaussian_elimination
+      //      http://mathworld.wolfram.com/MatrixInverse.html
+      //      http://math.uww.edu/~mcfarlat/inverse.htm
+
+      // make a copy of the matrix (only the arrays, not of the elements)
+      var A = matrix.concat();
+      for (r = 0; r < rows; r++) {
+        A[r] = A[r].concat();
+      }
+
+      // create an identity matrix which in the end will contain the
+      // matrix inverse
+      var B = math.eye(rows).valueOf();
+
+      // loop over all columns, and perform row reductions
+      for (var c = 0; c < cols; c++) {
+        // element Acc should be non zero. if not, swap content
+        // with one of the lower rows
+        r = c;
+        while (r < rows && A[r][c] == 0) {
+          r++;
+        }
+        if (r == rows || A[r][c] == 0) {
+          throw Error('Cannot calculate inverse, determinant is zero');
+        }
+        if (r != c) {
+          temp = A[c]; A[c] = A[r]; A[r] = temp;
+          temp = B[c]; B[c] = B[r]; B[r] = temp;
+        }
+
+        // eliminate non-zero values on the other rows at column c
+        var Ac = A[c],
+            Bc = B[c];
+        for (r = 0; r < rows; r++) {
+          var Ar = A[r],
+              Br = B[r];
+          if(r != c) {
+            // eliminate value at column c and row r
+            if (Ar[c] != 0) {
+              f = math.divide(math.unary(Ar[c]), Ac[c]);
+
+              // add (f * row c) to row r to eliminate the value
+              // at column c
+              for (s = c; s < cols; s++) {
+                Ar[s] = math.add(Ar[s], math.multiply(f, Ac[s]));
+              }
+              for (s = 0; s < cols; s++) {
+                Br[s] = math.add(Br[s],  math.multiply(f, Bc[s]));
+              }
+            }
+          }
+          else {
+            // normalize value at Acc to 1,
+            // divide each value on row r with the value at Acc
+            f = Ac[c];
+            for (s = c; s < cols; s++) {
+              Ar[s] = math.divide(Ar[s], f);
+            }
+            for (s = 0; s < cols; s++) {
+              Br[s] = math.divide(Br[s], f);
+            }
+          }
+        }
+      }
+      return B;
+    }
+  }
+};
+
+},{"../../type/Matrix":205,"../../type/collection":208,"../../util/string":215}],169:[function(require,module,exports){
+module.exports = function (math, settings) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Matrix = require('../../type/Matrix'),
+      collection = require('../../type/collection'),
+
+      array = util.array,
+
+      toNumber = util.number.toNumber,
+      isArray = Array.isArray;
+
+  /**
+   * Create a matrix filled with ones
+   *
+   *     ones(m)
+   *     ones(m, n)
+   *     ones([m, n])
+   *     ones([m, n, p, ...])
+   *
+   * @param {...Number | Array} size
+   * @return {Array | Matrix | Number} matrix
+   */
+  math.ones = function ones (size) {
+    var args = collection.argsToArray(arguments);
+    var asMatrix = (size instanceof Matrix) ? true :
+        (isArray(size) ? false : (settings.matrix.defaultType === 'matrix'));
+
+    if (args.length == 0) {
+      // output an empty matrix
+      return asMatrix ? new Matrix() : [];
+    }
+    else {
+      // output an array or matrix
+      var res = [];
+      var defaultValue = (args[0] instanceof BigNumber) ? new BigNumber(1) : 1;
+      res = array.resize(res, args.map(toNumber), defaultValue);
+
+      return asMatrix ? new Matrix(res) : res;
+    }
+  };
+};
+
+},{"../../type/Matrix":205,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],170:[function(require,module,exports){
+module.exports = function (math, settings) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Matrix = require('../../type/Matrix'),
+      collection = require('../../type/collection'),
+
+      isString = util.string.isString,
+      isNumber = util.number.isNumber,
+      toNumber = util.number.toNumber,
+      toBigNumber = util.number.toBigNumber;
+
+  /**
+   * Create an array from a range.
+   *
+   * The method accepts the following arguments
+   *     range(str)                   Create a range from a string, where the
+   *                                  string contains the start, optional step,
+   *                                  and end, separated by a colon.
+   *     range(start, end)            Create a range with start and end and a
+   *                                  default step size of 1
+   *     range(start, end, step)      Create a range with start, step, and end.
+   *
+   * Example usage:
+   *     math.range(2, 6);        // [2,3,4,5]
+   *     math.range(2, -3, -1);   // [2,1,0,-1,-2]
+   *     math.range('2:1:6');     // [2,3,4,5]
+   *
+   * @param {...*} args
+   * @return {Array | Matrix} range
+   */
+  math.range = function range(args) {
+    var start, end, step;
+
+    switch (arguments.length) {
+      case 1:
+        // parse string into a range
+        if (isString(args)) {
+          var r = _parse(args);
+          if (!r){
+            throw new SyntaxError('String "' + r + '" is no valid range');
+          }
+
+          start = r.start;
+          end = r.end;
+          step = r.step;
+        }
+        else {
+          throw new TypeError(
+              'Two or three numbers or a single string expected in function range');
+        }
+        break;
+
+      case 2:
+        // range(start, end)
+        start = arguments[0];
+        end = arguments[1];
+        step = 1;
+        break;
+
+      case 3:
+        // range(start, end, step)
+        start = arguments[0];
+        end = arguments[1];
+        step = arguments[2];
+        break;
+
+      default:
+        throw new math.error.ArgumentsError('range', arguments.length, 2, 3);
+    }
+
+    // verify type of parameters
+    if (!isNumber(start) && !(start instanceof BigNumber)) {
+      throw new TypeError('Parameter start must be a number');
+    }
+    if (!isNumber(end) && !(end instanceof BigNumber)) {
+      throw new TypeError('Parameter end must be a number');
+    }
+    if (!isNumber(step) && !(step instanceof BigNumber)) {
+      throw new TypeError('Parameter step must be a number');
+    }
+
+    // go big
+    if (start instanceof BigNumber || end instanceof BigNumber || step instanceof BigNumber) {
+      // create a range with big numbers
+      var asBigNumber = true;
+
+      // convert start, end, step to BigNumber
+      if (!(start instanceof BigNumber)) {
+        start = toBigNumber(start);
+      }
+      if (!(end instanceof BigNumber)) {
+        end = toBigNumber(end);
+      }
+      if (!(step instanceof BigNumber)) {
+        step = toBigNumber(step);
+      }
+
+      if (!(start instanceof BigNumber) || !(end instanceof BigNumber) || !(step instanceof BigNumber)) {
+        // not all values can be converted to big number :(
+        // fall back to numbers
+        asBigNumber = false;
+        start = toNumber(start);
+        end   = toNumber(end);
+        step  = toNumber(step);
+      }
+    }
+
+    // generate the range
+    var array = asBigNumber ? _bigRange(start, end, step) : _range(start, end, step);
+
+    // return as array or matrix
+    return (settings.matrix.defaultType === 'array') ? array : new Matrix(array);
+  };
+
+  /**
+   * Create a range with numbers
+   * @param {Number} start
+   * @param {Number} end
+   * @param {Number} step
+   * @returns {Array} range
+   * @private
+   */
+  function _range (start, end, step) {
+    var array = [],
+        x = start;
+    if (step > 0) {
+      while (x < end) {
+        array.push(x);
+        x += step;
+      }
+    }
+    else if (step < 0) {
+      while (x > end) {
+        array.push(x);
+        x += step;
+      }
+    }
+
+    return array;
+  }
+
+  /**
+   * Create a range with big numbers
+   * @param {BigNumber} start
+   * @param {BigNumber} end
+   * @param {BigNumber} step
+   * @returns {Array} range
+   * @private
+   */
+  function _bigRange (start, end, step) {
+    var array = [],
+        x = start.clone(),
+        zero = new BigNumber(0);
+    if (step.gt(zero)) {
+      while (x.lt(end)) {
+        array.push(x);
+        x = x.plus(step);
+      }
+    }
+    else if (step.lt(zero)) {
+      while (x.gt(end)) {
+        array.push(x);
+        x = x.plus(step);
+      }
+    }
+
+    return array;
+  }
+
+  /**
+   * 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'.
+   * @param {String} str
+   * @return {Object | null} range Object containing properties start, end, step
+   * @private
+   */
+  function _parse (str) {
+    var args = str.split(':'),
+        nums = null;
+
+    if (settings.number.defaultType === 'bignumber') {
+      // bignumber
+      try {
+        nums = args.map(function (arg) {
+          return new BigNumber(arg);
+        });
+      }
+      catch (err) {
+        return null;
+      }
+    }
+    else {
+      // number
+      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 {
+          start: nums[0],
+          end: nums[1],
+          step: 1
+        };
+
+      case 3:
+        return {
+          start: nums[0],
+          end: nums[2],
+          step: nums[1]
+        };
+
+      default:
+        return null;
+    }
+  }
+
+};
+
+},{"../../type/Matrix":205,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],171:[function(require,module,exports){
+module.exports = function (math, settings) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Matrix = require('../../type/Matrix'),
+
+      array = util.array,
+      clone = util.object.clone,
+      isString = util.string.isString,
+      toNumber = util.number.toNumber,
+      isNumber = util.number.isNumber,
+      isInteger = util.number.isInteger,
+      isArray = array.isArray;
+
+  /**
+   * Resize a matrix
+   *
+   *     resize(x, size)
+   *     resize(x, size, defaultValue)
+   *
+   * @param {* | Array | Matrix} x
+   * @param {Array | Matrix} size             One dimensional array with numbers
+   * @param {Number | String} [defaultValue]  Undefined by default, except in
+   *                                          case of a string, in that case
+   *                                          defaultValue = ' '
+   * @return {* | Array | Matrix} res
+   */
+  math.resize = function resize (x, size, defaultValue) {
+    if (arguments.length != 2 && arguments.length != 3) {
+      throw new math.error.ArgumentsError('resize', arguments.length, 2, 3);
+    }
+
+    var asMatrix = (x instanceof Matrix) ? true : isArray(x) ? false :
+        (settings.matrix.defaultType !== 'array');
+
+    if (x instanceof Matrix) {
+      x = x.valueOf(); // get Array
+    }
+    if (size instanceof Matrix) {
+      size = size.valueOf(); // get Array
+    }
+
+    if (size.length && size[0] instanceof BigNumber) {
+      // convert bignumbers to numbers
+      size = size.map(toNumber);
+    }
+
+    if (isString(x)) {
+      return _resizeString(x, size, defaultValue);
+    }
+    else {
+      if (size.length == 0) {
+        // output a scalar
+        while (isArray(x)) {
+          x = x[0];
+        }
+
+        return clone(x);
+      }
+      else {
+        // output an array/matrix
+        if (!isArray(x)) {
+          x = [x];
+        }
+        x = clone(x);
+
+        var res = array.resize(x, size, defaultValue);
+        return asMatrix ? new Matrix(res) : res;
+      }
+    }
+  };
+
+  /**
+   * Resize a string
+   * @param {String} str
+   * @param {Number[]} size
+   * @param {string} char     Default character
+   * @private
+   */
+  function _resizeString(str, size, char) {
+    if (char !== undefined) {
+      if (!isString(char) || char.length !== 1) {
+        throw new TypeError('Single character expected as defaultValue');
+      }
+    }
+    else {
+      char = ' ';
+    }
+
+    if (size.length !== 1) {
+      throw new Error('Dimension mismatch: (' + size.length + ' != 1)');
+    }
+    var len = size[0];
+    if (!isNumber(len) || !isInteger(len)) {
+      throw new TypeError('Size must contain numbers');
+    }
+
+    if (str.length > len) {
+      return str.substring(0, len);
+    }
+    else if (str.length < len) {
+      var res = str;
+      for (var i = 0, ii = len - str.length; i < ii; i++) {
+        res += char;
+      }
+      return res;
+    }
+    else {
+      return str;
+    }
+  }
+};
+
+},{"../../type/Matrix":205,"../../util/index":212,"bignumber.js":217}],172:[function(require,module,exports){
+module.exports = function (math, settings) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      Unit = require('../../type/Unit'),
+      Matrix = require('../../type/Matrix'),
+
+      array = util.array,
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isString = util.string.isString,
+      isComplex = Complex.isComplex,
+      isUnit = Unit.isUnit;
+
+  /**
+   * Calculate the size of a matrix or scalar
+   *
+   *     size(x)
+   *
+   * @param {Boolean | Number | Complex | Unit | String | Array | Matrix} x
+   * @return {Array | Matrix} res
+   */
+  math.size = function size (x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('size', arguments.length, 1);
+    }
+
+    var asArray = (settings.matrix.defaultType === 'array');
+
+    if (isNumber(x) || isComplex(x) || isUnit(x) || isBoolean(x) ||
+        x == null || x instanceof BigNumber) {
+      return asArray ? [] : new Matrix([]);
+    }
+
+    if (isString(x)) {
+      return asArray ? [x.length] : new Matrix([x.length]);
+    }
+
+    if (Array.isArray(x)) {
+      return array.size(x);
+    }
+
+    if (x instanceof Matrix) {
+      return new Matrix(x.size());
+    }
+
+    throw new math.error.UnsupportedTypeError('size', x);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/Matrix":205,"../../type/Unit":207,"../../util/index":212,"bignumber.js":217}],173:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      Matrix = require('../../type/Matrix'),
+
+      object = util.object,
+      array = util.array,
+      isArray = Array.isArray;
+
+  /**
+   * Remove singleton dimensions from a matrix
+   *
+   *     squeeze(x)
+   *
+   * @param {Matrix | Array} x
+   * @return {Matrix | Array} res
+   */
+  math.squeeze = function squeeze (x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('squeeze', arguments.length, 1);
+    }
+
+    if (isArray(x)) {
+      return array.squeeze(object.clone(x));
+    }
+    else if (x instanceof Matrix) {
+      var res = array.squeeze(x.toArray());
+      return isArray(res) ? new Matrix(res) : res;
+    }
+    else {
+      // scalar
+      return object.clone(x);
+    }
+  };
+};
+
+},{"../../type/Matrix":205,"../../util/index":212}],174:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      Matrix = require('../../type/Matrix'),
+      Index = require('../../type/Index'),
+
+      array = util.array,
+      isString = util.string.isString,
+      isArray = Array.isArray;
+
+  /**
+   * Get or set a subset of a matrix or string
+   *
+   * Usage:
+   *     // retrieve subset:
+   *     var subset = math.subset(value, index)
+   *
+   *     // replace subset:
+   *     var value = math.subset(value, index, replacement [, defaultValue])
+   *
+   * Where:
+   *     {Array | Matrix | String} value  An array, matrix, or string
+   *     {Index} index                    An index containing ranges for each
+   *                                      dimension
+   *     {*} replacement                  An array, matrix, or scalar
+   *     {*} [defaultValue]        Default value, filled in on new entries when
+   *                               the matrix is resized. If not provided,
+   *                               new matrix elements will be left undefined.
+   * @param args
+   * @return res
+   */
+  math.subset = function subset (args) {
+    switch (arguments.length) {
+      case 2: // get subset
+        return _getSubset(arguments[0], arguments[1]);
+
+      // intentional fall through
+      case 3: // set subset
+      case 4: // set subset with default value
+        return _setSubset(arguments[0], arguments[1], arguments[2], arguments[3]);
+
+      default: // wrong number of arguments
+        throw new math.error.ArgumentsError('subset', arguments.length, 2, 4);
+    }
+  };
+
+  /**
+   * Retrieve a subset of an value such as an Array, Matrix, or String
+   * @param {Array | Matrix | String} value Object from which to get a subset
+   * @param {Index} index                   An index containing ranges for each
+   *                                        dimension
+   * @returns {Array | Matrix | *} subset
+   * @private
+   */
+  function _getSubset(value, index) {
+    var m, subset;
+
+    if (isArray(value)) {
+      m = new Matrix(value);
+      subset = m.subset(index);
+      return subset.valueOf();
+    }
+    else if (value instanceof Matrix) {
+      return value.subset(index);
+    }
+    else if (isString(value)) {
+      return _getSubstring(value, index);
+    }
+    else {
+      throw new math.error.UnsupportedTypeError('subset', value);
+    }
+  }
+
+  /**
+   * 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 (!(index instanceof Index)) {
+      // TODO: better error message
+      throw new TypeError('Index expected');
+    }
+    if (index.size().length != 1) {
+      throw new RangeError('Dimension mismatch (' + index.size().length + ' != 1)');
+    }
+
+    var range = index.range(0);
+
+    var substr = '';
+    var strLen = str.length;
+    range.forEach(function (v) {
+      array.validateIndex(v, strLen);
+      substr += str.charAt(v);
+    });
+
+    return substr;
+  }
+
+  /**
+   * Replace a subset in an value such as an Array, Matrix, or String
+   * @param {Array | Matrix | String} value Object to be replaced
+   * @param {Index} index                   An index containing ranges for each
+   *                                        dimension
+   * @param {Array | Matrix | *} replacement
+   * @param {*} [defaultValue]        Default value, filled in on new entries when
+   *                                  the matrix is resized. If not provided,
+   *                                  new matrix elements will be left undefined.
+   * @returns {*} result
+   * @private
+   */
+  function _setSubset(value, index, replacement, defaultValue) {
+    var m;
+
+    if (isArray(value)) {
+      m = new Matrix(math.clone(value));
+      m.subset(index, replacement, defaultValue);
+      return m.valueOf();
+    }
+    else if (value instanceof Matrix) {
+      return value.clone().subset(index, replacement, defaultValue);
+    }
+    else if (isString(value)) {
+      return _setSubstring(value, index, replacement, defaultValue);
+    }
+    else {
+      throw new math.error.UnsupportedTypeError('subset', value);
+    }
+  }
+
+  /**
+   * 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 instanceof Index)) {
+      // TODO: better error message
+      throw new TypeError('Index expected');
+    }
+    if (index.size().length != 1) {
+      throw new RangeError('Dimension mismatch (' + index.size().length + ' != 1)');
+    }
+    if (defaultValue !== undefined) {
+      if (!isString(defaultValue) || defaultValue.length !== 1) {
+        throw new TypeError('Single character expected as defaultValue');
+      }
+    }
+    else {
+      defaultValue = ' ';
+    }
+
+    var range = index.range(0);
+    var len = range.size()[0];
+
+    if (len != replacement.length) {
+      throw new RangeError('Dimension mismatch ' +
+          '(' + range.size()[0] + ' != ' + replacement.length + ')');
+    }
+
+    // copy the string into an array with characters
+    var strLen = str.length;
+    var chars = [];
+    for (var i = 0; i < strLen; i++) {
+      chars[i] = str.charAt(i);
+    }
+
+    range.forEach(function (v, i) {
+      array.validateIndex(v);
+      chars[v] = replacement.charAt(i);
+    });
+
+    // initialize undefined characters with a space
+    if (chars.length > strLen) {
+      for (i = strLen - 1, len = chars.length; i < len; i++) {
+        if (!chars[i]) {
+          chars[i] = defaultValue;
+        }
+      }
+    }
+
+    return chars.join('');
+  }
+};
+
+},{"../../type/Index":204,"../../type/Matrix":205,"../../util/index":212}],175:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      Matrix = require('../../type/Matrix'),
+      collection = require('../../type/collection'),
+
+      object = util.object,
+      string = util.string;
+
+  /**
+   * Create the transpose of a matrix
+   *
+   *     transpose(x)
+   *
+   * @param {Array | Matrix} x
+   * @return {Array | Matrix} transpose
+   */
+  math.transpose = function transpose (x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('transpose', arguments.length, 1);
+    }
+
+    var size = math.size(x).valueOf();
+    switch (size.length) {
+      case 0:
+        // scalar
+        return object.clone(x);
+        break;
+
+      case 1:
+        // vector
+        return object.clone(x);
+        break;
+
+      case 2:
+        // two dimensional array
+        var rows = size[1],
+            cols = size[0],
+            asMatrix = (x instanceof Matrix),
+            data = x.valueOf(),
+            transposed = [],
+            transposedRow,
+            clone = object.clone;
+
+        if (rows === 0) {
+          // whoops
+          throw new RangeError('Cannot transpose a 2D matrix with no rows' +
+              '(size: ' + string.format(size) + ')');
+        }
+
+        for (var r = 0; r < rows; r++) {
+          transposedRow = transposed[r] = [];
+          for (var c = 0; c < cols; c++) {
+            transposedRow[c] = clone(data[c][r]);
+          }
+        }
+        if (cols == 0) {
+          transposed[0] = [];
+        }
+
+        return asMatrix ? new Matrix(transposed) : transposed;
+        break;
+
+      default:
+        // multi dimensional array
+        throw new RangeError('Matrix must be two dimensional ' +
+            '(size: ' + string.format(size) + ')');
+    }
+  };
+};
+
+},{"../../type/Matrix":205,"../../type/collection":208,"../../util/index":212}],176:[function(require,module,exports){
+module.exports = function (math, settings) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Matrix = require('../../type/Matrix'),
+      collection = require('../../type/collection'),
+
+      array = util.array,
+      toNumber = util.number.toNumber,
+      isArray = Array.isArray;
+
+  /**
+   * create a matrix filled with zeros
+   *
+   *     zeros(m)
+   *     zeros(m, n)
+   *     zeros([m, n])
+   *     zeros([m, n, p, ...])
+   *
+   * @param {...Number | Array} size
+   * @return {Array | Matrix | Number} matrix
+   */
+  math.zeros = function zeros (size) {
+    var args = collection.argsToArray(arguments);
+    var asMatrix = (size instanceof Matrix) ? true :
+        (isArray(size) ? false : (settings.matrix.defaultType === 'matrix'));
+
+    if (args.length == 0) {
+      // output an empty matrix
+      return asMatrix ? new Matrix() : [];
+    }
+    else {
+      // output an array or matrix
+      var res = [];
+      var defaultValue = (args[0] instanceof BigNumber) ? new BigNumber(0) : 0;
+      res = array.resize(res, args.map(toNumber), defaultValue);
+
+      return asMatrix ? new Matrix(res) : res;
+    }
+  };
+};
+
+},{"../../type/Matrix":205,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],177:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isInteger = util.number.isInteger,
+      isCollection = collection.isCollection;
+
+  /**
+   * Compute the factorial of a value
+   *
+   *     x!
+   *     factorial(x)
+   *
+   * Factorial only supports an integer value as argument.
+   * For matrices, the function is evaluated element wise.
+   *
+   * @Param {Number | BigNumber | Array | Matrix} x
+   * @return {Number | BigNumber | Array | Matrix} res
+   */
+  math.factorial = function factorial (x) {
+    var value, res;
+
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('factorial', arguments.length, 1);
+    }
+
+    if (isNumber(x)) {
+      if (!isInteger(x) || x < 0) {
+        throw new TypeError('Positive integer value expected in function factorial');
+      }
+
+      value = x - 1;
+      res = x;
+      while (value > 1) {
+        res *= value;
+        value--;
+      }
+
+      if (res == 0) {
+        res = 1;        // 0! is per definition 1
+      }
+
+      return res;
+    }
+
+    if (x instanceof BigNumber) {
+      if (!x.round().equals(x) || x.lt(0)) {
+        throw new TypeError('Positive integer value expected in function factorial');
+      }
+
+      var one = new BigNumber(1);
+
+      value = x.minus(one);
+      res = x;
+      while (value.gt(one)) {
+        res = res.times(value);
+        value = value.minus(one);
+      }
+
+      if (res.equals(0)) {
+        res = one;        // 0! is per definition 1
+      }
+
+      return res;
+    }
+
+    if (isBoolean(x)) {
+      return 1; // factorial(1) = 1, factorial(0) = 1
+    }
+
+    if (isCollection(x)) {
+      return collection.deepMap(x, factorial);
+    }
+
+    throw new math.error.UnsupportedTypeError('factorial', x);
+  };
+};
+
+},{"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],178:[function(require,module,exports){
+module.exports = function (math, settings) {
+  var Matrix = require('../../type/Matrix'),
+      collection = require('../../type/collection');
+
+  // TODO: implement BigNumber support for random
+
+  /**
+   * Return a random number between 0 and 1
+   *
+   *     random()
+   *
+   * @return {Number} res
+   */
+
+  // Each distribution is a function that takes no argument and when called returns
+  // a number between 0 and 1.
+  var distributions = {
+
+    uniform: function() {
+      return Math.random;
+    },
+
+    // Implementation of normal distribution using Box-Muller transform
+    // ref : http://en.wikipedia.org/wiki/Box%E2%80%93Muller_transform
+    // We take : mean = 0.5, standard deviation = 1/6
+    // so that 99.7% values are in [0, 1].
+    normal: function() {
+      return function() {
+        var u1, u2,
+            picked = -1;
+        // We reject values outside of the interval [0, 1]
+        // TODO: check if it is ok to do that?
+        while (picked < 0 || picked > 1) {
+          u1 = Math.random();
+          u2 = Math.random();
+          picked = 1/6 * Math.pow(-2 * Math.log(u1), 0.5) * Math.cos(2 * Math.PI * u2) + 0.5;
+        }
+        return picked;
+      }
+    }
+  };
+
+  /**
+   * Create a distribution object.
+   * @param {String} name           Name of a distribution.
+   *                                Choose from 'uniform', 'normal'.
+   * @return {Object} distribution  A distribution object containing functions:
+   *                                    random([size, min, max])
+   *                                    randomInt([min, max])
+   *                                    pickRandom(array)
+   */
+  math.distribution = function(name) {
+    if (!distributions.hasOwnProperty(name))
+      throw new Error('unknown distribution ' + name);
+
+    var args = Array.prototype.slice.call(arguments, 1),
+        distribution = distributions[name].apply(this, args);
+
+    return (function(distribution) {
+
+      // This is the public API for all distributions
+      var randFunctions = {
+
+        random: function(arg1, arg2, arg3) {
+          var size, min, max;
+          if (arguments.length > 3) {
+            throw new math.error.ArgumentsError('random', arguments.length, 0, 3);
+
+          // `random(max)` or `random(size)`
+          } else if (arguments.length === 1) {
+            if (Array.isArray(arg1))
+              size = arg1;
+            else
+              max = arg1;
+          // `random(min, max)` or `random(size, max)`
+          } else if (arguments.length === 2) {
+            if (Array.isArray(arg1))
+              size = arg1;
+            else {
+              min = arg1;
+              max = arg2;
+            }
+          // `random(size, min, max)`
+          } else {
+            size = arg1;
+            min = arg2;
+            max = arg3;
+          }
+
+          if (max === undefined) max = 1;
+          if (min === undefined) min = 0;
+          if (size !== undefined) {
+            var res = _randomDataForMatrix(size, min, max, _random);
+            return (settings.matrix.defaultType === 'array') ? res : new Matrix(res);
+          }
+          else return _random(min, max);
+        },
+
+        randomInt: function(arg1, arg2, arg3) {
+          var size, min, max;
+          if (arguments.length > 3 || arguments.length < 1)
+            throw new math.error.ArgumentsError('randomInt', arguments.length, 1, 3);
+
+          // `randomInt(max)`
+          else if (arguments.length === 1) max = arg1;
+          // `randomInt(min, max)` or `randomInt(size, max)`
+          else if (arguments.length === 2) {
+            if (Object.prototype.toString.call(arg1) === '[object Array]')
+              size = arg1;
+            else {
+              min = arg1;
+              max = arg2;
+            }
+          // `randomInt(size, min, max)`
+          } else {
+            size = arg1;
+            min = arg2;
+            max = arg3;
+          }
+
+          if (min === undefined) min = 0;
+          if (size !== undefined) {
+            var res = _randomDataForMatrix(size, min, max, _randomInt);
+            return (settings.matrix.defaultType === 'array') ? res : new Matrix(res);
+          }
+          else return _randomInt(min, max);
+        },
+
+        pickRandom: function(possibles) {
+          if (arguments.length !== 1) {
+            throw new math.error.ArgumentsError('pickRandom', arguments.length, 1);
+          }
+          if (!Array.isArray(possibles)) {
+            throw new math.error.UnsupportedTypeError('pickRandom', possibles);
+          }
+
+          // TODO: add support for matrices
+          return possibles[Math.floor(Math.random() * possibles.length)];
+        }
+
+      };
+
+      var _random = function(min, max) {
+        return min + distribution() * (max - min);
+      };
+
+      var _randomInt = function(min, max) {
+        return Math.floor(min + distribution() * (max - min));
+      };
+
+      // This is a function for generating a random matrix recursively.
+      var _randomDataForMatrix = function(size, min, max, randFunc) {
+        var data = [], length, i;
+        size = size.slice(0);
+
+        if (size.length > 1) {
+          for (i = 0, length = size.shift(); i < length; i++)
+            data.push(_randomDataForMatrix(size, min, max, randFunc));
+        } else {
+          for (i = 0, length = size.shift(); i < length; i++)
+            data.push(randFunc(min, max));
+        }
+
+        return data;
+      };
+
+      return randFunctions;
+
+    })(distribution);
+
+  };
+
+  // Default random functions use uniform distribution
+  // TODO: put random functions in separate files?
+  var uniformRandFunctions = math.distribution('uniform');
+  math.random = uniformRandFunctions.random;
+  math.randomInt = uniformRandFunctions.randomInt;
+  math.pickRandom = uniformRandFunctions.pickRandom;
+};
+
+},{"../../type/Matrix":205,"../../type/collection":208}],179:[function(require,module,exports){
+module.exports = function (math) {
+  var Matrix = require('../../type/Matrix'),
+      collection = require('../../type/collection'),
+
+      isCollection = collection.isCollection;
+
+  /**
+   * Compute the maximum value of a list of values
+   * In case of a multi dimensional array, the maximum of the flattened array
+   * will be calculated. When dim is provided, the maximum over the selected
+   * dimension will be calculated.
+   *
+   *     max(a, b, c, ...)
+   *     max(A)
+   *     max(A, dim)
+   *
+   * @param {... *} args  A single matrix or or multiple scalar values
+   * @return {*} res
+   */
+  math.max = function max(args) {
+    if (arguments.length == 0) {
+      throw new SyntaxError('Function max requires one or more parameters (0 provided)');
+    }
+
+    if (isCollection(args)) {
+      if (arguments.length == 1) {
+        // max([a, b, c, d, ...])
+        return _max(args);
+      }
+      else if (arguments.length == 2) {
+        // max([a, b, c, d, ...], dim)
+        return collection.reduce(arguments[0], arguments[1], _getlarger);
+      }
+      else {
+        throw new SyntaxError('Wrong number of parameters');
+      }
+    }
+    else {
+      // max(a, b, c, d, ...)
+      return _max(arguments);
+    }
+  };
+
+  function _getlarger(x, y){
+	  if( math.larger(x,y) )
+		  return x;
+	  else
+		  return y;
+  }
+
+  /**
+   * Recursively calculate the maximum value in an n-dimensional array
+   * @param {Array} array
+   * @return {Number} max
+   * @private
+   */
+  function _max(array) {
+    var max = null;
+
+    collection.deepForEach(array, function (value) {
+      if (max === null || math.larger(value, max)) {
+        max = value;
+      }
+    });
+
+    if (max === null) {
+      throw new Error('Cannot calculate max of an empty array');
+    }
+
+    return max;
+  }
+};
+
+},{"../../type/Matrix":205,"../../type/collection":208}],180:[function(require,module,exports){
+module.exports = function (math) {
+  var Matrix = require('../../type/Matrix'),
+      collection = require('../../type/collection'),
+
+      isCollection = collection.isCollection;
+
+  /**
+   * Compute the mean value of a list of values
+   * In case of a multi dimensional array, the mean of the flattened array
+   * will be calculated. When dim is provided, the maximum over the selected
+   * dimension will be calculated.
+   *
+   *     mean(a, b, c, ...)
+   *     mean(A)
+   *     mean(A, dim)
+   *
+   * @param {... *} args  A single matrix or or multiple scalar values
+   * @return {*} res
+   */
+  math.mean = function mean(args) {
+    if (arguments.length == 0) {
+      throw new SyntaxError('Function mean requires one or more parameters (0 provided)');
+    }
+
+    if (isCollection(args)) {
+      if (arguments.length == 1) {
+        // mean([a, b, c, d, ...])
+        return _mean(args);
+      }
+      else if (arguments.length == 2) {
+        // mean([a, b, c, d, ...], dim)
+        return _nmean(arguments[0], arguments[1]);
+      }
+      else {
+        throw new SyntaxError('Wrong number of parameters');
+      }
+    }
+    else {
+      // mean(a, b, c, d, ...)
+      return _mean(arguments);
+    }
+  };
+
+  /**
+   * Calculate the mean value in an n-dimensional array, returning a
+   * n-1 dimensional array
+   * @param {Array} array
+   * @param {Number} dim
+   * @return {Number} mean
+   * @private
+   */
+  function _nmean(array, dim){
+	  var sum;
+	  sum = collection.reduce(array, dim, math.add);
+	  return math.divide(sum, size(array)[dim]);
+  };
+
+  /**
+   * Recursively calculate the mean value in an n-dimensional array
+   * @param {Array} array
+   * @return {Number} mean
+   * @private
+   */
+  function _mean(array) {
+    var sum = 0;
+    var num = 0;
+
+    collection.deepForEach(array, function (value) {
+      sum = math.add(sum, value);
+      num++;
+    });
+
+    if (num === 0) {
+      throw new Error('Cannot calculate mean of an empty array');
+    }
+
+    return math.divide(sum, num);
+  }
+};
+
+},{"../../type/Matrix":205,"../../type/collection":208}],181:[function(require,module,exports){
+module.exports = function (math) {
+  var Matrix = require('../../type/Matrix'),
+      collection = require('../../type/collection'),
+
+      isCollection = collection.isCollection;
+
+  /**
+   * Compute the minimum value of a list of values.
+   * In case of a multi dimensional array, the minimum of the flattened array
+   * will be calculated. When dim is provided, the maximum over the selected
+   * dimension will be calculated.
+   *
+   *     min(a, b, c, ...)
+   *     min(A)
+   *     min(A, dim)
+   *
+   * @param {... *} args  A single matrix or multiple scalar values
+   * @return {*} res
+   */
+  math.min = function min(args) {
+    if (arguments.length == 0) {
+      throw new SyntaxError('Function min requires one or more parameters (0 provided)');
+    }
+
+    if (isCollection(args)) {
+      if (arguments.length == 1) {
+        // min([a, b, c, d, ...])
+        return _min(args);
+      }
+      else if (arguments.length == 2) {
+        // min([a, b, c, d, ...], dim)
+        return collection.reduce(arguments[0], arguments[1], _getsmaller);
+      }
+      else {
+        throw new SyntaxError('Wrong number of parameters');
+      }
+    }
+    else {
+      // min(a, b, c, d, ...)
+      return _min(arguments);
+    }
+  };
+
+  function _getsmaller(x, y){
+	  if( math.smaller(x,y) )
+		  return x;
+	  else
+		  return y;
+  }
+
+  /**
+   * Recursively calculate the minimum value in an n-dimensional array
+   * @param {Array} array
+   * @return {Number} min
+   * @private
+   */
+  function _min(array) {
+    var min = null;
+
+    collection.deepForEach(array, function (value) {
+      if (min === null || math.smaller(value, min)) {
+        min = value;
+      }
+    });
+
+    if (min === null) {
+      throw new Error('Cannot calculate min of an empty array');
+    }
+
+    return min;
+  }
+};
+
+},{"../../type/Matrix":205,"../../type/collection":208}],182:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isComplex = Complex.isComplex,
+      isCollection = collection.isCollection;
+
+  /**
+   * Calculate the inverse cosine of a value
+   *
+   *     acos(x)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param {Number | Boolean | Complex | Array | Matrix} x
+   * @return {Number | Complex | Array | Matrix} res
+   *
+   * @see http://mathworld.wolfram.com/InverseCosine.html
+   */
+  math.acos = function acos(x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('acos', arguments.length, 1);
+    }
+
+    if (isNumber(x)) {
+      if (x >= -1 && x <= 1) {
+        return Math.acos(x);
+      }
+      else {
+        return acos(new Complex(x, 0));
+      }
+    }
+
+    if (isComplex(x)) {
+      // acos(z) = 0.5*pi + i*log(iz + sqrt(1-z^2))
+      var temp1 = new Complex(
+          x.im * x.im - x.re * x.re + 1.0,
+          -2.0 * x.re * x.im
+      );
+      var temp2 = math.sqrt(temp1);
+      var temp3;
+      if (temp2 instanceof Complex) {
+        temp3 = new Complex(
+            temp2.re - x.im,
+            temp2.im + x.re
+        )
+      }
+      else {
+        temp3 = new Complex(
+            temp2 - x.im,
+            x.re
+        )
+      }
+      var temp4 = math.log(temp3);
+
+      // 0.5*pi = 1.5707963267948966192313216916398
+      if (temp4 instanceof Complex) {
+        return new Complex(
+            1.57079632679489661923 - temp4.im,
+            temp4.re
+        );
+      }
+      else {
+        return new Complex(
+            1.57079632679489661923,
+            temp4
+        );
+      }
+    }
+
+    if (isCollection(x)) {
+      return collection.deepMap(x, acos);
+    }
+
+    if (isBoolean(x)) {
+      return Math.acos(x);
+    }
+
+    if (x instanceof BigNumber) {
+      // TODO: implement BigNumber support
+      // downgrade to Number
+      return acos(util.number.toNumber(x));
+    }
+
+    throw new math.error.UnsupportedTypeError('acos', x);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],183:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isComplex = Complex.isComplex,
+      isCollection = collection.isCollection;
+
+  /**
+   * Calculate the inverse sine of a value
+   *
+   *     asin(x)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param {Number | Boolean | Complex | Array | Matrix} x
+   * @return {Number | Complex | Array | Matrix} res
+   *
+   * @see http://mathworld.wolfram.com/InverseSine.html
+   */
+  math.asin = function asin(x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('asin', arguments.length, 1);
+    }
+
+    if (isNumber(x)) {
+      if (x >= -1 && x <= 1) {
+        return Math.asin(x);
+      }
+      else {
+        return asin(new Complex(x, 0));
+      }
+    }
+
+    if (isComplex(x)) {
+      // asin(z) = -i*log(iz + sqrt(1-z^2))
+      var re = x.re;
+      var im = x.im;
+      var temp1 = new Complex(
+          im * im - re * re + 1.0,
+          -2.0 * re * im
+      );
+
+      var temp2 = math.sqrt(temp1);
+      var temp3;
+      if (temp2 instanceof Complex) {
+        temp3 = new Complex(
+            temp2.re - im,
+            temp2.im + re
+        );
+      }
+      else {
+        temp3 = new Complex(
+            temp2 - im,
+            re
+        );
+      }
+
+      var temp4 = math.log(temp3);
+
+      if (temp4 instanceof Complex) {
+        return new Complex(temp4.im, -temp4.re);
+      }
+      else {
+        return new Complex(0, -temp4);
+      }
+    }
+
+    if (isCollection(x)) {
+      return collection.deepMap(x, asin);
+    }
+
+    if (isBoolean(x)) {
+      return Math.asin(x);
+    }
+
+    if (x instanceof BigNumber) {
+      // TODO: implement BigNumber support
+      // downgrade to Number
+      return asin(util.number.toNumber(x));
+    }
+
+    throw new math.error.UnsupportedTypeError('asin', x);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],184:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isComplex = Complex.isComplex,
+      isCollection = collection.isCollection;
+
+  /**
+   * Calculate the inverse tangent of a value
+   *
+   *     atan(x)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param {Number | Boolean | Complex | Array | Matrix} x
+   * @return {Number | Complex | Array | Matrix} res
+   *
+   * @see http://mathworld.wolfram.com/InverseTangent.html
+   */
+  math.atan = function atan(x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('atan', arguments.length, 1);
+    }
+
+    if (isNumber(x)) {
+      return Math.atan(x);
+    }
+
+    if (isComplex(x)) {
+      // atan(z) = 1/2 * i * (ln(1-iz) - ln(1+iz))
+      var re = x.re;
+      var im = x.im;
+      var den = re * re + (1.0 - im) * (1.0 - im);
+
+      var temp1 = new Complex(
+          (1.0 - im * im - re * re) / den,
+          (-2.0 * re) / den
+      );
+      var temp2 = math.log(temp1);
+
+      if (temp2 instanceof Complex) {
+        return new Complex(
+            -0.5 * temp2.im,
+            0.5 * temp2.re
+        );
+      }
+      else {
+        return new Complex(
+            0,
+            0.5 * temp2
+        );
+      }
+    }
+
+    if (isCollection(x)) {
+      return collection.deepMap(x, atan);
+    }
+
+    if (isBoolean(x)) {
+      return Math.atan(x);
+    }
+
+    if (x instanceof BigNumber) {
+      // TODO: implement BigNumber support
+      // downgrade to Number
+      return atan(util.number.toNumber(x));
+    }
+
+    throw new math.error.UnsupportedTypeError('atan', x);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],185:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      collection = require('../../type/collection'),
+
+      toNumber = util.number.toNumber,
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isComplex = Complex.isComplex,
+      isCollection = collection.isCollection;
+
+  /**
+   * Computes the principal value of the arc tangent of y/x in radians
+   *
+   *     atan2(y, x)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param {Number | Boolean | Complex | Array | Matrix} y
+   * @param {Number | Boolean | Complex | Array | Matrix} x
+   * @return {Number | Complex | Array | Matrix} res
+   *
+   * @see http://mathworld.wolfram.com/InverseTangent.html
+   */
+  math.atan2 = function atan2(y, x) {
+    if (arguments.length != 2) {
+      throw new math.error.ArgumentsError('atan2', arguments.length, 2);
+    }
+
+    if (isNumber(y)) {
+      if (isNumber(x)) {
+        return Math.atan2(y, x);
+      }
+      /* TODO: support for complex computation of atan2
+       else if (isComplex(x)) {
+       return Math.atan2(y.re, x.re);
+       }
+       */
+    }
+    else if (isComplex(y)) {
+      if (isNumber(x)) {
+        return Math.atan2(y.re, x);
+      }
+      /* TODO: support for complex computation of atan2
+       else if (isComplex(x)) {
+       return Math.atan2(y.re, x.re);
+       }
+       */
+    }
+
+    if (isCollection(y) || isCollection(x)) {
+      return collection.deepMap2(y, x, atan2);
+    }
+
+    if (isBoolean(y)) {
+      return atan2(+y, x);
+    }
+    if (isBoolean(x)) {
+      return atan2(y, +x);
+    }
+
+    // TODO: implement bignumber support
+    if (y instanceof BigNumber) {
+      return atan2(toNumber(y), x);
+    }
+    if (x instanceof BigNumber) {
+      return atan2(y, toNumber(x));
+    }
+
+    throw new math.error.UnsupportedTypeError('atan2', y, x);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],186:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      Unit = require('../../type/Unit'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isComplex = Complex.isComplex,
+      isUnit = Unit.isUnit,
+      isCollection = collection.isCollection;
+
+  /**
+   * Calculate the cosine of a value
+   *
+   *     cos(x)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param {Number | Boolean | Complex | Unit | Array | Matrix} x
+   * @return {Number | Complex | Array | Matrix} res
+   *
+   * @see http://mathworld.wolfram.com/Cosine.html
+   */
+  math.cos = function cos(x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('cos', arguments.length, 1);
+    }
+
+    if (isNumber(x)) {
+      return Math.cos(x);
+    }
+
+    if (isComplex(x)) {
+      // cos(z) = (exp(iz) + exp(-iz)) / 2
+      return new Complex(
+          0.5 * Math.cos(x.re) * (Math.exp(-x.im) + Math.exp(x.im)),
+          0.5 * Math.sin(x.re) * (Math.exp(-x.im) - Math.exp(x.im))
+      );
+    }
+
+    if (isUnit(x)) {
+      if (!x.hasBase(Unit.BASE_UNITS.ANGLE)) {
+        throw new TypeError ('Unit in function cos is no angle');
+      }
+      return Math.cos(x.value);
+    }
+
+    if (isCollection(x)) {
+      return collection.deepMap(x, cos);
+    }
+
+    if (isBoolean(x)) {
+      return Math.cos(x);
+    }
+
+    if (x instanceof BigNumber) {
+      // TODO: implement BigNumber support
+      // downgrade to Number
+      return cos(util.number.toNumber(x));
+    }
+
+    throw new math.error.UnsupportedTypeError('cos', x);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],187:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      Unit = require('../../type/Unit'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isComplex = Complex.isComplex,
+      isUnit = Unit.isUnit,
+      isCollection = collection.isCollection;
+
+  /**
+   * Calculate the cotangent of a value. cot(x) is defined as 1 / tan(x)
+   *
+   *     cot(x)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param {Number | Boolean | Complex | Unit | Array | Matrix} x
+   * @return {Number | Complex | Array | Matrix} res
+   */
+  math.cot = function cot(x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('cot', arguments.length, 1);
+    }
+
+    if (isNumber(x)) {
+      return 1 / Math.tan(x);
+    }
+
+    if (isComplex(x)) {
+      var den = Math.exp(-4.0 * x.im) -
+          2.0 * Math.exp(-2.0 * x.im) * Math.cos(2.0 * x.re) + 1.0;
+
+      return new Complex(
+          2.0 * Math.exp(-2.0 * x.im) * Math.sin(2.0 * x.re) / den,
+          (Math.exp(-4.0 * x.im) - 1.0) / den
+      );
+    }
+
+    if (isUnit(x)) {
+      if (!x.hasBase(Unit.BASE_UNITS.ANGLE)) {
+        throw new TypeError ('Unit in function cot is no angle');
+      }
+      return 1 / Math.tan(x.value);
+    }
+
+    if (isCollection(x)) {
+      return collection.deepMap(x, cot);
+    }
+
+    if (isBoolean(x)) {
+      return cot(+x);
+    }
+
+    if (x instanceof BigNumber) {
+      // TODO: implement BigNumber support
+      // downgrade to Number
+      return cot(util.number.toNumber(x));
+    }
+
+    throw new math.error.UnsupportedTypeError('cot', x);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],188:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      Unit = require('../../type/Unit'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isComplex = Complex.isComplex,
+      isUnit = Unit.isUnit,
+      isCollection = collection.isCollection;
+
+  /**
+   * Calculate the cosecant of a value, csc(x) = 1/sin(x)
+   *
+   *     csc(x)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param {Number | Boolean | Complex | Unit | Array | Matrix} x
+   * @return {Number | Complex | Array | Matrix} res
+   */
+  math.csc = function csc(x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('csc', arguments.length, 1);
+    }
+
+    if (isNumber(x)) {
+      return 1 / Math.sin(x);
+    }
+
+    if (isComplex(x)) {
+      // csc(z) = 1/sin(z) = (2i) / (exp(iz) - exp(-iz))
+      var den = 0.25 * (Math.exp(-2.0 * x.im) + Math.exp(2.0 * x.im)) -
+          0.5 * Math.cos(2.0 * x.re);
+
+      return new Complex (
+          0.5 * Math.sin(x.re) * (Math.exp(-x.im) + Math.exp(x.im)) / den,
+          0.5 * Math.cos(x.re) * (Math.exp(-x.im) - Math.exp(x.im)) / den
+      );
+    }
+
+    if (isUnit(x)) {
+      if (!x.hasBase(Unit.BASE_UNITS.ANGLE)) {
+        throw new TypeError ('Unit in function csc is no angle');
+      }
+      return 1 / Math.sin(x.value);
+    }
+
+    if (isCollection(x)) {
+      return collection.deepMap(x, csc);
+    }
+
+    if (isBoolean(x)) {
+      return csc(+x);
+    }
+
+    if (x instanceof BigNumber) {
+      // TODO: implement BigNumber support
+      // downgrade to Number
+      return csc(util.number.toNumber(x));
+    }
+
+    throw new math.error.UnsupportedTypeError('csc', x);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],189:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      Unit = require('../../type/Unit'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isComplex = Complex.isComplex,
+      isUnit = Unit.isUnit,
+      isCollection = collection.isCollection;
+
+  /**
+   * Calculate the secant of a value, sec(x) = 1/cos(x)
+   *
+   *     sec(x)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param {Number | Boolean | Complex | Unit | Array | Matrix} x
+   * @return {Number | Complex | Array | Matrix} res
+   */
+  math.sec = function sec(x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('sec', arguments.length, 1);
+    }
+
+    if (isNumber(x)) {
+      return 1 / Math.cos(x);
+    }
+
+    if (isComplex(x)) {
+      // sec(z) = 1/cos(z) = 2 / (exp(iz) + exp(-iz))
+      var den = 0.25 * (Math.exp(-2.0 * x.im) + Math.exp(2.0 * x.im)) +
+          0.5 * Math.cos(2.0 * x.re);
+      return new Complex(
+          0.5 * Math.cos(x.re) * (Math.exp(-x.im) + Math.exp( x.im)) / den,
+          0.5 * Math.sin(x.re) * (Math.exp( x.im) - Math.exp(-x.im)) / den
+      );
+    }
+
+    if (isUnit(x)) {
+      if (!x.hasBase(Unit.BASE_UNITS.ANGLE)) {
+        throw new TypeError ('Unit in function sec is no angle');
+      }
+      return 1 / Math.cos(x.value);
+    }
+
+    if (isCollection(x)) {
+      return collection.deepMap(x, sec);
+    }
+
+    if (isBoolean(x)) {
+      return sec(+x);
+    }
+
+    if (x instanceof BigNumber) {
+      // TODO: implement BigNumber support
+      // downgrade to Number
+      return sec(util.number.toNumber(x));
+    }
+
+    throw new math.error.UnsupportedTypeError('sec', x);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],190:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      Unit = require('../../type/Unit'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isComplex = Complex.isComplex,
+      isUnit = Unit.isUnit,
+      isCollection = collection.isCollection;
+
+  /**
+   * Calculate the sine of a value
+   *
+   *     sin(x)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param {Number | Boolean | Complex | Unit | Array | Matrix} x
+   * @return {Number | Complex | Array | Matrix} res
+   *
+   * @see http://mathworld.wolfram.com/Sine.html
+   */
+  math.sin = function sin(x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('sin', arguments.length, 1);
+    }
+
+    if (isNumber(x)) {
+      return Math.sin(x);
+    }
+
+    if (isComplex(x)) {
+      return new Complex(
+          0.5 * Math.sin(x.re) * (Math.exp(-x.im) + Math.exp( x.im)),
+          0.5 * Math.cos(x.re) * (Math.exp( x.im) - Math.exp(-x.im))
+      );
+    }
+
+    if (isUnit(x)) {
+      if (!x.hasBase(Unit.BASE_UNITS.ANGLE)) {
+        throw new TypeError ('Unit in function sin is no angle');
+      }
+      return Math.sin(x.value);
+    }
+
+    if (isCollection(x)) {
+      return collection.deepMap(x, sin);
+    }
+
+    if (isBoolean(x)) {
+      return Math.sin(x);
+    }
+
+    if (x instanceof BigNumber) {
+      // TODO: implement BigNumber support
+      // downgrade to Number
+      return sin(util.number.toNumber(x));
+    }
+
+    throw new math.error.UnsupportedTypeError('sin', x);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],191:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      Unit = require('../../type/Unit'),
+      collection = require('../../type/collection'),
+
+      isNumber = util.number.isNumber,
+      isBoolean = util.boolean.isBoolean,
+      isComplex = Complex.isComplex,
+      isUnit = Unit.isUnit,
+      isCollection = collection.isCollection;
+
+  /**
+   * Calculate the tangent of a value
+   *
+   *     tan(x)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param {Number | Boolean | Complex | Unit | Array | Matrix} x
+   * @return {Number | Complex | Array | Matrix} res
+   *
+   * @see http://mathworld.wolfram.com/Tangent.html
+   */
+  math.tan = function tan(x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('tan', arguments.length, 1);
+    }
+
+    if (isNumber(x)) {
+      return Math.tan(x);
+    }
+
+    if (isComplex(x)) {
+      var den = Math.exp(-4.0 * x.im) +
+          2.0 * Math.exp(-2.0 * x.im) * Math.cos(2.0 * x.re) +
+          1.0;
+
+      return new Complex(
+          2.0 * Math.exp(-2.0 * x.im) * Math.sin(2.0 * x.re) / den,
+          (1.0 - Math.exp(-4.0 * x.im)) / den
+      );
+    }
+
+    if (isUnit(x)) {
+      if (!x.hasBase(Unit.BASE_UNITS.ANGLE)) {
+        throw new TypeError ('Unit in function tan is no angle');
+      }
+      return Math.tan(x.value);
+    }
+
+    if (isCollection(x)) {
+      return collection.deepMap(x, tan);
+    }
+
+    if (isBoolean(x)) {
+      return Math.tan(x);
+    }
+
+    if (x instanceof BigNumber) {
+      // TODO: implement BigNumber support
+      // downgrade to Number
+      return tan(util.number.toNumber(x));
+    }
+
+    throw new math.error.UnsupportedTypeError('tan', x);
+  };
+};
+
+},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],192:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      Unit = require('../../type/Unit'),
+      collection = require('../../type/collection'),
+
+      isString = util.string.isString,
+      isUnit = Unit.isUnit,
+      isCollection = collection.isCollection;
+
+  /**
+   * Change the unit of a value.
+   *
+   *     x in unit
+   *     in(x, unit)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * @param {Unit | Array | Matrix} x
+   * @param {Unit | Array | Matrix} unit
+   * @return {Unit | Array | Matrix} res
+   */
+  math['in'] = function unit_in(x, unit) {
+    if (arguments.length != 2) {
+      throw new math.error.ArgumentsError('in', arguments.length, 2);
+    }
+
+    if (isUnit(x)) {
+      if (isUnit(unit) || isString(unit)) {
+        return x['in'](unit);
+      }
+    }
+
+    // TODO: add support for string, in that case, convert to unit
+
+    if (isCollection(x) || isCollection(unit)) {
+      return collection.deepMap2(x, unit, unit_in);
+    }
+
+    throw new math.error.UnsupportedTypeError('in', x, unit);
+  };
+};
+
+},{"../../type/Unit":207,"../../type/collection":208,"../../util/index":212}],193:[function(require,module,exports){
+module.exports = function (math) {
+  var object = require('../../util/object');
+
+  /**
+   * Clone an object
+   *
+   *     clone(x)
+   *
+   * @param {*} x
+   * @return {*} clone
+   */
+  math.clone = function clone (x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('clone', arguments.length, 1);
+    }
+
+    return object.clone(x);
+  };
+};
+
+},{"../../util/object":214}],194:[function(require,module,exports){
+module.exports = function (math) {
+  var isMatrix = require('../../type/Matrix').isMatrix;
+
+  /**
+   * Execute a callback method on each entry of the matrix or the array.
+   * @param {Matrix/array} x      The container to iterate on.
+   * @param {function} callback   The callback method is invoked with three
+   *                              parameters: the value of the element, the index
+   *                              of the element, and the Matrix/array being traversed.
+   */
+  math.forEach = function (x, callback) {
+    if (arguments.length != 2) {
+      throw new math.error.ArgumentsError('forEach', arguments.length, 2);
+    }
+
+    if (Array.isArray(x)) {
+      return _forEachArray(x, callback);
+    } else if (isMatrix(x)) {
+      return x.forEach(callback);
+    } else {
+      throw new math.error.UnsupportedTypeError('forEach', x);
+    }
+  };
+
+  function _forEachArray (array, callback) {
+    var index = [];
+    var recurse = function (value, dim) {
+      if (Array.isArray(value)) {
+        value.forEach(function (child, i) {
+          index[dim] = i; // zero-based index
+          recurse(child, dim + 1);
+        });
+      }
+      else {
+        callback(value, index, array);
+      }
+    };
+    recurse(array, 0);
+  };
+
+};
+},{"../../type/Matrix":205}],195:[function(require,module,exports){
+module.exports = function (math) {
+  var string = require('../../util/string');
+
+  /**
+   * Format a value of any type into a string.
+   *
+   * Syntax:
+   *
+   *    format(value)
+   *    format(value, options)
+   *    format(value, precision)
+   *    format(value, fn)
+   *
+   * Where:
+   *
+   *    {*} 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' and
+   *                                          'auto', `precision` defines the total
+   *                                          number of significant digits returned
+   *                                          and is undefined by default.
+   *                                          In case of notation 'fixed',
+   *                                          `precision` defines the number of
+   *                                          significant digits after the decimal
+   *                                          point, and is 0 by default.
+   *                     {Object} exponential An object containing two parameters,
+   *                                          {Number} lower and {Number} upper,
+   *                                          used by notation 'auto' to determine
+   *                                          when to return exponential notation.
+   *                                          Default values are `lower=1e-3` and
+   *                                          `upper=1e5`.
+   *                                          Only applicable for notation `auto`.
+   *    {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'
+   *
+   * @param {*} value             Value to be stringified
+   * @param {Object | Function | Number} [options]
+   * @return {String} str The formatted value
+   */
+  math.format = function format (value, options) {
+    var num = arguments.length;
+    if (num !== 1 && num !== 2) {
+      throw new math.error.ArgumentsError('format', num, 1, 2);
+    }
+
+    return string.format(value, options);
+  };
+};
+
+},{"../../util/string":215}],196:[function(require,module,exports){
+module.exports = function (math) {
+  var util = require('../../util/index'),
+
+      Complex = require('../../type/Complex'),
+      Unit = require('../../type/Unit'),
+
+      isNumber = util.number.isNumber,
+      isString = util.string.isString,
+      isComplex = Complex.isComplex,
+      isUnit = Unit.isUnit;
+
+  /**
+   * Import functions from an object or a file
+   * @param {function | String | Object} object
+   * @param {Object} [options]        Available options:
+   *                                  {Boolean} override
+   *                                      If true, existing functions will be
+   *                                      overwritten. False by default.
+   *                                  {Boolean} wrap
+   *                                      If true (default), 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 the math.js data types.
+   */
+// TODO: return status information
+  math['import'] = function math_import(object, options) {
+    var name;
+    var opts = {
+      override: false,
+      wrap: true
+    };
+    if (options && options instanceof Object) {
+      util.object.extend(opts, options);
+    }
+
+    if (isString(object)) {
+      // a string with a filename
+      if (typeof (require) !== 'undefined') {
+        // load the file using require
+        var _module = require(object);
+        math_import(_module);
+      }
+      else {
+        throw new Error('Cannot load file: require not available.');
+      }
+    }
+    else if (isSupportedType(object)) {
+      // a single function
+      name = object.name;
+      if (name) {
+        if (opts.override || math[name] === undefined) {
+          _import(name, object, opts);
+        }
+      }
+      else {
+        throw new Error('Cannot import an unnamed function or object');
+      }
+    }
+    else if (object instanceof Object) {
+      // a map with functions
+      for (name in object) {
+        if (object.hasOwnProperty(name)) {
+          var value = object[name];
+          if (isSupportedType(value)) {
+            _import(name, value, opts);
+          }
+          else {
+            math_import(value);
+          }
+        }
+      }
+    }
+  };
+
+  /**
+   * 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) {
+    if (options.override || math[name] === undefined) {
+      // add to math namespace
+      if (options.wrap && typeof value === 'function') {
+        // create a wrapper around the function
+        math[name] = function () {
+          var args = [];
+          for (var i = 0, len = arguments.length; i < len; i++) {
+            args[i] = arguments[i].valueOf();
+          }
+          return value.apply(math, args);
+        };
+      }
+      else {
+        // just create a link to the function or value
+        math[name] = value;
+      }
+
+      // create a proxy for the Selector
+      math.chaining.Selector.createProxy(name, value);
+    }
+  }
+
+  /**
+   * Check whether given object is a supported type
+   * @param object
+   * @return {Boolean}
+   * @private
+   */
+  function isSupportedType(object) {
+    return (typeof object == 'function') ||
+        isNumber(object) || isString(object) ||
+        isComplex(object) || isUnit(object);
+    // TODO: add boolean?
+  }
+};
+
+},{"../../type/Complex":202,"../../type/Unit":207,"../../util/index":212}],197:[function(require,module,exports){
+module.exports = function (math) {
+  var isMatrix = require('../../type/Matrix').isMatrix;
+
+  /**
+   * Create a new matrix or array with the results of the callback function executed on
+   * each entry of the matrix/array.
+   * @param {Matrix/array} x      The container to iterate on.
+   * @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.
+   * @return {Matrix/array} container
+   */
+  math.map = function (x, callback) {
+    if (arguments.length != 2) {
+      throw new math.error.ArgumentsError('map', arguments.length, 2);
+    }
+
+    if (Array.isArray(x)) {
+      return _mapArray(x, callback);
+    } else if (isMatrix(x)) {
+      return x.map(callback);
+    } else {
+      throw new math.error.UnsupportedTypeError('map', x);
+    }
+  };
+
+  function _mapArray (arrayIn, callback) {
+    var index = [];
+    var recurse = function (value, dim) {
+      if (Array.isArray(value)) {
+        return value.map(function (child, i) {
+          index[dim] = i;
+          return recurse(child, dim + 1);
+        });
+      }
+      else {
+        return callback(value, index, arrayIn);
+      }
+    };
+
+    return recurse(arrayIn, 0);
+  };
+};
+
+},{"../../type/Matrix":205}],198:[function(require,module,exports){
+module.exports = function (math) {
+  var string = require('../../util/string'),
+
+      isString = string.isString;
+
+  /**
+   * Interpolate values into a string template.
+   *     math.print(template, values)
+   *     math.print(template, values, precision)
+   *
+   * Example usage:
+   *
+   *     // the following outputs: 'The value of pi is 3.141592654'
+   *     math.format('The value of pi is $pi', {pi: math.pi}, 10);
+   *
+   *     // the following outputs: 'hello Mary! The date is 2013-03-23'
+   *     math.format('Hello $user.name! The date is $date', {
+   *       user: {
+   *         name: 'Mary',
+   *       },
+   *       date: new Date().toISOString().substring(0, 10)
+   *     });
+   *
+   * @param {String} template
+   * @param {Object} values
+   * @param {Number} [precision]  Number of digits to format numbers.
+   *                              If not provided, the value will not be rounded.
+   * @return {String} str
+   */
+  math.print = function print (template, values, precision) {
+    var num = arguments.length;
+    if (num != 2 && num != 3) {
+      throw new math.error.ArgumentsError('print', num, 2, 3);
+    }
+
+    if (!isString(template)) {
+      throw new TypeError('String expected as first parameter in function format');
+    }
+    if (!(values instanceof Object)) {
+      throw new TypeError('Object expected as second parameter in function format');
+    }
+
+    // format values into a string
+    return template.replace(/\$([\w\.]+)/g, function (original, key) {
+          var keys = key.split('.');
+          var value = values[keys.shift()];
+          while (keys.length && value !== undefined) {
+            var k = keys.shift();
+            value = k ? value[k] : value + '.';
+          }
+
+          if (value !== undefined) {
+            if (!isString(value)) {
+              return math.format(value, precision);
+            }
+            else {
+              return value;
+            }
+          }
+
+          return original;
+        }
+    );
+  };
+};
+
+},{"../../util/string":215}],199:[function(require,module,exports){
+module.exports = function (math) {
+  /**
+   * Wrap any value in a Selector, allowing to perform chained operations on
+   * the value.
+   *
+   * All methods available in the math.js library can be called upon the selector,
+   * and then will be evaluated with the value itself as first argument.
+   * The selector can be closed by executing selector.done(), which will return
+   * the final value.
+   *
+   * Example usage:
+   *     math.select(3)
+   *         .add(4)
+   *         .subtract(2)
+   *         .done();     // 5
+   *     math.select( [[1, 2], [3, 4]] )
+   *         .set([1, 1], 8)
+   *         .multiply(3)
+   *         .done();     // [[24, 6], [9, 12]]
+   *
+   * The Selector has a number of special functions:
+   * - done()     Finalize the chained operation and return the selectors value.
+   * - valueOf()  The same as done()
+   * - toString() Executes math.format() onto the selectors value, returning
+   *              a string representation of the value.
+   * - get(...)   Get a subselection of the selectors value. Only applicable when
+   *              the value has a method get, for example when value is a Matrix
+   *              or Array.
+   * - set(...)   Replace a subselection of the selectors value. Only applicable
+   *              when the value has a method get, for example when value is a
+   *              Matrix or Array.
+   *
+   * @param {*} value
+   * @return {math.chaining.Selector} selector
+   */
+  math.select = function select(value) {
+    // TODO: check number of arguments
+    return new math.chaining.Selector(value);
+  };
+};
+
+},{}],200:[function(require,module,exports){
+module.exports = function (math) {
+  var types = require('../../util/types'),
+
+      BigNumber = require('bignumber.js'),
+      Complex = require('../../type/Complex'),
+      Matrix = require('../../type/Matrix'),
+      Unit = require('../../type/Unit'),
+      Index = require('../../type/Index'),
+      Range = require('../../type/Range'),
+      Help = require('../../type/Help');
+
+  /**
+   * Determine the type of a variable
+   *
+   *     typeof(x)
+   *
+   * @param {*} x
+   * @return {String} type  Lower case type, for example 'number', 'string',
+   *                        'array'.
+   */
+  math['typeof'] = function _typeof (x) {
+    if (arguments.length != 1) {
+      throw new math.error.ArgumentsError('typeof', arguments.length, 1);
+    }
+
+    // JavaScript types
+    var type = types.type(x);
+
+    // math.js types
+    if (type === 'object') {
+      if (x instanceof Complex) return 'complex';
+      if (x instanceof BigNumber) return 'bignumber';
+      if (x instanceof Matrix) return 'matrix';
+      if (x instanceof Unit) return 'unit';
+      if (x instanceof Index) return 'index';
+      if (x instanceof Range) return 'range';
+      if (x instanceof Help) return 'matrix';
+
+      if (x instanceof math.chaining.Selector) return 'selector';
+    }
+
+    return type;
+  };
+};
+
+},{"../../type/Complex":202,"../../type/Help":203,"../../type/Index":204,"../../type/Matrix":205,"../../type/Range":206,"../../type/Unit":207,"../../util/types":216,"bignumber.js":217}],201:[function(require,module,exports){
+var object = require('./util/object');
+
+/**
+ * math.js factory function.
+ *
+ * Usage:
+ *
+ *     var math = mathjs();
+ *     var math = mathjs(settings);
+ *
+ * @param {Object} [settings] Available settings:
+ *                            {String} matrix.defaultType
+ *                              A string 'matrix' (default) or 'array'.
+ *                            {String} number.defaultType
+ *                              A string 'number' (default) or 'bignumber'
+ */
+function mathjs (settings) {
+  // create new namespace
+  var math = {};
+
+  // create configuration settings. These are private
+  var _settings = {
+    matrix: {
+      // type of default matrix output. Choose 'matrix' (default) or 'array'
+      'defaultType': 'matrix'
+    },
+    number: {
+      // type of default number output. Choose 'number' (default) or 'bignumber'
+      'defaultType': 'number'
+    }
+  };
+
+  /**
+   * Set configuration settings for math.js, and get current settings
+   * @param {Object} [settings] Available settings:
+   *                            {String} matrix.defaultType
+   *                              A string 'matrix' (default) or 'array'.
+   *                            {String} number.defaultType
+   *                              A string 'number' (default) or 'bignumber'
+   *                            {Number} number.precision
+   *                              The number of digits in BigNumber.
+   *                              Not applicable for Numbers.
+   * @return {Object} settings   The currently applied settings
+   */
+  math.config = function config (settings) {
+    var BigNumber = require('bignumber.js');
+
+    if (settings) {
+      // merge settings
+      object.deepExtend(_settings, settings);
+
+      if (settings.number && settings.number.precision) {
+        BigNumber.config({
+          DECIMAL_PLACES: settings.number.precision
+        });
+      }
+
+      // TODO: remove deprecated setting some day (deprecated since version 0.15.0)
+      if (settings.matrix && settings.matrix.default) {
+        throw new Error('setting matrix.default is deprecated. ' +
+            'Use matrix.defaultType instead.')
+      }
+    }
+
+    // return a clone of the settings
+    var current = object.clone(_settings);
+    current.number.precision = BigNumber.config().DECIMAL_PLACES;
+    return current;
+  };
+
+  // apply provided configuration settings
+  math.config(settings);
+
+  // expression (Parser, Scope, nodes, docs)
+  math.expression = {};
+  math.expression.node = require('./expression/node/index.js');
+  math.expression.Scope = require('./expression/Scope.js');
+  math.expression.Parser = require('./expression/Parser.js');
+  math.expression.docs = require('./expression/docs/index.js');
+
+  // TODO: deprecated since version 0.13.0. cleanup deprecated stuff some day
+  math.expr = {};
+  math.expr.Scope = function () {
+    throw new Error('Moved to math.expression.Scope');
+  };
+  math.expr.Parser = function () {
+    throw new Error('Moved to math.expression.Parser');
+  };
+
+  // types (Matrix, Complex, Unit, ...)
+  math.type = {};
+  math.type.BigNumber = require('bignumber.js');
+  math.type.Complex = require('./type/Complex');
+  math.type.Range = require('./type/Range');
+  math.type.Index = require('./type/Index');
+  math.type.Matrix = require('./type/Matrix');
+  math.type.Unit = require('./type/Unit');
+  math.type.Help = require('./type/Help');
+
+  math.collection = require('./type/collection');
+
+  // error utility functions
+  require('./type/error')(math);
+
+  // expression parser
+  require('./function/expression/eval.js')(math, _settings);
+  require('./function/expression/help.js')(math, _settings);
+  require('./function/expression/parse.js')(math, _settings);
+
+  // functions - arithmetic
+  require('./function/arithmetic/abs.js')(math, _settings);
+  require('./function/arithmetic/add.js')(math, _settings);
+  require('./function/arithmetic/add.js')(math, _settings);
+  require('./function/arithmetic/ceil.js')(math, _settings);
+  require('./function/arithmetic/cube.js')(math, _settings);
+  require('./function/arithmetic/divide.js')(math, _settings);
+  require('./function/arithmetic/edivide.js')(math, _settings);
+  require('./function/arithmetic/emultiply.js')(math, _settings);
+  require('./function/arithmetic/epow.js')(math, _settings);
+  require('./function/arithmetic/equal.js')(math, _settings);
+  require('./function/arithmetic/exp.js')(math, _settings);
+  require('./function/arithmetic/fix.js')(math, _settings);
+  require('./function/arithmetic/floor.js')(math, _settings);
+  require('./function/arithmetic/gcd.js')(math, _settings);
+  require('./function/arithmetic/larger.js')(math, _settings);
+  require('./function/arithmetic/largereq.js')(math, _settings);
+  require('./function/arithmetic/lcm.js')(math, _settings);
+  require('./function/arithmetic/log.js')(math, _settings);
+  require('./function/arithmetic/log10.js')(math, _settings);
+  require('./function/arithmetic/mod.js')(math, _settings);
+  require('./function/arithmetic/multiply.js')(math, _settings);
+  require('./function/arithmetic/pow.js')(math, _settings);
+  require('./function/arithmetic/round.js')(math, _settings);
+  require('./function/arithmetic/sign.js')(math, _settings);
+  require('./function/arithmetic/smaller.js')(math, _settings);
+  require('./function/arithmetic/smallereq.js')(math, _settings);
+  require('./function/arithmetic/sqrt.js')(math, _settings);
+  require('./function/arithmetic/square.js')(math, _settings);
+  require('./function/arithmetic/subtract.js')(math, _settings);
+  require('./function/arithmetic/unary.js')(math, _settings);
+  require('./function/arithmetic/unequal.js')(math, _settings);
+  require('./function/arithmetic/xgcd.js')(math, _settings);
+
+  // functions - complex
+  require('./function/complex/arg.js')(math, _settings);
+  require('./function/complex/conj.js')(math, _settings);
+  require('./function/complex/re.js')(math, _settings);
+  require('./function/complex/im.js')(math, _settings);
+
+  // functions - construction
+  require('./function/construction/bignumber')(math, _settings);
+  require('./function/construction/boolean.js')(math, _settings);
+  require('./function/construction/complex.js')(math, _settings);
+  require('./function/construction/index.js')(math, _settings);
+  require('./function/construction/matrix.js')(math, _settings);
+  require('./function/construction/number.js')(math, _settings);
+  require('./function/construction/parser.js')(math, _settings);
+  require('./function/construction/string.js')(math, _settings);
+  require('./function/construction/unit.js')(math, _settings);
+
+  // functions - matrix
+  require('./function/matrix/concat.js')(math, _settings);
+  require('./function/matrix/det.js')(math, _settings);
+  require('./function/matrix/diag.js')(math, _settings);
+  require('./function/matrix/eye.js')(math, _settings);
+  require('./function/matrix/inv.js')(math, _settings);
+  require('./function/matrix/ones.js')(math, _settings);
+  require('./function/matrix/range.js')(math, _settings);
+  require('./function/matrix/resize.js')(math, _settings);
+  require('./function/matrix/size.js')(math, _settings);
+  require('./function/matrix/squeeze.js')(math, _settings);
+  require('./function/matrix/subset.js')(math, _settings);
+  require('./function/matrix/transpose.js')(math, _settings);
+  require('./function/matrix/zeros.js')(math, _settings);
+
+  // functions - probability
+  require('./function/probability/factorial.js')(math, _settings);
+  require('./function/probability/random.js')(math, _settings);
+
+  // functions - statistics
+  require('./function/statistics/min.js')(math, _settings);
+  require('./function/statistics/max.js')(math, _settings);
+  require('./function/statistics/mean.js')(math, _settings);
+
+  // functions - trigonometry
+  require('./function/trigonometry/acos.js')(math, _settings);
+  require('./function/trigonometry/asin.js')(math, _settings);
+  require('./function/trigonometry/atan.js')(math, _settings);
+  require('./function/trigonometry/atan2.js')(math, _settings);
+  require('./function/trigonometry/cos.js')(math, _settings);
+  require('./function/trigonometry/cot.js')(math, _settings);
+  require('./function/trigonometry/csc.js')(math, _settings);
+  require('./function/trigonometry/sec.js')(math, _settings);
+  require('./function/trigonometry/sin.js')(math, _settings);
+  require('./function/trigonometry/tan.js')(math, _settings);
+
+  // functions - units
+  require('./function/units/in.js')(math, _settings);
+
+  // functions - utils
+  require('./function/utils/clone.js')(math, _settings);
+  require('./function/utils/format.js')(math, _settings);
+  require('./function/utils/import.js')(math, _settings);
+  require('./function/utils/map.js')(math, _settings);
+  require('./function/utils/print.js')(math, _settings);
+  require('./function/utils/select.js')(math, _settings);
+  require('./function/utils/typeof.js')(math, _settings);
+  require('./function/utils/forEach.js')(math, _settings);
+
+  // constants
+  require('./constants.js')(math, _settings);
+
+  // selector (we initialize after all functions are loaded)
+  math.chaining = {};
+  math.chaining.Selector = require('./chaining/Selector.js')(math, _settings);
+
+  // TODO: deprecated since version 0.13.0. Cleanup some day
+  math.expr.Selector = function () {
+    throw new Error('Moved to math.expression.Selector');
+  };
+
+  // return the new instance
+  return math;
+}
+
+
+// return the mathjs factory
+module.exports = mathjs;
+
+// error messages for deprecated static library (deprecated since v0.15.0) TODO: remove some day
+var placeholder = function () {
+  throw new Error('Static function calls are deprecated. Create an instance of math.js:\n\t"var math = require(\'mathjs\')();" on node.js, \n\t"var math = mathjs();" in the browser.');
+};
+var instance = mathjs();
+for (var prop in instance) {
+  if (instance.hasOwnProperty(prop)) {
+    var fn = instance[prop];
+    if (typeof fn === 'function') {
+      mathjs[prop] = placeholder;
+    }
+    else {
+      if (Object.defineProperty) {
+        Object.defineProperty(mathjs, prop, {
+          get: placeholder,
+          set: placeholder,
+          enumerable: true,
+          configurable: false
+        });
+      }
+    }
+  }
+}
+
+if (typeof window !== 'undefined') {
+  window.math = mathjs;
+}
+},{"./chaining/Selector.js":2,"./constants.js":3,"./expression/Parser.js":4,"./expression/Scope.js":5,"./expression/docs/index.js":103,"./expression/node/index.js":116,"./function/arithmetic/abs.js":117,"./function/arithmetic/add.js":118,"./function/arithmetic/ceil.js":119,"./function/arithmetic/cube.js":120,"./function/arithmetic/divide.js":121,"./function/arithmetic/edivide.js":122,"./function/arithmetic/emultiply.js":123,"./function/arithmetic/epow.js":124,"./function/arithmetic/equal.js":125,"./function/arithmetic/exp.js":126,"./function/arithmetic/fix.js":127,"./function/arithmetic/floor.js":128,"./function/arithmetic/gcd.js":129,"./function/arithmetic/larger.js":130,"./function/arithmetic/largereq.js":131,"./function/arithmetic/lcm.js":132,"./function/arithmetic/log.js":133,"./function/arithmetic/log10.js":134,"./function/arithmetic/mod.js":135,"./function/arithmetic/multiply.js":136,"./function/arithmetic/pow.js":137,"./function/arithmetic/round.js":138,"./function/arithmetic/sign.js":139,"./function/arithmetic/smaller.js":140,"./function/arithmetic/smallereq.js":141,"./function/arithmetic/sqrt.js":142,"./function/arithmetic/square.js":143,"./function/arithmetic/subtract.js":144,"./function/arithmetic/unary.js":145,"./function/arithmetic/unequal.js":146,"./function/arithmetic/xgcd.js":147,"./function/complex/arg.js":148,"./function/complex/conj.js":149,"./function/complex/im.js":150,"./function/complex/re.js":151,"./function/construction/bignumber":152,"./function/construction/boolean.js":153,"./function/construction/complex.js":154,"./function/construction/index.js":155,"./function/construction/matrix.js":156,"./function/construction/number.js":157,"./function/construction/parser.js":158,"./function/construction/string.js":159,"./function/construction/unit.js":160,"./function/expression/eval.js":161,"./function/expression/help.js":162,"./function/expression/parse.js":163,"./function/matrix/concat.js":164,"./function/matrix/det.js":165,"./function/matrix/diag.js":166,"./function/matrix/eye.js":167,"./function/matrix/inv.js":168,"./function/matrix/ones.js":169,"./function/matrix/range.js":170,"./function/matrix/resize.js":171,"./function/matrix/size.js":172,"./function/matrix/squeeze.js":173,"./function/matrix/subset.js":174,"./function/matrix/transpose.js":175,"./function/matrix/zeros.js":176,"./function/probability/factorial.js":177,"./function/probability/random.js":178,"./function/statistics/max.js":179,"./function/statistics/mean.js":180,"./function/statistics/min.js":181,"./function/trigonometry/acos.js":182,"./function/trigonometry/asin.js":183,"./function/trigonometry/atan.js":184,"./function/trigonometry/atan2.js":185,"./function/trigonometry/cos.js":186,"./function/trigonometry/cot.js":187,"./function/trigonometry/csc.js":188,"./function/trigonometry/sec.js":189,"./function/trigonometry/sin.js":190,"./function/trigonometry/tan.js":191,"./function/units/in.js":192,"./function/utils/clone.js":193,"./function/utils/forEach.js":194,"./function/utils/format.js":195,"./function/utils/import.js":196,"./function/utils/map.js":197,"./function/utils/print.js":198,"./function/utils/select.js":199,"./function/utils/typeof.js":200,"./type/Complex":202,"./type/Help":203,"./type/Index":204,"./type/Matrix":205,"./type/Range":206,"./type/Unit":207,"./type/collection":208,"./type/error":209,"./util/object":214,"bignumber.js":217}],202:[function(require,module,exports){
+var util = require('../util/index'),
+    number = util.number,
+
+    isNumber = util.number.isNumber,
+    isString = util.string.isString;
+
+/**
+ * @constructor Complex
+ *
+ * A complex value can be constructed in the following ways:
+ *     var a = new Complex();
+ *     var b = new Complex(re, im);
+ *     var c = Complex.parse(str);
+ *
+ * Example usage:
+ *     var a = new Complex(3, -4);      // 3 - 4i
+ *     a.re = 5;                        // a = 5 - 4i
+ *     var i = a.im;                    // -4;
+ *     var b = Complex.parse('2 + 6i'); // 2 + 6i
+ *     var c = new Complex();           // 0 + 0i
+ *     var d = math.add(a, b);          // 5 + 2i
+ *
+ * @param {Number} re       The real part of the complex value
+ * @param {Number} [im]     The imaginary part of the complex value
+ */
+function Complex(re, im) {
+  if (!(this instanceof Complex)) {
+    throw new SyntaxError(
+        'Complex constructor must be called with the new operator');
+  }
+
+  switch (arguments.length) {
+    case 0:
+      this.re = 0;
+      this.im = 0;
+      break;
+
+    case 2:
+      if (!isNumber(re) || !isNumber(im)) {
+        throw new TypeError('Two numbers expected in Complex constructor');
+      }
+      this.re = re;
+      this.im = im;
+      break;
+
+    default:
+      if (arguments.length != 0 && arguments.length != 2) {
+        throw new SyntaxError(
+            'Two or zero arguments expected in Complex constructor');
+      }
+      break;
+  }
+}
+
+/**
+ * Test whether value is a Complex value
+ * @param {*} value
+ * @return {Boolean} isComplex
+ */
+Complex.isComplex = function isComplex(value) {
+  return (value instanceof Complex);
+};
+
+// private variables and functions for the parser
+var text, index, c;
+
+function skipWhitespace() {
+  while (c == ' ' || c == '\t') {
+    next();
+  }
+}
+
+function isDigitDot (c) {
+  return ((c >= '0' && c <= '9') || c == '.');
+}
+
+function isDigit (c) {
+  return ((c >= '0' && c <= '9'));
+}
+
+function next() {
+  index++;
+  c = text.charAt(index);
+}
+
+function revert(oldIndex) {
+  index = oldIndex;
+  c = text.charAt(index);
+}
+
+function parseNumber () {
+  var number = '';
+  var oldIndex;
+  oldIndex = index;
+
+  if (c == '+') {
+    next();
+  }
+  else if (c == '-') {
+    number += c;
+    next();
+  }
+
+  if (!isDigitDot(c)) {
+    // a + or - must be followed by a digit
+    revert(oldIndex);
+    return null;
+  }
+
+  // get number, can have a single dot
+  if (c == '.') {
+    number += c;
+    next();
+    if (!isDigit(c)) {
+      // this is no legal number, it is just a dot
+      revert(oldIndex);
+      return null;
+    }
+  }
+  else {
+    while (isDigit(c)) {
+      number += c;
+      next();
+    }
+    if (c == '.') {
+      number += c;
+      next();
+    }
+  }
+  while (isDigit(c)) {
+    number += c;
+    next();
+  }
+
+  // check for exponential notation like "2.3e-4" or "1.23e50"
+  if (c == 'E' || c == 'e') {
+    number += c;
+    next();
+
+    if (c == '+' || c == '-') {
+      number += c;
+      next();
+    }
+
+    // Scientific notation MUST be followed by an exponent
+    if (!isDigit(c)) {
+      // this is no legal number, exponent is missing.
+      revert(oldIndex);
+      return null;
+    }
+
+    while (isDigit(c)) {
+      number += c;
+      next();
+    }
+  }
+
+  return number;
+}
+
+function parseComplex () {
+  // check for 'i', '-i', '+i'
+  var cnext = text.charAt(index + 1);
+  if (c == 'I' || c == 'i') {
+    next();
+    return '1';
+  }
+  else if ((c == '+' || c == '-') && (cnext == 'I' || cnext == 'i')) {
+    var number = (c == '+') ? '1' : '-1';
+    next();
+    next();
+    return number;
+  }
+
+  return null;
+}
+
+/**
+ * Parse a complex number from a string. For example Complex.parse("2 + 3i")
+ * will return a Complex value where re = 2, im = 3.
+ * Returns null if provided string does not contain a valid complex number.
+ * @param {String} str
+ * @returns {Complex | null} complex
+ */
+Complex.parse = function parse (str) {
+  text = str;
+  index = -1;
+  c = '';
+
+  if (!isString(text)) {
+    return null;
+  }
+
+  next();
+  skipWhitespace();
+  var first = parseNumber();
+  if (first) {
+    if (c == 'I' || c == 'i') {
+      // pure imaginary number
+      next();
+      skipWhitespace();
+      if (c) {
+        // garbage at the end. not good.
+        return null;
+      }
+
+      return new Complex(0, Number(first));
+    }
+    else {
+      // complex and real part
+      skipWhitespace();
+      var separator = c;
+      if (separator != '+' && separator != '-') {
+        // pure real number
+        skipWhitespace();
+        if (c) {
+          // garbage at the end. not good.
+          return null;
+        }
+
+        return new Complex(Number(first), 0);
+      }
+      else {
+        // complex and real part
+        next();
+        skipWhitespace();
+        var second = parseNumber();
+        if (second) {
+          if (c != 'I' && c != 'i') {
+            // 'i' missing at the end of the complex number
+            return null;
+          }
+          next();
+        }
+        else {
+          second = parseComplex();
+          if (!second) {
+            // imaginary number missing after separator
+            return null;
+          }
+        }
+
+        if (separator == '-') {
+          if (second[0] == '-') {
+            second =  '+' + second.substring(1);
+          }
+          else {
+            second = '-' + second;
+          }
+        }
+
+        next();
+        skipWhitespace();
+        if (c) {
+          // garbage at the end. not good.
+          return null;
+        }
+
+        return new Complex(Number(first), Number(second));
+      }
+    }
+  }
+  else {
+    // check for 'i', '-i', '+i'
+    first = parseComplex();
+    if (first) {
+      skipWhitespace();
+      if (c) {
+        // garbage at the end. not good.
+        return null;
+      }
+
+      return new Complex(0, Number(first));
+    }
+  }
+
+  return null;
+};
+
+/**
+ * Create a copy of the complex value
+ * @return {Complex} clone
+ */
+Complex.prototype.clone = function clone () {
+  return new Complex(this.re, this.im);
+};
+
+/**
+ * Test whether this complex number equals an other complex value.
+ * Two complex numbers are equal when both their real and imaginary parts
+ * are equal.
+ * @param {Complex} other
+ * @return {boolean} isEqual
+ */
+Complex.prototype.equals = function equals (other) {
+  return (this.re === other.re) && (this.im === other.im);
+};
+
+/**
+ * Get a string representation of the complex number,
+ * with optional formatting options.
+ * @param {Object | Number | Function} [options]  Formatting options. See
+ *                                                lib/util/number:format for a
+ *                                                description of the available
+ *                                                options.
+ * @return {String} str
+ */
+Complex.prototype.format = function format (options) {
+  var str = '',
+      strRe = number.format(this.re, options),
+      strIm = number.format(this.im, options);
+
+  if (this.im == 0) {
+    // real value
+    str = strRe;
+  }
+  else if (this.re == 0) {
+    // purely complex value
+    if (this.im == 1) {
+      str = 'i';
+    }
+    else if (this.im == -1) {
+      str = '-i';
+    }
+    else {
+      str = strIm + 'i';
+    }
+  }
+  else {
+    // complex value
+    if (this.im > 0) {
+      if (this.im == 1) {
+        str = strRe + ' + i';
+      }
+      else {
+        str = strRe + ' + ' + strIm + 'i';
+      }
+    }
+    else {
+      if (this.im == -1) {
+        str = strRe + ' - i';
+      }
+      else {
+        str = strRe + ' - ' + strIm.substring(1) + 'i';
+      }
+    }
+  }
+
+  return str;
+};
+
+/**
+ * Get a string representation of the complex number.
+ * @return {String} str
+ */
+Complex.prototype.toString = function toString () {
+  return this.format();
+};
+
+// exports
+module.exports = Complex;
+
+// to trick my IDE which doesn't get it
+exports.isComplex = Complex.isComplex;
+exports.parse = Complex.parse;
+
+},{"../util/index":212}],203:[function(require,module,exports){
+var util = require('../util/index'),
+    object = util.object,
+    string = util.string;
+
+/**
+ * Documentation object
+ * @param {Object} math The math.js namespace
+ * @param {Object} doc  Object containing properties:
+ *                      {String} name
+ *                      {String} category
+ *                      {String[]} syntax
+ *                      {String[]} examples
+ *                      {String[]} seealso
+ * @constructor
+ */
+function Help (math, doc) {
+  this.math = math;
+  this.doc = doc;
+}
+
+/**
+ * Test whether a value is an instance of Help
+ * @param {*} value
+ * @return {Boolean} isHelp
+ */
+Help.isHelp = function isHelp (value) {
+  return (value instanceof Help);
+};
+
+/**
+ * Generate readable description from a Help object
+ * @return {String} readableDoc
+ * @private
+ */
+Help.prototype.toString = function () {
+  var doc = this.doc || {};
+  var desc = '\n';
+
+  if (doc.name) {
+    desc += 'Name: ' + doc.name + '\n\n';
+  }
+  if (doc.category) {
+    desc += 'Category: ' + doc.category + '\n\n';
+  }
+  if (doc.description) {
+    desc += 'Description:\n    ' + doc.description + '\n\n';
+  }
+  if (doc.syntax) {
+    desc += 'Syntax:\n    ' + doc.syntax.join('\n    ') + '\n\n';
+  }
+  if (doc.examples) {
+    var parser = this.math.parser();
+    desc += 'Examples:\n';
+    for (var i = 0; i < doc.examples.length; i++) {
+      var expr = doc.examples[i];
+      var res;
+      try {
+        res = parser.eval(expr);
+      }
+      catch (e) {
+        res = e;
+      }
+      desc += '    ' + expr + '\n';
+      if (res && !(res instanceof Help)) {
+        desc += '        ' + string.format(res) + '\n';
+      }
+    }
+    desc += '\n';
+  }
+  if (doc.seealso) {
+    desc += 'See also: ' + doc.seealso.join(', ') + '\n';
+  }
+
+  return desc;
+};
+
+// TODO: implement a toHTML function in Help
+
+/**
+ * Export the help object to JSON
+ */
+Help.prototype.toJSON = function () {
+  return object.extend({}, this.doc);
+};
+
+// exports
+module.exports = Help;
+
+// to trick my IDE which doesn't get it
+exports.isHelp = Help.isHelp;
+
+},{"../util/index":212}],204:[function(require,module,exports){
+var util = require('../util/index'),
+
+    Range = require('./Range'),
+
+    number = util.number,
+
+    isNumber = number.isNumber,
+    isInteger = number.isInteger,
+    isArray = Array.isArray,
+    validateIndex = util.array.validateIndex;
+
+/**
+ * @Constructor Index
+ * Create an index. An Index can store ranges having start, step, and end
+ * for multiple dimensions.
+ * Matrix.get, Matrix.set, and math.subset accept an Index as input.
+ *
+ * Usage:
+ *     var index = new Index(range1, range2, ...);
+ *
+ * Where each range can be any of:
+ *     An array [start, end]
+ *     An array [start, end, step]
+ *     A number
+ *     An instance of Range
+ *
+ * The parameters start, end, and step must be integer numbers.
+ *
+ * @param {...*} ranges
+ */
+function Index(ranges) {
+  if (!(this instanceof Index)) {
+    throw new SyntaxError(
+        'Index constructor must be called with the new operator');
+  }
+
+  this._ranges = [];
+
+  for (var i = 0, ii = arguments.length; i < ii; i++) {
+    var arg = arguments[i];
+
+    if (arg instanceof Range) {
+      this._ranges.push(arg);
+    }
+    else {
+      if (arg) {
+        arg = arg.valueOf();
+      }
+
+      if (isArray(arg)) {
+        this._ranges.push(_createRange(arg));
+      }
+      else if (isNumber(arg)) {
+        this._ranges.push(_createRange([arg, arg + 1]));
+      }
+      // TODO: implement support for wildcard '*'
+      else {
+        throw new TypeError('Range expected as Array, Number, or String');
+      }
+    }
+  }
+}
+
+/**
+ * Parse an argument into a range and validate the range
+ * @param {Array} arg  An array with [start: Number, end: Number] and
+ *                     optional a third element step:Number
+ * @return {Range} range
+ * @private
+ */
+function _createRange(arg) {
+  // TODO: make function _createRange simpler/faster
+
+  // test whether all arguments are integers
+  var num = arg.length;
+  for (var i = 0; i < num; i++) {
+    if (!isNumber(arg[i]) || !isInteger(arg[i])) {
+      throw new TypeError('Index parameters must be integer numbers');
+    }
+  }
+
+  switch (arg.length) {
+    case 2:
+      return new Range(arg[0], arg[1]); // start, end
+    case 3:
+      return new Range(arg[0], arg[1], arg[2]); // start, end, step
+    default:
+      // TODO: improve error message
+      throw new SyntaxError('Wrong number of arguments in Index (2 or 3 expected)');
+  }
+}
+
+/**
+ * Create a clone of the index
+ * @return {Index} clone
+ */
+Index.prototype.clone = function clone () {
+  var index = new Index();
+  index._ranges = util.object.clone(this._ranges);
+  return index;
+};
+
+/**
+ * Test whether an object is an Index
+ * @param {*} object
+ * @return {Boolean} isIndex
+ */
+Index.isIndex = function isIndex(object) {
+  return (object instanceof Index);
+};
+
+/**
+ * Create an index from an array with ranges/numbers
+ * @param {Array.<Array | Number>} ranges
+ * @return {Index} index
+ * @private
+ */
+Index.create = function create(ranges) {
+  var index = new Index();
+  Index.apply(index, ranges);
+  return index;
+};
+
+/**
+ * Retrieve the size of the index, the number of elements for each dimension.
+ * @returns {Number[]} size
+ */
+Index.prototype.size = function size () {
+  var size = [];
+
+  for (var i = 0, ii = this._ranges.length; i < ii; i++) {
+    var range = this._ranges[i];
+
+    size[i] = range.size()[0];
+  }
+
+  return size;
+};
+
+/**
+ * Get the maximum value for each of the indexes ranges.
+ * @returns {Number[]} max
+ */
+Index.prototype.max = function max () {
+  var values = [];
+
+  for (var i = 0, ii = this._ranges.length; i < ii; i++) {
+    var range = this._ranges[i];
+    values[i] = range.max();
+  }
+
+  return values;
+};
+
+/**
+ * Get the minimum value for each of the indexes ranges.
+ * @returns {Number[]} min
+ */
+Index.prototype.min = function min () {
+  var values = [];
+
+  for (var i = 0, ii = this._ranges.length; i < ii; i++) {
+    var range = this._ranges[i];
+
+    values[i] = range.min();
+  }
+
+  return values;
+};
+
+/**
+ * Loop over each of the ranges of the index
+ * @param {function} callback   Called for each range with a Range as first
+ *                              argument, the dimension as second, and the
+ *                              index object as third.
+ */
+Index.prototype.forEach = function forEach(callback) {
+  for (var i = 0, ii = this._ranges.length; i < ii; i++) {
+    callback(this._ranges[i], i, this);
+  }
+};
+
+/**
+ * Retrieve the range for a given dimension number from the index
+ * @param {Number} dim                  Number of the dimension
+ * @returns {Range | undefined} range
+ */
+Index.prototype.range = function range (dim) {
+  return this._ranges[dim];
+};
+
+/**
+ * Test whether this index contains only a single value
+ * @return {boolean} isScalar
+ */
+Index.prototype.isScalar = function isScalar () {
+  var size = this.size();
+
+  for (var i = 0, ii = size.length; i < ii; i++) {
+    if (size[i] !== 1) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+/**
+ * Expand the Index into an array.
+ * For example new Index([0,3], [2,7]) returns [[0,1,2], [2,3,4,5,6]]
+ * @returns {Array} array
+ */
+Index.prototype.toArray = function toArray() {
+  var array = [];
+  for (var i = 0, ii = this._ranges.length; i < ii; i++) {
+    var range = this._ranges[i],
+        row = [],
+        x = range.start,
+        end = range.end,
+        step = range.step;
+
+    if (step > 0) {
+      while (x < end) {
+        row.push(x);
+        x += step;
+      }
+    }
+    else if (step < 0) {
+      while (x > end) {
+        row.push(x);
+        x += step;
+      }
+    }
+
+    array.push(row);
+  }
+
+  return array;
+};
+
+/**
+ * Get the primitive value of the Index, a two dimensional array.
+ * Equivalent to Index.toArray().
+ * @returns {Array} array
+ */
+Index.prototype.valueOf = Index.prototype.toArray;
+
+/**
+ * Get the string representation of the index, for example '[2:6]' or '[0:2:10, 4:7]'
+ * @returns {String} str
+ */
+Index.prototype.toString = function () {
+  var strings = [];
+
+  for (var i = 0, ii = this._ranges.length; i < ii; i++) {
+    var range = this._ranges[i];
+    var str = number.format(range.start);
+    if (range.step != 1) {
+      str += ':' + number.format(range.step);
+    }
+    str += ':' + number.format(range.end);
+    strings.push(str);
+  }
+
+  return '[' + strings.join(',') + ']';
+};
+
+// exports
+module.exports = Index;
+
+// to trick my IDE which doesn't get it
+exports.isIndex = Index.isIndex;
+exports.create = Index.create;
+
+},{"../util/index":212,"./Range":206}],205:[function(require,module,exports){
+var util = require('../util/index'),
+    Index = require('./Index'),
+
+    number = util.number,
+    string = util.string,
+    array = util.array,
+    object = util.object,
+
+    isArray = Array.isArray,
+    validateIndex = array.validateIndex;
+
+/**
+ * @constructor Matrix
+ *
+ * A Matrix is a wrapper around an Array. A matrix can hold a multi dimensional
+ * array. A matrix can be constructed as:
+ *     var matrix = new Matrix(data)
+ *
+ * Matrix contains the functions to resize, get and set values, get the size,
+ * clone the matrix and to convert the matrix to a vector, array, or scalar.
+ * Furthermore, one can iterate over the matrix using map and forEach.
+ * The internal Array of the Matrix can be accessed using the function valueOf.
+ *
+ * Example usage:
+ *     var matrix = new Matrix([[1, 2], [3, 4]);
+ *     matix.size();              // [2, 2]
+ *     matrix.resize([3, 2], 5);
+ *     matrix.valueOf();          // [[1, 2], [3, 4], [5, 5]]
+ *     matrix.subset([1,2])       // 3 (indexes are zero-based)
+ *
+ * @param {Array | Matrix} [data]    A multi dimensional array
+ */
+function Matrix(data) {
+  if (!(this instanceof Matrix)) {
+    throw new SyntaxError(
+        'Matrix constructor must be called with the new operator');
+  }
+
+  if (data instanceof Matrix) {
+    // clone data from a Matrix
+    this._data = data.clone()._data;
+  }
+  else if (isArray(data)) {
+    // use array as is
+    this._data = data;
+  }
+  else if (data != null) {
+    // unsupported type
+    throw new TypeError('Unsupported type of data (' + util.types.type(data) + ')');
+  }
+  else {
+    // nothing provided
+    this._data = [];
+  }
+
+  // verify the size of the array
+  this._size = array.size(this._data);
+}
+
+/**
+ * Test whether an object is a Matrix
+ * @param {*} object
+ * @return {Boolean} isMatrix
+ */
+Matrix.isMatrix = function isMatrix(object) {
+  return (object instanceof Matrix);
+};
+
+/**
+ * Get a subset of the matrix, or replace a subset of the matrix.
+ *
+ * Usage:
+ *     var subset = matrix.subset(index)               // retrieve subset
+ *     var value = matrix.subset(index, replacement)   // replace subset
+ *
+ * @param {Index} index
+ * @param {Array | Matrix | *} [replacement]
+ * @param {*} [defaultValue]        Default value, filled in on new entries when
+ *                                  the matrix is resized. If not provided,
+ *                                  new matrix elements will be left undefined.
+ */
+Matrix.prototype.subset = function subset(index, replacement, defaultValue) {
+  switch (arguments.length) {
+    case 1:
+      return _get(this, index);
+
+    // intentional fall through
+    case 2:
+    case 3:
+      return _set(this, index, replacement, defaultValue);
+
+    default:
+      throw new SyntaxError('Wrong number of arguments');
+  }
+};
+
+/**
+ * Get a single element from the matrix.
+ * @param {Number[]} index   Zero-based index
+ * @return {*} value
+ */
+Matrix.prototype.get = function get(index) {
+  if (!isArray(index)) {
+    throw new Error('Array expected');
+  }
+  if (index.length != this._size.length) {
+    throw new RangeError('Dimension mismatch ' +
+        '(' + index.length + ' != ' + this._size.length + ')');
+  }
+
+  var data = this._data;
+  for (var i = 0, ii = index.length; i < ii; i++) {
+    var index_i = index[i];
+    validateIndex(index_i, data.length);
+    data = data[index_i];
+  }
+
+  return object.clone(data);
+};
+
+/**
+ * Replace a single element in the matrix.
+ * @param {Number[]} index   Zero-based index
+ * @param {*} value
+ * @param {*} [defaultValue]        Default value, filled in on new entries when
+ *                                  the matrix is resized. If not provided,
+ *                                  new matrix elements will be left undefined.
+ * @return {Matrix} self
+ */
+Matrix.prototype.set = function set (index, value, defaultValue) {
+  var i, ii;
+
+  // validate input type and dimensions
+  if (!isArray(index)) {
+    throw new Error('Array expected');
+  }
+  if (index.length < this._size.length) {
+    throw new RangeError('Dimension mismatch ' +
+        '(' + index.length + ' < ' + this._size.length + ')');
+  }
+
+  // enlarge matrix when needed
+  var size = index.map(function (i) {
+    return i + 1;
+  });
+  _fit(this, size, defaultValue);
+
+  // traverse over the dimensions
+  var data = this._data;
+  for (i = 0, ii = index.length - 1; i < ii; i++) {
+    var index_i = index[i];
+    validateIndex(index_i, data.length);
+    data = data[index_i];
+  }
+
+  // set new value
+  index_i = index[index.length - 1];
+  validateIndex(index_i, data.length);
+  data[index_i] = value;
+
+  return this;
+};
+
+/**
+ * Get a submatrix of this matrix
+ * @param {Matrix} matrix
+ * @param {Index} index   Zero-based index
+ * @private
+ */
+function _get (matrix, index) {
+  if (!(index instanceof Index)) {
+    throw new TypeError('Invalid index');
+  }
+
+  var isScalar = index.isScalar();
+  if (isScalar) {
+    // return a scalar
+    return matrix.get(index.min());
+  }
+  else {
+    // validate dimensions
+    var size = index.size();
+    if (size.length != matrix._size.length) {
+      throw new RangeError('Dimension mismatch ' +
+          '(' + size.length + ' != ' + matrix._size.length + ')');
+    }
+
+    // retrieve submatrix
+    var submatrix = new Matrix(_getSubmatrix(matrix._data, index, size.length, 0));
+    // TODO: more efficient when creating an empty matrix and setting _data and _size manually
+
+    // squeeze matrix output
+    while (isArray(submatrix._data) && submatrix._data.length == 1) {
+      submatrix._data = submatrix._data[0];
+      submatrix._size.shift();
+    }
+
+    return submatrix;
+  }
+}
+
+/**
+ * Recursively get a submatrix of a multi dimensional matrix.
+ * Index is not checked for correct number of dimensions.
+ * @param {Array} data
+ * @param {Index} index
+ * @param {number} dims   Total number of dimensions
+ * @param {number} dim    Current dimension
+ * @return {Array} submatrix
+ * @private
+ */
+function _getSubmatrix (data, index, dims, dim) {
+  var last = (dim == dims - 1);
+  var range = index.range(dim);
+
+  if (last) {
+    return range.map(function (i) {
+      validateIndex(i, data.length);
+      return data[i];
+    });
+  }
+  else {
+    return range.map(function (i) {
+      validateIndex(i, data.length);
+      var child = data[i];
+      return _getSubmatrix(child, index, dims, dim + 1);
+    });
+  }
+}
+
+/**
+ * Replace a submatrix in this matrix
+ * Indexes are zero-based.
+ * @param {Matrix} matrix
+ * @param {Index} index
+ * @param {Matrix | Array | *} submatrix
+ * @param {*} [defaultValue]        Default value, filled in on new entries when
+ *                                  the matrix is resized. If not provided,
+ *                                  new matrix elements will be left undefined.
+ * @return {Matrix} matrix
+ * @private
+ */
+function _set (matrix, index, submatrix, defaultValue) {
+  if (!(index instanceof Index)) {
+    throw new TypeError('Invalid index');
+  }
+
+  // get index size and check whether the index contains a single value
+  var iSize = index.size(),
+      isScalar = index.isScalar();
+
+  // calculate the size of the submatrix, and convert it into an Array if needed
+  var sSize;
+  if (submatrix instanceof Matrix) {
+    sSize = submatrix.size();
+    submatrix = submatrix.valueOf();
+  }
+  else {
+    sSize = array.size(submatrix);
+  }
+
+  if (isScalar) {
+    // set a scalar
+
+    // check whether submatrix is a scalar
+    if (sSize.length != 0) {
+      throw new TypeError('Scalar value expected');
+    }
+
+    matrix.set(index.min(), submatrix, defaultValue);
+  }
+  else {
+    // set a submatrix
+
+    // validate dimensions
+    if (iSize.length < matrix._size.length) {
+      throw new RangeError('Dimension mismatch ' +
+          '(' + iSize.length + ' < ' + matrix._size.length + ')');
+    }
+
+    // unsqueeze the submatrix when needed
+    for (var i = 0, ii = iSize.length - sSize.length; i < ii; i++) {
+      submatrix = [submatrix];
+      sSize.unshift(1);
+    }
+
+    // check whether the size of the submatrix matches the index size
+    if (!object.deepEqual(iSize, sSize)) {
+      throw new RangeError('Dimensions mismatch ' +
+          '(' + string.format(iSize) + ' != '+ string.format(sSize) + ')');
+    }
+
+    // enlarge matrix when needed
+    var size = index.max().map(function (i) {
+      return i + 1;
+    });
+    _fit(matrix, size, defaultValue);
+
+    // insert the sub matrix
+    var dims = iSize.length,
+        dim = 0;
+    _setSubmatrix (matrix._data, index, submatrix, dims, dim);
+  }
+
+  return matrix;
+}
+
+/**
+ * Replace a submatrix of a multi dimensional matrix.
+ * @param {Array} data
+ * @param {Index} index
+ * @param {Array} submatrix
+ * @param {number} dims   Total number of dimensions
+ * @param {number} dim
+ * @private
+ */
+function _setSubmatrix (data, index, submatrix, dims, dim) {
+  var last = (dim == dims - 1),
+      range = index.range(dim);
+
+  if (last) {
+    range.forEach(function (dataIndex, subIndex) {
+      validateIndex(dataIndex);
+      data[dataIndex] = submatrix[subIndex];
+    });
+  }
+  else {
+    range.forEach(function (dataIndex, subIndex) {
+      validateIndex(dataIndex);
+      _setSubmatrix(data[dataIndex], index, submatrix[subIndex], dims, dim + 1);
+    });
+  }
+}
+
+/**
+ * Resize the matrix
+ * @param {Number[]} size
+ * @param {*} [defaultValue]        Default value, filled in on new entries.
+ *                                  If not provided, the matrix elements will
+ *                                  be left undefined.
+ * @return {Matrix} self            The matrix itself is returned
+ */
+Matrix.prototype.resize = function resize(size, defaultValue) {
+  this._size = object.clone(size);
+  this._data = array.resize(this._data, this._size, defaultValue);
+
+  // return the matrix itself
+  return this;
+};
+
+/**
+ * Enlarge the matrix when it is smaller than given size.
+ * If the matrix is larger or equal sized, nothing is done.
+ * @param {Matrix} matrix           The matrix to be resized
+ * @param {Number[]} size
+ * @param {*} [defaultValue]        Default value, filled in on new entries.
+ *                                  If not provided, the matrix elements will
+ *                                  be left undefined.
+ * @private
+ */
+function _fit(matrix, size, defaultValue) {
+  if (!isArray(size)) {
+    throw new Error('Array expected');
+  }
+
+  var newSize = object.clone(matrix._size),
+      changed = false;
+
+  // add dimensions when needed
+  while (newSize.length < size.length) {
+    newSize.unshift(0);
+    changed = true;
+  }
+
+  // enlarge size when needed
+  for (var i = 0, ii = size.length; i < ii; i++) {
+    if (size[i] > newSize[i]) {
+      newSize[i] = size[i];
+      changed = true;
+    }
+  }
+
+  if (changed) {
+    // resize only when size is changed
+    matrix.resize(newSize, defaultValue);
+  }
+}
+
+/**
+ * Create a clone of the matrix
+ * @return {Matrix} clone
+ */
+Matrix.prototype.clone = function clone() {
+  var matrix = new Matrix();
+  matrix._data = object.clone(this._data);
+  matrix._size = object.clone(this._size);
+  return matrix;
+};
+
+/**
+ * Retrieve the size of the matrix.
+ * @returns {Number[]} size
+ */
+Matrix.prototype.size = function size() {
+  return this._size;
+};
+
+/**
+ * Create a new matrix with the results of the callback function executed on
+ * each entry of the matrix.
+ * @param {function} callback   The callback function is invoked with three
+ *                              parameters: the value of the element, the index
+ *                              of the element, and the Matrix being traversed.
+ * @return {Matrix} matrix
+ */
+Matrix.prototype.map = function map(callback) {
+  var me = this;
+  var matrix = new Matrix();
+  var index = [];
+  var recurse = function (value, dim) {
+    if (isArray(value)) {
+      return value.map(function (child, i) {
+        index[dim] = i;
+        return recurse(child, dim + 1);
+      });
+    }
+    else {
+      return callback(value, index, me);
+    }
+  };
+  matrix._data = recurse(this._data, 0);
+  matrix._size = object.clone(this._size);
+
+  return matrix;
+};
+
+/**
+ * Execute a callback function on each entry of the matrix.
+ * @param {function} callback   The callback function is invoked with three
+ *                              parameters: the value of the element, the index
+ *                              of the element, and the Matrix being traversed.
+ */
+Matrix.prototype.forEach = function forEach(callback) {
+  var me = this;
+  var index = [];
+  var recurse = function (value, dim) {
+    if (isArray(value)) {
+      value.forEach(function (child, i) {
+        index[dim] = i;
+        recurse(child, dim + 1);
+      });
+    }
+    else {
+      callback(value, index, me);
+    }
+  };
+  recurse(this._data, 0);
+};
+
+/**
+ * Create an Array with a copy of the data of the Matrix
+ * @returns {Array} array
+ */
+Matrix.prototype.toArray = function toArray() {
+  return object.clone(this._data);
+};
+
+/**
+ * Get the primitive value of the Matrix: a multidimensional array
+ * @returns {Array} array
+ */
+Matrix.prototype.valueOf = function valueOf() {
+  return this._data;
+};
+
+/**
+ * Get a string representation of the matrix, with optional formatting options.
+ * @param {Object | Number | Function} [options]  Formatting options. See
+ *                                                lib/util/number:format for a
+ *                                                description of the available
+ *                                                options.
+ * @returns {String} str
+ */
+Matrix.prototype.format = function format(options) {
+  return string.format(this._data, options);
+};
+
+/**
+ * Get a string representation of the matrix
+ * @returns {String} str
+ */
+Matrix.prototype.toString = function toString() {
+  return string.format(this._data);
+};
+
+// exports
+module.exports = Matrix;
+
+// to trick my IDE which doesn't get it
+exports.isMatrix = Matrix.isMatrix;
+
+},{"../util/index":212,"./Index":204}],206:[function(require,module,exports){
+var util = require('../util/index'),
+
+    number = util.number,
+    string = util.string,
+    array = util.array;
+
+/**
+ * @constructor Range
+ * 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:
+ *     var range = new Range(start, end);
+ *     var 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:
+ *     var c = new Range(2, 6);         // 2:1:5
+ *     c.toArray();                     // [2, 3, 4, 5]
+ *     var d = new Range(2, -3, -1);    // 2:-1:-2
+ *     d.toArray();                     // [2, 1, 0, -1, -2]
+ *
+ * @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(
+        'Range constructor must be called with the new operator');
+  }
+
+  if (start != null && !number.isNumber(start)) {
+    throw new TypeError('Parameter start must be a number');
+  }
+  if (end != null && !number.isNumber(end)) {
+    throw new TypeError('Parameter end must be a number');
+  }
+  if (step != null && !number.isNumber(step)) {
+    throw new TypeError('Parameter step must be a number');
+  }
+
+  this.start = (start != null) ? parseFloat(start) : 0;
+  this.end   = (end != null) ? parseFloat(end) : 0;
+  this.step  = (step != null) ? parseFloat(step) : 1;
+}
+
+/**
+ * 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'.
+ * @param {String} str
+ * @return {Range | null} range
+ */
+Range.parse = function parse (str) {
+  if (!string.isString(str)) {
+    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 clone() {
+  return new Range(this.start, this.end, this.step);
+};
+
+/**
+ * Test whether an object is a Range
+ * @param {*} object
+ * @return {Boolean} isRange
+ */
+Range.isRange = function isRange(object) {
+  return (object instanceof Range);
+};
+
+/**
+ * Retrieve the size of the range.
+ * Returns an array containing one number, the number of elements in the range.
+ * @returns {Number[]} size
+ */
+Range.prototype.size = function size() {
+  var len = 0,
+      start = this.start,
+      step = this.step,
+      end = this.end,
+      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
+ * @return {Number | undefined} min
+ */
+Range.prototype.min = function min () {
+  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
+ * @return {Number | undefined} max
+ */
+Range.prototype.max = function max () {
+  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.
+ * @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.
+ */
+Range.prototype.forEach = function forEach(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
+ * @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 map(callback) {
+  var array = [];
+  this.forEach(function (value, index, obj) {
+    array[index] = callback(value, index, obj);
+  });
+  return array;
+};
+
+/**
+ * Create an Array with a copy of the Ranges data
+ * @returns {Array} array
+ */
+Range.prototype.toArray = function toArray() {
+  var array = [];
+  this.forEach(function (value, index) {
+    array[index] = value;
+  });
+  return array;
+};
+
+/**
+ * Get the primitive value of the Range, a one dimensional array
+ * @returns {Array} array
+ */
+Range.prototype.valueOf = function valueOf() {
+  // 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'
+ * @param {Object | Number | Function} [options]  Formatting options. See
+ *                                                lib/util/number:format for a
+ *                                                description of the available
+ *                                                options.
+ * @returns {String} str
+ */
+Range.prototype.format = function format(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.
+ * @returns {String}
+ */
+Range.prototype.toString = function toString() {
+  return this.format();
+};
+
+// exports
+module.exports = Range;
+
+// to trick my IDE which doesn't get it
+exports.isRange = Range.isRange;
+exports.parse = Range.parse;
+
+},{"../util/index":212}],207:[function(require,module,exports){
+var util = require('../util/index'),
+
+    number = util.number,
+    string = util.string,
+    isNumber = util.number.isNumber,
+    isString = util.string.isString;
+
+/**
+ * @constructor Unit
+ *
+ * A unit can be constructed in the following ways:
+ *     var a = new Unit(value, unit);
+ *     var b = new Unit(null, unit);
+ *     var c = Unit.parse(str);
+ *
+ * Example usage:
+ *     var a = new Unit(5, 'cm');               // 50 mm
+ *     var b = Unit.parse('23 kg');             // 23 kg
+ *     var c = math.in(a, new Unit(null, 'm');  // 0.05 m
+ *
+ * @param {Number} [value]  A value like 5.2
+ * @param {String} [unit]   A unit like "cm" or "inch"
+ */
+function Unit(value, unit) {
+  if (!(this instanceof Unit)) {
+    throw new Error('Unit constructor must be called with the new operator');
+  }
+
+  if (value != null && !isNumber(value)) {
+    throw new TypeError('First parameter in Unit constructor must be a number');
+  }
+  if (unit != null && !isString(unit)) {
+    throw new TypeError('Second parameter in Unit constructor must be a string');
+  }
+
+  if (unit != null) {
+    // find the unit and prefix from the string
+    var res = _findUnit(unit);
+    if (!res) {
+      throw new SyntaxError('String "' + unit + '" is no unit');
+    }
+    this.unit = res.unit;
+    this.prefix = res.prefix;
+  }
+  else {
+    this.unit = UNIT_NONE;
+    this.prefix = PREFIX_NONE;  // link to a list with supported prefixes
+  }
+
+  if (value != null) {
+    this.value = this._normalize(value);
+    this.fixPrefix = false;  // is set true by the methods Unit.in and math.in
+  }
+  else {
+    this.value = null;
+    this.fixPrefix = true;
+  }
+}
+
+// private variables and functions for the Unit parser
+var text, index, c;
+
+function skipWhitespace() {
+  while (c == ' ' || c == '\t') {
+    next();
+  }
+}
+
+function isDigitDot (c) {
+  return ((c >= '0' && c <= '9') || c == '.');
+}
+
+function isDigit (c) {
+  return ((c >= '0' && c <= '9'));
+}
+
+function next() {
+  index++;
+  c = text.charAt(index);
+}
+
+function revert(oldIndex) {
+  index = oldIndex;
+  c = text.charAt(index);
+}
+
+function parseNumber () {
+  var number = '';
+  var oldIndex;
+  oldIndex = index;
+
+  if (c == '+') {
+    next();
+  }
+  else if (c == '-') {
+    number += c;
+    next();
+  }
+
+  if (!isDigitDot(c)) {
+    // a + or - must be followed by a digit
+    revert(oldIndex);
+    return null;
+  }
+
+  // get number, can have a single dot
+  if (c == '.') {
+    number += c;
+    next();
+    if (!isDigit(c)) {
+      // this is no legal number, it is just a dot
+      revert(oldIndex);
+      return null;
+    }
+  }
+  else {
+    while (isDigit(c)) {
+      number += c;
+      next();
+    }
+    if (c == '.') {
+      number += c;
+      next();
+    }
+  }
+  while (isDigit(c)) {
+    number += c;
+    next();
+  }
+
+  // check for exponential notation like "2.3e-4" or "1.23e50"
+  if (c == 'E' || c == 'e') {
+    number += c;
+    next();
+
+    if (c == '+' || c == '-') {
+      number += c;
+      next();
+    }
+
+    // Scientific notation MUST be followed by an exponent
+    if (!isDigit(c)) {
+      // this is no legal number, exponent is missing.
+      revert(oldIndex);
+      return null;
+    }
+
+    while (isDigit(c)) {
+      number += c;
+      next();
+    }
+  }
+
+  return number;
+}
+
+function parseUnit() {
+  var unit = '';
+
+  skipWhitespace();
+  while (c && c != ' ' && c != '\t') {
+    unit += c;
+    next();
+  }
+
+  return unit || null;
+}
+
+/**
+ * Parse a string into a unit. Returns null if the provided string does not
+ * contain a valid unit.
+ * @param {String} str        A string like "5.2 inch", "4e2 kg"
+ * @return {Unit | null} unit
+ */
+Unit.parse = function parse(str) {
+  text = str;
+  index = -1;
+  c = '';
+
+  if (!isString(text)) {
+    return null;
+  }
+
+  next();
+  skipWhitespace();
+  var value = parseNumber();
+  var unit;
+  if (value) {
+    unit = parseUnit();
+
+    next();
+    skipWhitespace();
+    if (c) {
+      // garbage at the end. not good.
+      return null;
+    }
+
+    if (value && unit) {
+      return new Unit(Number(value), unit);
+    }
+  }
+  else {
+    unit = parseUnit();
+
+    next();
+    skipWhitespace();
+    if (c) {
+      // garbage at the end. not good.
+      return null;
+    }
+
+    return new Unit(null, unit)
+  }
+
+  return null;
+};
+
+/**
+ * Test whether value is of type Unit
+ * @param {*} value
+ * @return {Boolean} isUnit
+ */
+Unit.isUnit = function isUnit(value) {
+  return (value instanceof Unit);
+};
+
+/**
+ * create a copy of this unit
+ * @return {Unit} clone
+ */
+Unit.prototype.clone = function () {
+  var clone = new Unit();
+
+  for (var p in this) {
+    if (this.hasOwnProperty(p)) {
+      clone[p] = this[p];
+    }
+  }
+
+  return clone;
+};
+
+/**
+ * Normalize a value, based on its currently set unit
+ * @param {Number} value
+ * @return {Number} normalized value
+ * @private
+ */
+Unit.prototype._normalize = function(value) {
+  return (value + this.unit.offset) *
+      this.unit.value * this.prefix.value;
+};
+
+/**
+ * Unnormalize a value, based on its currently set unit
+ * @param {Number} value
+ * @param {Number} [prefixValue]    Optional prefix value to be used
+ * @return {Number} unnormalized value
+ * @private
+ */
+Unit.prototype._unnormalize = function (value, prefixValue) {
+  if (prefixValue == undefined) {
+    return value / this.unit.value / this.prefix.value -
+        this.unit.offset;
+  }
+  else {
+    return value / this.unit.value / prefixValue -
+        this.unit.offset;
+  }
+};
+
+/**
+ * Find a unit from a string
+ * @param {String} str              A string like 'cm' or 'inch'
+ * @returns {Object | null} result  When found, an object with fields unit and
+ *                                  prefix is returned. Else, null is returned.
+ * @private
+ */
+function _findUnit(str) {
+  for (var i = 0, iMax = UNITS.length; i < iMax; i++) {
+    var UNIT = UNITS[i];
+
+    if (string.endsWith(str, UNIT.name) ) {
+      var prefixLen = (str.length - UNIT.name.length);
+      var prefixName = str.substring(0, prefixLen);
+      var prefix = UNIT.prefixes[prefixName];
+      if (prefix !== undefined) {
+        // store unit, prefix, and value
+        return {
+          unit: UNIT,
+          prefix: prefix
+        };
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Test if the given expression is a unit.
+ * The unit can have a prefix but cannot have a value.
+ * @param {String} unit   A plain unit without value. Can have prefix, like "cm"
+ * @return {Boolean}      true if the given string is a unit
+ */
+Unit.isPlainUnit = function (unit) {
+  return (_findUnit(unit) != null);
+};
+
+/**
+ * check if this unit has given base unit
+ * @param {BASE_UNITS | undefined} base
+ */
+Unit.prototype.hasBase = function(base) {
+  if (this.unit.base === undefined) {
+    return (base === undefined);
+  }
+  return (this.unit.base === base);
+};
+
+/**
+ * Check if this unit has a base equal to another base
+ * @param {Unit} other
+ * @return {Boolean} true if equal base
+ */
+Unit.prototype.equalBase = function(other) {
+  return (this.unit.base === other.unit.base);
+};
+
+/**
+ * Check if this unit equals another unit
+ * @param {Unit} other
+ * @return {Boolean} true if both units are equal
+ */
+Unit.prototype.equals = function(other) {
+  return (this.equalBase(other) && this.value == other.value);
+};
+
+/**
+ * Create a clone of this unit with a representation
+ * @param {String | Unit} plainUnit   A plain unit, without value. Can have prefix, like "cm"
+ * @returns {Unit} unit having fixed, specified unit
+ */
+Unit.prototype['in'] = function (plainUnit) {
+  var other;
+  if (isString(plainUnit)) {
+    other = new Unit(null, plainUnit);
+
+    if (!this.equalBase(other)) {
+      throw new Error('Units do not match');
+    }
+
+    other.value = this.value;
+    return other;
+  }
+  else if (plainUnit instanceof Unit) {
+    if (!this.equalBase(plainUnit)) {
+      throw new Error('Units do not match');
+    }
+    if (plainUnit.value != null) {
+      throw new Error('Cannot convert to a unit with a value');
+    }
+    if (plainUnit.unit == null) {
+      throw new Error('Unit expected on the right hand side of function in');
+    }
+
+    other = plainUnit.clone();
+    other.value = this.value;
+    other.fixPrefix = true;
+    return other;
+  }
+  else {
+    throw new Error('String or Unit expected as parameter');
+  }
+};
+
+/**
+ * Return the value of the unit when represented with given plain unit
+ * @param {String | Unit} plainUnit    For example 'cm' or 'inch'
+ * @return {Number} value
+ */
+Unit.prototype.toNumber = function (plainUnit) {
+  var other = this['in'](plainUnit);
+  var prefix = this.fixPrefix ? other._bestPrefix() : other.prefix;
+  return other._unnormalize(other.value, prefix.value);
+};
+
+
+/**
+ * Get a string representation of the unit.
+ * @return {String}
+ */
+Unit.prototype.toString = function toString() {
+  return this.format();
+};
+
+/**
+ * Get a string representation of the Unit, with optional formatting options.
+ * @param {Object | Number | Function} [options]  Formatting options. See
+ *                                                lib/util/number:format for a
+ *                                                description of the available
+ *                                                options.
+ * @return {String}
+ */
+Unit.prototype.format = function format(options) {
+  var value,
+      str;
+
+  if (!this.fixPrefix) {
+    var bestPrefix = this._bestPrefix();
+    value = this._unnormalize(this.value, bestPrefix.value);
+    str = (this.value != null) ? number.format(value, options) + ' ' : '';
+    str += bestPrefix.name + this.unit.name;
+  }
+  else {
+    value = this._unnormalize(this.value);
+    str = (this.value != null) ? number.format(value, options) + ' ' : '';
+    str += this.prefix.name + this.unit.name;
+  }
+  return str;
+};
+
+/**
+ * Calculate the best prefix using current value.
+ * @returns {Object} prefix
+ * @private
+ */
+Unit.prototype._bestPrefix = function () {
+  // find the best prefix value (resulting in the value of which
+  // the absolute value of the log10 is closest to zero,
+  // though with a little offset of 1.2 for nicer values: you get a
+  // sequence 1mm 100mm 500mm 0.6m 1m 10m 100m 500m 0.6km 1km ...
+  var absValue = Math.abs(this.value / this.unit.value);
+  var bestPrefix = PREFIX_NONE;
+  var bestDiff = Math.abs(
+      Math.log(absValue / bestPrefix.value) / Math.LN10 - 1.2);
+
+  var prefixes = this.unit.prefixes;
+  for (var p in prefixes) {
+    if (prefixes.hasOwnProperty(p)) {
+      var prefix = prefixes[p];
+      if (prefix.scientific) {
+        var diff = Math.abs(
+            Math.log(absValue / prefix.value) / Math.LN10 - 1.2);
+
+        if (diff < bestDiff) {
+          bestPrefix = prefix;
+          bestDiff = diff;
+        }
+      }
+    }
+  }
+
+  return bestPrefix;
+};
+
+var PREFIXES = {
+  'NONE': {
+    '': {'name': '', 'value': 1, 'scientific': true}
+  },
+  'SHORT': {
+    '': {'name': '', 'value': 1, 'scientific': true},
+
+    'da': {'name': 'da', 'value': 1e1, 'scientific': false},
+    'h': {'name': 'h', 'value': 1e2, 'scientific': false},
+    'k': {'name': 'k', 'value': 1e3, 'scientific': true},
+    'M': {'name': 'M', 'value': 1e6, 'scientific': true},
+    'G': {'name': 'G', 'value': 1e9, 'scientific': true},
+    'T': {'name': 'T', 'value': 1e12, 'scientific': true},
+    'P': {'name': 'P', 'value': 1e15, 'scientific': true},
+    'E': {'name': 'E', 'value': 1e18, 'scientific': true},
+    'Z': {'name': 'Z', 'value': 1e21, 'scientific': true},
+    'Y': {'name': 'Y', 'value': 1e24, 'scientific': true},
+
+    'd': {'name': 'd', 'value': 1e-1, 'scientific': false},
+    'c': {'name': 'c', 'value': 1e-2, 'scientific': false},
+    'm': {'name': 'm', 'value': 1e-3, 'scientific': true},
+    // 'µ': {'name': 'µ', 'value': 1e-6, 'scientific': true},
+    'u': {'name': 'u', 'value': 1e-6, 'scientific': true},
+    'n': {'name': 'n', 'value': 1e-9, 'scientific': true},
+    'p': {'name': 'p', 'value': 1e-12, 'scientific': true},
+    'f': {'name': 'f', 'value': 1e-15, 'scientific': true},
+    'a': {'name': 'a', 'value': 1e-18, 'scientific': true},
+    'z': {'name': 'z', 'value': 1e-21, 'scientific': true},
+    'y': {'name': 'y', 'value': 1e-24, 'scientific': true}
+  },
+  'LONG': {
+    '': {'name': '', 'value': 1, 'scientific': true},
+
+    'deca': {'name': 'deca', 'value': 1e1, 'scientific': false},
+    'hecto': {'name': 'hecto', 'value': 1e2, 'scientific': false},
+    'kilo': {'name': 'kilo', 'value': 1e3, 'scientific': true},
+    'mega': {'name': 'mega', 'value': 1e6, 'scientific': true},
+    'giga': {'name': 'giga', 'value': 1e9, 'scientific': true},
+    'tera': {'name': 'tera', 'value': 1e12, 'scientific': true},
+    'peta': {'name': 'peta', 'value': 1e15, 'scientific': true},
+    'exa': {'name': 'exa', 'value': 1e18, 'scientific': true},
+    'zetta': {'name': 'zetta', 'value': 1e21, 'scientific': true},
+    'yotta': {'name': 'yotta', 'value': 1e24, 'scientific': true},
+
+    'deci': {'name': 'deci', 'value': 1e-1, 'scientific': false},
+    'centi': {'name': 'centi', 'value': 1e-2, 'scientific': false},
+    'milli': {'name': 'milli', 'value': 1e-3, 'scientific': true},
+    'micro': {'name': 'micro', 'value': 1e-6, 'scientific': true},
+    'nano': {'name': 'nano', 'value': 1e-9, 'scientific': true},
+    'pico': {'name': 'pico', 'value': 1e-12, 'scientific': true},
+    'femto': {'name': 'femto', 'value': 1e-15, 'scientific': true},
+    'atto': {'name': 'atto', 'value': 1e-18, 'scientific': true},
+    'zepto': {'name': 'zepto', 'value': 1e-21, 'scientific': true},
+    'yocto': {'name': 'yocto', 'value': 1e-24, 'scientific': true}
+  },
+  'BINARY_SHORT': {
+    '': {'name': '', 'value': 1, 'scientific': true},
+    'k': {'name': 'k', 'value': 1024, 'scientific': true},
+    'M': {'name': 'M', 'value': Math.pow(1024, 2), 'scientific': true},
+    'G': {'name': 'G', 'value': Math.pow(1024, 3), 'scientific': true},
+    'T': {'name': 'T', 'value': Math.pow(1024, 4), 'scientific': true},
+    'P': {'name': 'P', 'value': Math.pow(1024, 5), 'scientific': true},
+    'E': {'name': 'E', 'value': Math.pow(1024, 6), 'scientific': true},
+    'Z': {'name': 'Z', 'value': Math.pow(1024, 7), 'scientific': true},
+    'Y': {'name': 'Y', 'value': Math.pow(1024, 8), 'scientific': true},
+
+    'Ki': {'name': 'Ki', 'value': 1024, 'scientific': true},
+    'Mi': {'name': 'Mi', 'value': Math.pow(1024, 2), 'scientific': true},
+    'Gi': {'name': 'Gi', 'value': Math.pow(1024, 3), 'scientific': true},
+    'Ti': {'name': 'Ti', 'value': Math.pow(1024, 4), 'scientific': true},
+    'Pi': {'name': 'Pi', 'value': Math.pow(1024, 5), 'scientific': true},
+    'Ei': {'name': 'Ei', 'value': Math.pow(1024, 6), 'scientific': true},
+    'Zi': {'name': 'Zi', 'value': Math.pow(1024, 7), 'scientific': true},
+    'Yi': {'name': 'Yi', 'value': Math.pow(1024, 8), 'scientific': true}
+  },
+  'BINARY_LONG': {
+    '': {'name': '', 'value': 1, 'scientific': true},
+    'kilo': {'name': 'kilo', 'value': 1024, 'scientific': true},
+    'mega': {'name': 'mega', 'value': Math.pow(1024, 2), 'scientific': true},
+    'giga': {'name': 'giga', 'value': Math.pow(1024, 3), 'scientific': true},
+    'tera': {'name': 'tera', 'value': Math.pow(1024, 4), 'scientific': true},
+    'peta': {'name': 'peta', 'value': Math.pow(1024, 5), 'scientific': true},
+    'exa': {'name': 'exa', 'value': Math.pow(1024, 6), 'scientific': true},
+    'zetta': {'name': 'zetta', 'value': Math.pow(1024, 7), 'scientific': true},
+    'yotta': {'name': 'yotta', 'value': Math.pow(1024, 8), 'scientific': true},
+
+    'kibi': {'name': 'kibi', 'value': 1024, 'scientific': true},
+    'mebi': {'name': 'mebi', 'value': Math.pow(1024, 2), 'scientific': true},
+    'gibi': {'name': 'gibi', 'value': Math.pow(1024, 3), 'scientific': true},
+    'tebi': {'name': 'tebi', 'value': Math.pow(1024, 4), 'scientific': true},
+    'pebi': {'name': 'pebi', 'value': Math.pow(1024, 5), 'scientific': true},
+    'exi': {'name': 'exi', 'value': Math.pow(1024, 6), 'scientific': true},
+    'zebi': {'name': 'zebi', 'value': Math.pow(1024, 7), 'scientific': true},
+    'yobi': {'name': 'yobi', 'value': Math.pow(1024, 8), 'scientific': true}
+  }
+};
+
+var PREFIX_NONE = {'name': '', 'value': 1, 'scientific': true};
+
+var BASE_UNITS = {
+  'NONE': {},
+
+  'LENGTH': {},               // meter
+  'MASS': {},                 // kilogram
+  'TIME': {},                 // second
+  'CURRENT': {},              // ampere
+  'TEMPERATURE': {},          // kelvin
+  'LUMINOUS_INTENSITY': {},   // candela
+  'AMOUNT_OF_SUBSTANCE': {},  // mole
+
+  'FORCE': {},        // Newton
+  'SURFACE': {},      // m2
+  'VOLUME': {},       // m3
+  'ANGLE': {},        // rad
+  'BIT': {}           // bit (digital)
+};
+
+BASE_UNIT_NONE = {};
+
+UNIT_NONE = {'name': '', 'base': BASE_UNIT_NONE, 'value': 1, 'offset': 0};
+
+var UNITS = [
+  // length
+  {'name': 'meter', 'base': BASE_UNITS.LENGTH, 'prefixes': PREFIXES.LONG, 'value': 1, 'offset': 0},
+  {'name': 'inch', 'base': BASE_UNITS.LENGTH, 'prefixes': PREFIXES.NONE, 'value': 0.0254, 'offset': 0},
+  {'name': 'foot', 'base': BASE_UNITS.LENGTH, 'prefixes': PREFIXES.NONE, 'value': 0.3048, 'offset': 0},
+  {'name': 'yard', 'base': BASE_UNITS.LENGTH, 'prefixes': PREFIXES.NONE, 'value': 0.9144, 'offset': 0},
+  {'name': 'mile', 'base': BASE_UNITS.LENGTH, 'prefixes': PREFIXES.NONE, 'value': 1609.344, 'offset': 0},
+  {'name': 'link', 'base': BASE_UNITS.LENGTH, 'prefixes': PREFIXES.NONE, 'value': 0.201168, 'offset': 0},
+  {'name': 'rod', 'base': BASE_UNITS.LENGTH, 'prefixes': PREFIXES.NONE, 'value': 5.029210, 'offset': 0},
+  {'name': 'chain', 'base': BASE_UNITS.LENGTH, 'prefixes': PREFIXES.NONE, 'value': 20.1168, 'offset': 0},
+  {'name': 'angstrom', 'base': BASE_UNITS.LENGTH, 'prefixes': PREFIXES.NONE, 'value': 1e-10, 'offset': 0},
+
+  {'name': 'm', 'base': BASE_UNITS.LENGTH, 'prefixes': PREFIXES.SHORT, 'value': 1, 'offset': 0},
+  //{'name': 'in', 'base': BASE_UNITS.LENGTH, 'prefixes': PREFIXES.NONE, 'value': 0.0254, 'offset': 0}, not supported, In is an operator
+  {'name': 'ft', 'base': BASE_UNITS.LENGTH, 'prefixes': PREFIXES.NONE, 'value': 0.3048, 'offset': 0},
+  {'name': 'yd', 'base': BASE_UNITS.LENGTH, 'prefixes': PREFIXES.NONE, 'value': 0.9144, 'offset': 0},
+  {'name': 'mi', 'base': BASE_UNITS.LENGTH, 'prefixes': PREFIXES.NONE, 'value': 1609.344, 'offset': 0},
+  {'name': 'li', 'base': BASE_UNITS.LENGTH, 'prefixes': PREFIXES.NONE, 'value': 0.201168, 'offset': 0},
+  {'name': 'rd', 'base': BASE_UNITS.LENGTH, 'prefixes': PREFIXES.NONE, 'value': 5.029210, 'offset': 0},
+  {'name': 'ch', 'base': BASE_UNITS.LENGTH, 'prefixes': PREFIXES.NONE, 'value': 20.1168, 'offset': 0},
+  {'name': 'mil', 'base': BASE_UNITS.LENGTH, 'prefixes': PREFIXES.NONE, 'value': 0.0000254, 'offset': 0}, // 1/1000 inch
+
+  // Surface
+  {'name': 'm2', 'base': BASE_UNITS.SURFACE, 'prefixes': PREFIXES.SHORT, 'value': 1, 'offset': 0},
+  {'name': 'sqin', 'base': BASE_UNITS.SURFACE, 'prefixes': PREFIXES.NONE, 'value': 0.00064516, 'offset': 0}, // 645.16 mm2
+  {'name': 'sqft', 'base': BASE_UNITS.SURFACE, 'prefixes': PREFIXES.NONE, 'value': 0.09290304, 'offset': 0}, // 0.09290304 m2
+  {'name': 'sqyd', 'base': BASE_UNITS.SURFACE, 'prefixes': PREFIXES.NONE, 'value': 0.83612736, 'offset': 0}, // 0.83612736 m2
+  {'name': 'sqmi', 'base': BASE_UNITS.SURFACE, 'prefixes': PREFIXES.NONE, 'value': 2589988.110336, 'offset': 0}, // 2.589988110336 km2
+  {'name': 'sqrd', 'base': BASE_UNITS.SURFACE, 'prefixes': PREFIXES.NONE, 'value': 25.29295, 'offset': 0}, // 25.29295 m2
+  {'name': 'sqch', 'base': BASE_UNITS.SURFACE, 'prefixes': PREFIXES.NONE, 'value': 404.6873, 'offset': 0}, // 404.6873 m2
+  {'name': 'sqmil', 'base': BASE_UNITS.SURFACE, 'prefixes': PREFIXES.NONE, 'value': 6.4516e-10, 'offset': 0}, // 6.4516 * 10^-10 m2
+
+  // Volume
+  {'name': 'm3', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.SHORT, 'value': 1, 'offset': 0},
+  {'name': 'L', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.SHORT, 'value': 0.001, 'offset': 0}, // litre
+  {'name': 'litre', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.LONG, 'value': 0.001, 'offset': 0},
+  {'name': 'cuin', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 1.6387064e-5, 'offset': 0}, // 1.6387064e-5 m3
+  {'name': 'cuft', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.028316846592, 'offset': 0}, // 28.316 846 592 L
+  {'name': 'cuyd', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.764554857984, 'offset': 0}, // 764.554 857 984 L
+  {'name': 'teaspoon', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.000005, 'offset': 0}, // 5 mL
+  {'name': 'tablespoon', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.000015, 'offset': 0}, // 15 mL
+  //{'name': 'cup', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.000240, 'offset': 0}, // 240 mL  // not possible, we have already another cup
+
+  // Liquid volume
+  {'name': 'minim', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.00000006161152, 'offset': 0}, // 0.06161152 mL
+  {'name': 'fluiddram', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.0000036966911, 'offset': 0},  // 3.696691 mL
+  {'name': 'fluidounce', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.00002957353, 'offset': 0}, // 29.57353 mL
+  {'name': 'gill', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.0001182941, 'offset': 0}, // 118.2941 mL
+  {'name': 'cup', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.0002365882, 'offset': 0}, // 236.5882 mL
+  {'name': 'pint', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.0004731765, 'offset': 0}, // 473.1765 mL
+  {'name': 'quart', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.0009463529, 'offset': 0}, // 946.3529 mL
+  {'name': 'gallon', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.003785412, 'offset': 0}, // 3.785412 L
+  {'name': 'beerbarrel', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.1173478, 'offset': 0}, // 117.3478 L
+  {'name': 'oilbarrel', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.1589873, 'offset': 0}, // 158.9873 L
+  {'name': 'hogshead', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.2384810, 'offset': 0}, // 238.4810 L
+
+  //{'name': 'min', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.00000006161152, 'offset': 0}, // 0.06161152 mL // min is already in use as minute
+  {'name': 'fldr', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.0000036966911, 'offset': 0},  // 3.696691 mL
+  {'name': 'floz', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.00002957353, 'offset': 0}, // 29.57353 mL
+  {'name': 'gi', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.0001182941, 'offset': 0}, // 118.2941 mL
+  {'name': 'cp', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.0002365882, 'offset': 0}, // 236.5882 mL
+  {'name': 'pt', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.0004731765, 'offset': 0}, // 473.1765 mL
+  {'name': 'qt', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.0009463529, 'offset': 0}, // 946.3529 mL
+  {'name': 'gal', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.003785412, 'offset': 0}, // 3.785412 L
+  {'name': 'bbl', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.1173478, 'offset': 0}, // 117.3478 L
+  {'name': 'obl', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.1589873, 'offset': 0}, // 158.9873 L
+  //{'name': 'hogshead', 'base': BASE_UNITS.VOLUME, 'prefixes': PREFIXES.NONE, 'value': 0.2384810, 'offset': 0}, // 238.4810 L // TODO: hh?
+
+  // Mass
+  {'name': 'g', 'base': BASE_UNITS.MASS, 'prefixes': PREFIXES.SHORT, 'value': 0.001, 'offset': 0},
+  {'name': 'gram', 'base': BASE_UNITS.MASS, 'prefixes': PREFIXES.LONG, 'value': 0.001, 'offset': 0},
+
+  {'name': 'ton', 'base': BASE_UNITS.MASS, 'prefixes': PREFIXES.SHORT, 'value': 907.18474, 'offset': 0},
+  {'name': 'tonne', 'base': BASE_UNITS.MASS, 'prefixes': PREFIXES.SHORT, 'value': 1000, 'offset': 0},
+
+  {'name': 'grain', 'base': BASE_UNITS.MASS, 'prefixes': PREFIXES.NONE, 'value': 64.79891e-6, 'offset': 0},
+  {'name': 'dram', 'base': BASE_UNITS.MASS, 'prefixes': PREFIXES.NONE, 'value': 1.7718451953125e-3, 'offset': 0},
+  {'name': 'ounce', 'base': BASE_UNITS.MASS, 'prefixes': PREFIXES.NONE, 'value': 28.349523125e-3, 'offset': 0},
+  {'name': 'poundmass', 'base': BASE_UNITS.MASS, 'prefixes': PREFIXES.NONE, 'value': 453.59237e-3, 'offset': 0},
+  {'name': 'hundredweight', 'base': BASE_UNITS.MASS, 'prefixes': PREFIXES.NONE, 'value': 45.359237, 'offset': 0},
+  {'name': 'stick', 'base': BASE_UNITS.MASS, 'prefixes': PREFIXES.NONE, 'value': 115e-3, 'offset': 0},
+
+  {'name': 'gr', 'base': BASE_UNITS.MASS, 'prefixes': PREFIXES.NONE, 'value': 64.79891e-6, 'offset': 0},
+  {'name': 'dr', 'base': BASE_UNITS.MASS, 'prefixes': PREFIXES.NONE, 'value': 1.7718451953125e-3, 'offset': 0},
+  {'name': 'oz', 'base': BASE_UNITS.MASS, 'prefixes': PREFIXES.NONE, 'value': 28.349523125e-3, 'offset': 0},
+  {'name': 'lbm', 'base': BASE_UNITS.MASS, 'prefixes': PREFIXES.NONE, 'value': 453.59237e-3, 'offset': 0},
+  {'name': 'cwt', 'base': BASE_UNITS.MASS, 'prefixes': PREFIXES.NONE, 'value': 45.359237, 'offset': 0},
+
+  // Time
+  {'name': 's', 'base': BASE_UNITS.TIME, 'prefixes': PREFIXES.SHORT, 'value': 1, 'offset': 0},
+  {'name': 'min', 'base': BASE_UNITS.TIME, 'prefixes': PREFIXES.NONE, 'value': 60, 'offset': 0},
+  {'name': 'h', 'base': BASE_UNITS.TIME, 'prefixes': PREFIXES.NONE, 'value': 3600, 'offset': 0},
+  {'name': 'seconds', 'base': BASE_UNITS.TIME, 'prefixes': PREFIXES.LONG, 'value': 1, 'offset': 0},
+  {'name': 'second', 'base': BASE_UNITS.TIME, 'prefixes': PREFIXES.LONG, 'value': 1, 'offset': 0},
+  {'name': 'sec', 'base': BASE_UNITS.TIME, 'prefixes': PREFIXES.LONG, 'value': 1, 'offset': 0},
+  {'name': 'minutes', 'base': BASE_UNITS.TIME, 'prefixes': PREFIXES.NONE, 'value': 60, 'offset': 0},
+  {'name': 'minute', 'base': BASE_UNITS.TIME, 'prefixes': PREFIXES.NONE, 'value': 60, 'offset': 0},
+  {'name': 'hours', 'base': BASE_UNITS.TIME, 'prefixes': PREFIXES.NONE, 'value': 3600, 'offset': 0},
+  {'name': 'hour', 'base': BASE_UNITS.TIME, 'prefixes': PREFIXES.NONE, 'value': 3600, 'offset': 0},
+  {'name': 'day', 'base': BASE_UNITS.TIME, 'prefixes': PREFIXES.NONE, 'value': 86400, 'offset': 0},
+  {'name': 'days', 'base': BASE_UNITS.TIME, 'prefixes': PREFIXES.NONE, 'value': 86400, 'offset': 0},
+
+  // Angles
+  {'name': 'rad', 'base': BASE_UNITS.ANGLE, 'prefixes': PREFIXES.NONE, 'value': 1, 'offset': 0},
+  {'name': 'deg', 'base': BASE_UNITS.ANGLE, 'prefixes': PREFIXES.NONE, 'value': 0.017453292519943295769236907684888, 'offset': 0},  // deg = rad / (2*pi) * 360 = rad / 0.017453292519943295769236907684888
+  {'name': 'grad', 'base': BASE_UNITS.ANGLE, 'prefixes': PREFIXES.NONE, 'value': 0.015707963267948966192313216916399, 'offset': 0}, // grad = rad / (2*pi) * 400  = rad / 0.015707963267948966192313216916399
+  {'name': 'cycle', 'base': BASE_UNITS.ANGLE, 'prefixes': PREFIXES.NONE, 'value': 6.2831853071795864769252867665793, 'offset': 0},  // cycle = rad / (2*pi) = rad / 6.2831853071795864769252867665793
+
+  // Electric current
+  {'name': 'A', 'base': BASE_UNITS.CURRENT, 'prefixes': PREFIXES.SHORT, 'value': 1, 'offset': 0},
+  {'name': 'ampere', 'base': BASE_UNITS.CURRENT, 'prefixes': PREFIXES.LONG, 'value': 1, 'offset': 0},
+
+  // Temperature
+  // K(C) = °C + 273.15
+  // K(F) = (°F + 459.67) / 1.8
+  // K(R) = °R / 1.8
+  {'name': 'K', 'base': BASE_UNITS.TEMPERATURE, 'prefixes': PREFIXES.NONE, 'value': 1, 'offset': 0},
+  {'name': 'degC', 'base': BASE_UNITS.TEMPERATURE, 'prefixes': PREFIXES.NONE, 'value': 1, 'offset': 273.15},
+  {'name': 'degF', 'base': BASE_UNITS.TEMPERATURE, 'prefixes': PREFIXES.NONE, 'value': 1/1.8, 'offset': 459.67},
+  {'name': 'degR', 'base': BASE_UNITS.TEMPERATURE, 'prefixes': PREFIXES.NONE, 'value': 1/1.8, 'offset': 0},
+  {'name': 'kelvin', 'base': BASE_UNITS.TEMPERATURE, 'prefixes': PREFIXES.NONE, 'value': 1, 'offset': 0},
+  {'name': 'celsius', 'base': BASE_UNITS.TEMPERATURE, 'prefixes': PREFIXES.NONE, 'value': 1, 'offset': 273.15},
+  {'name': 'fahrenheit', 'base': BASE_UNITS.TEMPERATURE, 'prefixes': PREFIXES.NONE, 'value': 1/1.8, 'offset': 459.67},
+  {'name': 'rankine', 'base': BASE_UNITS.TEMPERATURE, 'prefixes': PREFIXES.NONE, 'value': 1/1.8, 'offset': 0},
+
+  // amount of substance
+  {'name': 'mol', 'base': BASE_UNITS.AMOUNT_OF_SUBSTANCE, 'prefixes': PREFIXES.NONE, 'value': 1, 'offset': 0},
+  {'name': 'mole', 'base': BASE_UNITS.AMOUNT_OF_SUBSTANCE, 'prefixes': PREFIXES.NONE, 'value': 1, 'offset': 0},
+
+  // luminous intensity
+  {'name': 'cd', 'base': BASE_UNITS.LUMINOUS_INTENSITY, 'prefixes': PREFIXES.NONE, 'value': 1, 'offset': 0},
+  {'name': 'candela', 'base': BASE_UNITS.LUMINOUS_INTENSITY, 'prefixes': PREFIXES.NONE, 'value': 1, 'offset': 0},
+  // TODO: units STERADIAN
+  //{'name': 'sr', 'base': BASE_UNITS.STERADIAN, 'prefixes': PREFIXES.NONE, 'value': 1, 'offset': 0},
+  //{'name': 'steradian', 'base': BASE_UNITS.STERADIAN, 'prefixes': PREFIXES.NONE, 'value': 1, 'offset': 0},
+
+  // Force
+  {'name': 'N', 'base': BASE_UNITS.FORCE, 'prefixes': PREFIXES.SHORT, 'value': 1, 'offset': 0},
+  {'name': 'newton', 'base': BASE_UNITS.FORCE, 'prefixes': PREFIXES.LONG, 'value': 1, 'offset': 0},
+  {'name': 'lbf', 'base': BASE_UNITS.FORCE, 'prefixes': PREFIXES.NONE, 'value': 4.4482216152605, 'offset': 0},
+  {'name': 'poundforce', 'base': BASE_UNITS.FORCE, 'prefixes': PREFIXES.NONE, 'value': 4.4482216152605, 'offset': 0},
+
+  // Binary
+  {'name': 'b', 'base': BASE_UNITS.BIT, 'prefixes': PREFIXES.BINARY_SHORT, 'value': 1, 'offset': 0},
+  {'name': 'bits', 'base': BASE_UNITS.BIT, 'prefixes': PREFIXES.BINARY_LONG, 'value': 1, 'offset': 0},
+  {'name': 'B', 'base': BASE_UNITS.BIT, 'prefixes': PREFIXES.BINARY_SHORT, 'value': 8, 'offset': 0},
+  {'name': 'bytes', 'base': BASE_UNITS.BIT, 'prefixes': PREFIXES.BINARY_LONG, 'value': 8, 'offset': 0}
+];
+
+Unit.PREFIXES = PREFIXES;
+Unit.BASE_UNITS = BASE_UNITS;
+Unit.UNITS = UNITS;
+
+
+// exports
+module.exports = Unit;
+
+// to trick my IDE which doesn't get it
+exports.isUnit = Unit.isUnit;
+exports.isPlainUnit = Unit.isPlainUnit;
+exports.parse = Unit.parse;
+
+},{"../util/index":212}],208:[function(require,module,exports){
+// utility methods for arrays and matrices
+
+var util = require('../util/index'),
+
+    Matrix = require('./Matrix'),
+
+    isArray = util.array.isArray,
+    isString = util.string.isString;
+
+/**
+ * Convert function arguments to an array. Arguments can have the following
+ * signature:
+ *     fn()
+ *     fn(n)
+ *     fn(m, n, p, ...)
+ *     fn([m, n, p, ...])
+ * @param {...Number | Array | Matrix} args
+ * @returns {Array} array
+ */
+exports.argsToArray = function argsToArray(args) {
+  var array;
+  if (args.length == 0) {
+    // fn()
+    array = [];
+  }
+  else if (args.length == 1) {
+    // fn(n)
+    // fn([m, n, p, ...])
+    array = args[0];
+    if (array instanceof Matrix) {
+      array = array.valueOf();
+    }
+    if (!isArray(array)) {
+      array = [array];
+    }
+  }
+  else {
+    // fn(m, n, p, ...)
+    array = Array.prototype.slice.apply(args);
+  }
+  return array;
+};
+
+
+/**
+ * Test whether a value is a collection: an Array or Matrix
+ * @param {*} x
+ * @returns {boolean} isCollection
+ */
+exports.isCollection = function isCollection (x) {
+  return (isArray(x) || (x instanceof Matrix));
+};
+
+/**
+ * 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.
+ * @return {Array | Matrix} res
+ */
+exports.deepMap = function deepMap(array, callback) {
+  if (array && (typeof array.map === 'function')) {
+    return array.map(function (x) {
+      return deepMap(x, callback);
+    });
+  }
+  else {
+    return callback(array);
+  }
+};
+
+/**
+ * Execute the callback function element wise for each entry in two given arrays,
+ * and for any nested array. Objects can also be scalar objects.
+ * Returns an array with the results.
+ * @param {Array | Matrix | Object} array1
+ * @param {Array | Matrix | Object} array2
+ * @param {function} callback   The callback is called with two parameters:
+ *                              value1 and value2, which contain the current
+ *                              element of both arrays.
+ * @return {Array | Matrix} res
+ */
+exports.deepMap2 = function deepMap2(array1, array2, callback) {
+  var res, len, i;
+
+  if (isArray(array1)) {
+    if (isArray(array2)) {
+      // callback(array, array)
+      if (array1.length != array2.length) {
+        throw new RangeError('Dimension mismatch ' +
+            '(' +  array1.length + ' != ' + array2.length + ')');
+      }
+
+      res = [];
+      len = array1.length;
+      for (i = 0; i < len; i++) {
+        res[i] = deepMap2(array1[i], array2[i], callback);
+      }
+    }
+    else if (array2 instanceof Matrix) {
+      // callback(array, matrix)
+      res = deepMap2(array1, array2.valueOf(), callback);
+      return new Matrix(res);
+    }
+    else {
+      // callback(array, object)
+      res = [];
+      len = array1.length;
+      for (i = 0; i < len; i++) {
+        res[i] = deepMap2(array1[i], array2, callback);
+      }
+    }
+  }
+  else if (array1 instanceof Matrix) {
+    if (array2 instanceof Matrix) {
+      // callback(matrix, matrix)
+      res = deepMap2(array1.valueOf(), array2.valueOf(), callback);
+      return new Matrix(res);
+    }
+    else {
+      // callback(matrix, array)
+      // callback(matrix, object)
+      res = deepMap2(array1.valueOf(), array2, callback);
+      return new Matrix(res);
+    }
+  }
+  else {
+    if (isArray(array2)) {
+      // callback(object, array)
+      res = [];
+      len = array2.length;
+      for (i = 0; i < len; i++) {
+        res[i] = deepMap2(array1, array2[i], callback);
+      }
+    }
+    else if (array2 instanceof Matrix) {
+      // callback(object, matrix)
+      res = deepMap2(array1, array2.valueOf(), callback);
+      return new Matrix(res);
+    }
+    else {
+      // callback(object, object)
+      res = callback(array1, array2);
+    }
+  }
+
+  return res;
+};
+
+/**
+ * Reduce a given matrix or array to a new matrix or
+ * array with one less dimension, aplying the given
+ * callback in the selected dimension.
+ * @param {Array | Matrix} mat
+ * @param {Number} dim
+ * @param {function} callback
+ * @return {Array | Matrix} res
+ */
+exports.reduce = function reduce (mat, dim, callback) {
+	if (mat instanceof Matrix) {
+		return new Matrix(_reduce(mat.valueOf(), dim, callback));
+	}else {
+		return _reduce(mat, dim, callback);
+	}
+};
+
+/**
+ * Recursively reduce a matrix
+ * @param {Array} mat
+ * @param {Number} dim
+ * @param {Function} callback
+ * @returns {Array} ret
+ * @private
+ */
+function _reduce(mat, dim, callback){
+  var i, ret, val, tran;
+
+	if(dim<=0){
+		if( !isArray(mat[0]) ){
+			val = mat[0];
+			for(i=1; i<mat.length; i++){
+				val = callback(val, mat[i]);
+			}
+			return val;
+		}else{
+			tran = _switch(mat);
+			ret = [];
+			for(i=0; i<tran.length; i++){
+				ret[i] = _reduce(tran[i], dim-1, callback);
+			}
+			return ret
+		}
+	}else{
+		ret = [];
+		for(i=0; i<mat.length; i++){
+			ret[i] = _reduce(mat[i], dim-1, callback);
+		}
+		return ret;
+	}
+}
+
+/**
+ * Transpose a matrix
+ * @param {Array} mat
+ * @returns {Array} ret
+ * @private
+ */
+function _switch(mat){
+  var I = mat.length;
+  var J = mat[0].length;
+  var i, j;
+  var ret = [];
+  for( j=0; j<J; j++) {
+    var tmp = [];
+    for( i=0; i<I; i++) {
+      tmp.push(mat[i][j]);
+    }
+    ret.push(tmp);
+  }
+  return ret;
+}
+
+/**
+ * Recursively loop over all elements in a given multi dimensional array
+ * and invoke the callback on each of the elements.
+ * @param {Array | Matrix} array
+ * @param {function} callback     The callback method is invoked with one
+ *                                parameter: the current element in the array
+ */
+exports.deepForEach = function deepForEach (array, callback) {
+  if (array instanceof Matrix) {
+    array = array.valueOf();
+  }
+
+  for (var i = 0, ii = array.length; i < ii; i++) {
+    var value = array[i];
+
+    if (isArray(value)) {
+      deepForEach(value, callback);
+    }
+    else {
+      callback(value);
+    }
+  }
+};
+
+},{"../util/index":212,"./Matrix":205}],209:[function(require,module,exports){
+module.exports = function (math) {
+  var types = require('./../util/types');
+
+  // export the error constructors to namespace math.error.*
+  var error = {};
+  math.error = error;
+
+  /**
+   * Create a TypeError with message:
+   *      'Function <fn> does not support a parameter of type <type>';
+   * @param {String} name   Function name
+   * @param {*} [value1]
+   * @param {*...} [value_n]
+   * @extends TypeError
+   */
+  error.UnsupportedTypeError = function UnsupportedTypeError(name, value1, value_n) {
+    if (arguments.length == 2) {
+      var type1 = math['typeof'](value1);
+      this.message = 'Function ' + name + '(' + type1 + ') not supported';
+    }
+    else if (arguments.length > 2) {
+      var values = Array.prototype.splice.call(arguments, 1);
+      var types = values.map(function (value) {
+        return math['typeof'](value);
+      });
+      this.message = 'Function ' + name + '(' + types.join(', ') + ') not supported';
+    }
+    else {
+      this.message = 'Unsupported type of argument in function ' + name;
+    }
+  };
+
+  error.UnsupportedTypeError.prototype = new TypeError();
+  error.UnsupportedTypeError.prototype.name = 'UnsupportedTypeError';
+
+  /**
+   * Create a syntax error with the message:
+   *     'Wrong number of arguments in function <fn> (<count> provided, <min>-<max> expected)'
+   * @param {String} name   Function name
+   * @param {Number} count  Actual argument count
+   * @param {Number} min    Minimum required argument count
+   * @param {Number} [max]  Maximum required argument count
+   * @extends SyntaxError
+   */
+  error.ArgumentsError = function ArgumentsError(name, count, min, max) {
+    this.message = 'Wrong number of arguments in function ' + name +
+        ' (' + count + ' provided, ' +
+        min + ((max != undefined) ? ('-' + max) : '') + ' expected)';
+  };
+
+  error.ArgumentsError.prototype = new SyntaxError();
+  error.ArgumentsError.prototype.name = 'ArgumentError';
+};
+},{"./../util/types":216}],210:[function(require,module,exports){
+var number = require('./number'),
+    string = require('./string'),
+    object = require('./object'),
+    types = require('./types'),
+    isArray = Array.isArray;
+
+/**
+ * Calculate the size of a multi dimensional array.
+ * @param {Array} x
+ * @Return {Number[]} size
+ * @private
+ */
+function _size(x) {
+  var size = [];
+
+  while (isArray(x)) {
+    size.push(x.length);
+    x = x[0];
+  }
+
+  return size;
+}
+
+/**
+ * Calculate the size of a multi dimensional array.
+ * All elements in the array are checked for matching dimensions using the
+ * method validate
+ * @param {Array} x
+ * @Return {Number[]} size
+ * @throws RangeError
+ */
+exports.size = function size (x) {
+  // calculate the size
+  var s = _size(x);
+
+  // verify the size
+  exports.validate(x, s);
+  // TODO: don't validate here? only in a Matrix constructor?
+
+  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 RangeError
+ * @private
+ */
+function _validate(array, size, dim) {
+  var i;
+  var len = array.length;
+
+  if (len != size[dim]) {
+    throw new RangeError('Dimension mismatch (' + 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 (!isArray(child)) {
+        throw new RangeError('Dimension mismatch ' +
+            '(' + (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 (isArray(array[i])) {
+        throw new RangeError('Dimension mismatch ' +
+            '(' + (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 RangeError
+ */
+exports.validate = function validate(array, size) {
+  var isScalar = (size.length == 0);
+  if (isScalar) {
+    // scalar
+    if (isArray(array)) {
+      throw new RangeError('Dimension mismatch (' + array.length + ' != 0)');
+    }
+  }
+  else {
+    // array
+    _validate(array, size, 0);
+  }
+};
+
+/**
+ * Test whether index is an integer number with index >= 0 and index < length
+ * @param {*} index         Zero-based index
+ * @param {Number} [length] Length of the array
+ */
+exports.validateIndex = function validateIndex (index, length) {
+  if (!number.isNumber(index) || !number.isInteger(index)) {
+    throw new TypeError('Index must be an integer (value: ' + index + ')');
+  }
+  if (index < 0) {
+    throw new RangeError('Index out of range (' + index + ' < 0)');
+  }
+  if (length !== undefined && index >= length) {
+    throw new RangeError('Index out of range (' + index + ' > ' + (length - 1) +  ')');
+  }
+};
+
+/**
+ * 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]    Value to be filled in in new entries,
+ *                              undefined by default
+ * @return {Array} array         The resized array
+ */
+exports.resize = function resize(array, size, defaultValue) {
+  // TODO: add support for scalars, having size=[] ?
+
+  // check the type of the arguments
+  if (!isArray(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.isNumber(value) || !number.isInteger(value) || value < 0) {
+      throw new TypeError('Invalid size, must contain positive integers ' +
+          '(size: ' + string.format(size) + ')');
+    }
+  });
+
+  // count the current number of dimensions
+  var dims = 1;
+  var elem = array[0];
+  while (isArray(elem)) {
+    dims++;
+    elem = elem[0];
+  }
+
+  // adjust the number of dimensions when needed
+  while (dims < size.length) { // add dimensions
+    array = [array];
+    dims++;
+  }
+  while (dims > size.length) { // remove dimensions
+    array = array[0];
+    dims--;
+  }
+
+  // recursively resize the array
+  _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) {
+  if (!isArray(array)) {
+    throw Error('Array expected');
+  }
+
+  var i, elem,
+      oldLen = array.length,
+      newLen = size[dim],
+      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];
+      _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
+    if(defaultValue !== undefined) {
+      // fill new elements with the default value
+      for (i = oldLen; i < newLen; i++) {
+        array[i] = object.clone(defaultValue);
+      }
+    }
+  }
+}
+
+/**
+ * Squeeze a multi dimensional array
+ * @param {Array} array
+ * @return {Array} array
+ * @private
+ */
+exports.squeeze = function squeeze(array) {
+  while(isArray(array) && array.length === 1) {
+    array = array[0];
+  }
+
+  return array;
+};
+
+/**
+ * Unsqueeze a multi dimensional array: add dimensions when missing
+ * @param {Array} array
+ * @param {Number} dims   Number of desired dimensions
+ * @return {Array} array
+ * @private
+ */
+exports.unsqueeze = function unsqueeze(array, dims) {
+  var size = exports.size(array);
+
+  for (var i = 0, ii = (dims - size.length); i < ii; i++) {
+    array = [array];
+  }
+
+  return array;
+};
+
+/**
+ * Test whether an object is an array
+ * @param {*} value
+ * @return {Boolean} isArray
+ */
+exports.isArray = isArray;
+},{"./number":213,"./object":214,"./string":215,"./types":216}],211:[function(require,module,exports){
+/**
+ * Test whether value is a Boolean
+ * @param {*} value
+ * @return {Boolean} isBoolean
+ */
+exports.isBoolean = function isBoolean(value) {
+  return (value instanceof Boolean) || (typeof value == 'boolean');
+};
+
+},{}],212:[function(require,module,exports){
+exports.array = require('./array');
+exports.boolean = require('./boolean');
+exports.number = require('./number');
+exports.object = require('./object');
+exports.string = require('./string');
+exports.types = require('./types');
+
+},{"./array":210,"./boolean":211,"./number":213,"./object":214,"./string":215,"./types":216}],213:[function(require,module,exports){
+var BigNumber = require('bignumber.js');
+
+/**
+ * Test whether value is a Number
+ * @param {*} value
+ * @return {Boolean} isNumber
+ */
+exports.isNumber = function isNumber(value) {
+  return (value instanceof Number) || (typeof value == 'number');
+};
+
+/**
+ * Check if a number is integer
+ * @param {Number | Boolean} value
+ * @return {Boolean} isInteger
+ */
+exports.isInteger = function isInteger(value) {
+  return (value == Math.round(value));
+  // Note: we use ==, not ===, as we can have Booleans as well
+};
+
+/**
+ * Calculate the sign of a number
+ * @param {Number} x
+ * @returns {*}
+ */
+exports.sign = function sign (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'
+ *                         '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' and
+ *                                          'auto', `precision` defines the total
+ *                                          number of significant digits returned
+ *                                          and is undefined by default.
+ *                                          In case of notation 'fixed',
+ *                                          `precision` defines the number of
+ *                                          significant digits after the decimal
+ *                                          point, and is 0 by default.
+ *                     {Object} exponential An object containing two parameters,
+ *                                          {Number} lower and {Number} upper,
+ *                                          used by notation 'auto' to determine
+ *                                          when to return exponential notation.
+ *                                          Default values are `lower=1e-3` and
+ *                                          `upper=1e5`.
+ *                                          Only applicable for notation `auto`.
+ *    {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'
+ *
+ * @param {Number | BigNumber} value
+ * @param {Object | Function | Number} [options]
+ * @return {String} str The formatted value
+ */
+exports.format = function format(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 = undefined;
+
+  if (options !== undefined) {
+    // determine notation from options
+    if (options.notation) {
+      notation = options.notation;
+    }
+
+    // determine precision from options
+    if (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);
+
+    // TODO: notation 'scientific' is deprecated since version 0.16.0, remove this some day
+    case 'scientific':
+      throw new Error('Format notation "scientific" is deprecated. Use "exponential" instead.');
+
+    case 'exponential':
+      return exports.toExponential(value, precision);
+
+    case 'auto':
+      // determine lower and upper bound for exponential notation.
+        // TODO: implement support for upper and lower to be BigNumbers themselves
+      var lower = 1e-3;
+      var upper = 1e5;
+      if (options && options.exponential) {
+        if (options.exponential.lower !== undefined) {
+          lower = options.exponential.lower;
+        }
+        if (options.exponential.upper !== undefined) {
+          upper = options.exponential.upper;
+        }
+      }
+      else if (options && options.scientific) {
+        // TODO: 'options.scientific' is deprecated since version 0.16.0, remove this some day
+        throw new Error('options.scientific is deprecated, use options.exponential instead.');
+      }
+
+      // adjust BigNumber configuration
+      var isBigNumber = value instanceof BigNumber;
+      if (isBigNumber) {
+        var oldScientific = BigNumber.config().EXPONENTIAL_AT;
+        BigNumber.config({
+          EXPONENTIAL_AT: [
+            Math.round(Math.log(lower) / Math.LN10),
+            Math.round(Math.log(upper) / Math.LN10)
+          ]
+        });
+      }
+
+      // handle special case zero
+      if (_isZero(value)) {
+        return '0';
+      }
+
+      // determine whether or not to output exponential notation
+      var str;
+      if (_isBetween(value, lower, upper)) {
+        // normal number notation
+        if (isBigNumber) {
+          str = new BigNumber(value.toPrecision(precision)).toString();
+        }
+        else { // Number
+          str = parseFloat(value.toPrecision(precision ? Math.min(precision, 21) : precision)) + '';
+        }
+      }
+      else {
+        // exponential notation
+        str = exports.toExponential(value, precision);
+      }
+
+      // restore BigNumber configuration
+      if (isBigNumber) {
+        BigNumber.config({EXPONENTIAL_AT: oldScientific});
+      }
+
+      // 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".');
+  }
+};
+
+/**
+ * Test whether a value is zero
+ * @param {Number | BigNumber} value
+ * @return {boolean} isZero
+ * @private
+ */
+function _isZero (value) {
+  return (value instanceof BigNumber) ? value.isZero() : (value === 0);
+}
+
+/**
+ * Test whether a value is inside a range:
+ *
+ *   lower >= value < upper
+ *
+ * @param {Number | BigNumber} value
+ * @param {Number} lower  Included lower bound
+ * @param {Number} upper  Excluded upper bound
+ * @return {boolean} isBetween
+ * @private
+ */
+function _isBetween(value, lower, upper) {
+  var abs;
+  if (value instanceof BigNumber) {
+    abs = value.abs();
+    return (abs.gte(lower) && abs.lt(upper));
+  }
+  else {
+    abs = Math.abs(value);
+    return (abs >= lower && abs < upper);
+  }
+}
+
+/**
+ * Format a number in exponential notation. Like '1.23e+5', '2.3e+0', '3.500e-3'
+ * @param {Number | 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 toExponential (value, precision) {
+  if (precision !== undefined) {
+    if (value instanceof BigNumber) {
+      return value.toExponential(precision - 1);
+    }
+    else { // Number
+      return value.toExponential(Math.min(precision - 1, 20));
+    }
+  }
+  else {
+    return value.toExponential();
+  }
+};
+
+/**
+ * Format a number with fixed notation.
+ * @param {Number | BigNumber} value
+ * @param {Number} [precision=0]        Optional number of decimals after the
+ *                                      decimal point. Zero by default.
+ */
+exports.toFixed = function toFixed (value, precision) {
+  if (value instanceof BigNumber) {
+    return value.toFixed(precision || 0);
+    // Note: the (precision || 0) is needed as the toFixed of BigNumber has an
+    // undefined default precision instead of 0.
+  }
+  else { // Number
+    return value.toFixed(Math.min(precision, 20));
+  }
+};
+
+/**
+ * Count the number of significant digits of a number.
+ *
+ * For example:
+ *   2.34 returns 3
+ *   0.0034 returns 2
+ *   120.5e+3 returns 4
+ *
+ * @param {Number} value
+ * @return {Number} digits   Number of significant digits
+ */
+exports.digits = function digits (value) {
+  return value
+      .toExponential()
+      .replace(/e[\+\-0-9]*$/, '')  // remove exponential notation
+      .replace( /^0\.0*|\./, '')    // remove decimal point and leading zeros
+      .length
+};
+
+/**
+ * Convert a Number in to a BigNumber. If the number has 15 or mor significant
+ * digits, the Number cannot be converted to BigNumber and will return the
+ * original number.
+ * @param {Number} number
+ * @return {BigNumber | Number} bignumber
+ */
+exports.toBigNumber = function toBigNumber (number) {
+  if (exports.digits(number) > 15) {
+    return number;
+  }
+  else {
+    return new BigNumber(number);
+  }
+};
+
+/**
+ * Convert a BigNumber into a Number. If the number is out of range, it will
+ * get the value Infinity or 0.
+ * @param {BigNumber} bignumber
+ * @return {Number} number
+ */
+exports.toNumber = function toNumber (bignumber) {
+  return parseFloat(bignumber.valueOf());
+};
+
+},{"bignumber.js":217}],214:[function(require,module,exports){
+var number = require('./number'),
+    string = require('./string'),
+    bool = require('./boolean');
+
+/**
+ * Clone an object
+ *
+ *     clone(x)
+ *
+ * @param {*} x
+ * @return {*} clone
+ */
+exports.clone = function clone(x) {
+  if (x == null) {
+    // null or undefined
+    return x;
+  }
+
+  if (typeof(x.clone) === 'function') {
+    return x.clone();
+  }
+
+  if (number.isNumber(x) || string.isString(x) || bool.isBoolean(x)) {
+    return x;
+  }
+
+  if (Array.isArray(x)) {
+    return x.map(function (value) {
+      return clone(value);
+    });
+  }
+
+  if (x instanceof Object) {
+    var m = {};
+    for (var key in x) {
+      if (x.hasOwnProperty(key)) {
+        m[key] = clone(x[key]);
+      }
+    }
+    return x;
+  }
+
+  throw new TypeError('Cannot clone ' + x);
+};
+
+/**
+ * Extend object a with the properties of object b
+ * @param {Object} a
+ * @param {Object} b
+ * @return {Object} a
+ */
+exports.extend = function extend (a, b) {
+  for (var prop in b) {
+    if (b.hasOwnProperty(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) {
+  for (var prop in b) {
+    if (b.hasOwnProperty(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 {
+        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) {
+      if (a.hasOwnProperty(prop)) {
+        if (!exports.deepEqual(a[prop], b[prop])) {
+          return false;
+        }
+      }
+    }
+    for (prop in b) {
+      if (b.hasOwnProperty(prop)) {
+        if (!exports.deepEqual(a[prop], b[prop])) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  else {
+    return (a == b);
+  }
+};
+
+},{"./boolean":211,"./number":213,"./string":215}],215:[function(require,module,exports){
+var number = require('./number'),
+    BigNumber = require('bignumber.js');
+
+/**
+ * Test whether value is a String
+ * @param {*} value
+ * @return {Boolean} isString
+ */
+exports.isString = function isString(value) {
+  return (value instanceof String) || (typeof value == 'string');
+};
+
+/**
+ * Check if a text ends with a certain string.
+ * @param {String} text
+ * @param {String} search
+ */
+exports.endsWith = function endsWith(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)
+ *
+ * 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/util/number:format for a
+ *                                                description of the available
+ *                                                options.
+ * @return {String} str
+ */
+exports.format = function format(value, options) {
+  if (number.isNumber(value) || value instanceof BigNumber) {
+    return number.format(value, options);
+  }
+
+  if (Array.isArray(value)) {
+    return formatArray(value, options);
+  }
+
+  if (exports.isString(value)) {
+    return '"' + value + '"';
+  }
+
+  if (value instanceof Object) {
+    if (typeof value.format === 'function') {
+      return value.format(options);
+    }
+    else {
+      return value.toString();
+    }
+  }
+
+  return String(value);
+};
+
+/**
+ * Recursively format an n-dimensional matrix
+ * Example output: "[[1, 2], [3, 4]]"
+ * @param {Array} array
+ * @param {Object | Number | Function} [options]  Formatting options. See
+ *                                                lib/util/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);
+  }
+}
+
+},{"./number":213,"bignumber.js":217}],216:[function(require,module,exports){
+/**
+ * Determine the type of a variable
+ *
+ *     typeof(x)
+ *
+ * @param {*} x
+ * @return {String} type  Lower case type, for example 'number', 'string',
+ *                        'array', 'date'.
+ */
+exports.type = function type (x) {
+  var type = typeof x;
+
+  if (type === 'object') {
+    if (x === null) {
+      return 'null';
+    }
+    if (x instanceof Boolean) {
+      return 'boolean';
+    }
+    if (x instanceof Number) {
+      return 'number';
+    }
+    if (x instanceof String) {
+      return 'string';
+    }
+    if (Array.isArray(x)) {
+      return 'array';
+    }
+    if (x instanceof Date) {
+      return 'date';
+    }
+  }
+
+  return type;
+};
+
+},{}],217:[function(require,module,exports){
+/* bignumber.js v1.3.0 https://github.com/MikeMcl/bignumber.js/LICENCE */
+;(function ( global ) {
+    'use strict';
+
+    /*
+      bignumber.js v1.3.0
+      A JavaScript library for arbitrary-precision arithmetic.
+      https://github.com/MikeMcl/bignumber.js
+      Copyright (c) 2012 Michael Mclaughlin <M8ch88l@gmail.com>
+      MIT Expat Licence
+    */
+
+    /*********************************** DEFAULTS ************************************/
+
+    /*
+     * The default values below must be integers within the stated ranges (inclusive).
+     * Most of these values can be changed during run-time using BigNumber.config().
+     */
+
+    /*
+     * The limit on the value of DECIMAL_PLACES, TO_EXP_NEG, TO_EXP_POS, MIN_EXP,
+     * MAX_EXP, and the argument to toFixed, toPrecision and toExponential, beyond
+     * which an exception is thrown (if ERRORS is true).
+     */
+    var MAX = 1E9,                                   // 0 to 1e+9
+
+        // Limit of magnitude of exponent argument to toPower.
+        MAX_POWER = 1E6,                             // 1 to 1e+6
+
+        // The maximum number of decimal places for operations involving division.
+        DECIMAL_PLACES = 20,                         // 0 to MAX
+
+        /*
+         * The rounding mode used when rounding to the above decimal places, and when
+         * using toFixed, toPrecision and toExponential, and round (default value).
+         * UP         0 Away from zero.
+         * DOWN       1 Towards zero.
+         * CEIL       2 Towards +Infinity.
+         * FLOOR      3 Towards -Infinity.
+         * HALF_UP    4 Towards nearest neighbour. If equidistant, up.
+         * HALF_DOWN  5 Towards nearest neighbour. If equidistant, down.
+         * HALF_EVEN  6 Towards nearest neighbour. If equidistant, towards even neighbour.
+         * HALF_CEIL  7 Towards nearest neighbour. If equidistant, towards +Infinity.
+         * HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.
+         */
+        ROUNDING_MODE = 4,                           // 0 to 8
+
+        // EXPONENTIAL_AT : [TO_EXP_NEG , TO_EXP_POS]
+
+        // The exponent value at and beneath which toString returns exponential notation.
+        // Number type: -7
+        TO_EXP_NEG = -7,                             // 0 to -MAX
+
+        // The exponent value at and above which toString returns exponential notation.
+        // Number type: 21
+        TO_EXP_POS = 21,                             // 0 to MAX
+        TO_EXP_POS = 21,                             // 0 to MAX
+
+        // RANGE : [MIN_EXP, MAX_EXP]
+
+        // The minimum exponent value, beneath which underflow to zero occurs.
+        // Number type: -324  (5e-324)
+        MIN_EXP = -MAX,                              // -1 to -MAX
+
+        // The maximum exponent value, above which overflow to Infinity occurs.
+        // Number type:  308  (1.7976931348623157e+308)
+        MAX_EXP = MAX,                               // 1 to MAX
+
+        // Whether BigNumber Errors are ever thrown.
+        // CHANGE parseInt to parseFloat if changing ERRORS to false.
+        ERRORS = true,                               // true or false
+        parse = parseInt,                            // parseInt or parseFloat
+
+    /***********************************************************************************/
+
+        P = BigNumber.prototype,
+        DIGITS = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_',
+        outOfRange,
+        id = 0,
+        isValid = /^-?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i,
+        trim = String.prototype.trim || function () {return this.replace(/^\s+|\s+$/g, '')},
+        ONE = BigNumber(1);
+
+
+    // CONSTRUCTOR
+
+
+    /*
+     * The exported function.
+     * Create and return a new instance of a BigNumber object.
+     *
+     * n {number|string|BigNumber} A numeric value.
+     * [b] {number} The base of n. Integer, 2 to 64 inclusive.
+     */
+    function BigNumber( n, b ) {
+        var e, i, isNum, digits, valid, orig,
+            x = this;
+
+        // Enable constructor usage without new.
+        if ( !(x instanceof BigNumber) ) {
+            return new BigNumber( n, b )
+        }
+
+        // Duplicate.
+        if ( n instanceof BigNumber ) {
+            id = 0;
+
+            // e is undefined.
+            if ( b !== e ) {
+                n += ''
+            } else {
+                x['s'] = n['s'];
+                x['e'] = n['e'];
+                x['c'] = ( n = n['c'] ) ? n.slice() : n;
+                return
+            }
+        }
+
+        // If number, check if minus zero.
+        if ( typeof n != 'string' ) {
+            n = ( isNum = typeof n == 'number' ||
+                Object.prototype.toString.call(n) == '[object Number]' ) &&
+                    n === 0 && 1 / n < 0 ? '-0' : n + ''
+        }
+
+        orig = n;
+
+        if ( b === e && isValid.test(n) ) {
+
+            // Determine sign.
+            x['s'] = n.charAt(0) == '-' ? ( n = n.slice(1), -1 ) : 1
+
+        // Either n is not a valid BigNumber or a base has been specified.
+        } else {
+
+            // Enable exponential notation to be used with base 10 argument.
+            // Ensure return value is rounded to DECIMAL_PLACES as with other bases.
+            if ( b == 10 ) {
+
+                return setMode( n, DECIMAL_PLACES, ROUNDING_MODE )
+            }
+
+            n = trim.call(n).replace( /^\+(?!-)/, '' );
+
+            x['s'] = n.charAt(0) == '-' ? ( n = n.replace( /^-(?!-)/, '' ), -1 ) : 1;
+
+            if ( b != null ) {
+
+                if ( ( b == (b | 0) || !ERRORS ) &&
+                  !( outOfRange = !( b >= 2 && b < 65 ) ) ) {
+
+                    digits = '[' + DIGITS.slice( 0, b = b | 0 ) + ']+';
+
+                    // Before non-decimal number validity test and base conversion
+                    // remove the `.` from e.g. '1.', and replace e.g. '.1' with '0.1'.
+                    n = n.replace( /\.$/, '' ).replace( /^\./, '0.' );
+
+                    // Any number in exponential form will fail due to the e+/-.
+                    if ( valid = new RegExp(
+                      '^' + digits + '(?:\\.' + digits + ')?$', b < 37 ? 'i' : '' ).test(n) ) {
+
+                        if ( isNum ) {
+
+                            if ( n.replace( /^0\.0*|\./, '' ).length > 15 ) {
+
+                                // 'new BigNumber() number type has more than 15 significant digits: {n}'
+                                ifExceptionsThrow( orig, 0 )
+                            }
+
+                            // Prevent later check for length on converted number.
+                            isNum = !isNum
+                        }
+                        n = convert( n, 10, b, x['s'] )
+
+                    } else if ( n != 'Infinity' && n != 'NaN' ) {
+
+                        // 'new BigNumber() not a base {b} number: {n}'
+                        ifExceptionsThrow( orig, 1, b );
+                        n = 'NaN'
+                    }
+                } else {
+
+                    // 'new BigNumber() base not an integer: {b}'
+                    // 'new BigNumber() base out of range: {b}'
+                    ifExceptionsThrow( b, 2 );
+
+                    // Ignore base.
+                    valid = isValid.test(n)
+                }
+            } else {
+                valid = isValid.test(n)
+            }
+
+            if ( !valid ) {
+
+                // Infinity/NaN
+                x['c'] = x['e'] = null;
+
+                // NaN
+                if ( n != 'Infinity' ) {
+
+                    // No exception on NaN.
+                    if ( n != 'NaN' ) {
+
+                        // 'new BigNumber() not a number: {n}'
+                        ifExceptionsThrow( orig, 3 )
+                    }
+                    x['s'] = null
+                }
+                id = 0;
+
+                return
+            }
+        }
+
+        // Decimal point?
+        if ( ( e = n.indexOf('.') ) > -1 ) {
+            n = n.replace( '.', '' )
+        }
+
+        // Exponential form?
+        if ( ( i = n.search( /e/i ) ) > 0 ) {
+
+            // Determine exponent.
+            if ( e < 0 ) {
+                e = i
+            }
+            e += +n.slice( i + 1 );
+            n = n.substring( 0, i )
+
+        } else if ( e < 0 ) {
+
+            // Integer.
+            e = n.length
+        }
+
+        // Determine leading zeros.
+        for ( i = 0; n.charAt(i) == '0'; i++ ) {
+        }
+
+        b = n.length;
+
+        // Disallow numbers with over 15 significant digits if number type.
+        if ( isNum && b > 15 && n.slice(i).length > 15 ) {
+
+            // 'new BigNumber() number type has more than 15 significant digits: {n}'
+            ifExceptionsThrow( orig, 0 )
+        }
+        id = 0;
+
+        // Overflow?
+        if ( ( e -= i + 1 ) > MAX_EXP ) {
+
+            // Infinity.
+            x['c'] = x['e'] = null
+
+        // Zero or underflow?
+        } else if ( i == b || e < MIN_EXP ) {
+
+            // Zero.
+            x['c'] = [ x['e'] = 0 ]
+        } else {
+
+            // Determine trailing zeros.
+            for ( ; n.charAt(--b) == '0'; ) {
+            }
+
+            x['e'] = e;
+            x['c'] = [];
+
+            // Convert string to array of digits (without leading and trailing zeros).
+            for ( e = 0; i <= b; x['c'][e++] = +n.charAt(i++) ) {
+            }
+        }
+    }
+
+
+    // CONSTRUCTOR PROPERTIES/METHODS
+
+
+    BigNumber['ROUND_UP'] = 0;
+    BigNumber['ROUND_DOWN'] = 1;
+    BigNumber['ROUND_CEIL'] = 2;
+    BigNumber['ROUND_FLOOR'] = 3;
+    BigNumber['ROUND_HALF_UP'] = 4;
+    BigNumber['ROUND_HALF_DOWN'] = 5;
+    BigNumber['ROUND_HALF_EVEN'] = 6;
+    BigNumber['ROUND_HALF_CEIL'] = 7;
+    BigNumber['ROUND_HALF_FLOOR'] = 8;
+
+
+    /*
+     * Configure infrequently-changing library-wide settings.
+     *
+     * Accept an object or an argument list, with one or many of the following
+     * properties or parameters respectively:
+     * [ DECIMAL_PLACES [, ROUNDING_MODE [, EXPONENTIAL_AT [, RANGE [, ERRORS ]]]]]
+     *
+     * E.g.
+     * BigNumber.config(20, 4) is equivalent to
+     * BigNumber.config({ DECIMAL_PLACES : 20, ROUNDING_MODE : 4 })
+     * Ignore properties/parameters set to null or undefined.
+     *
+     * Return an object with the properties current values.
+     */
+    BigNumber['config'] = function () {
+        var v, p,
+            i = 0,
+            r = {},
+            a = arguments,
+            o = a[0],
+            c = 'config',
+            inRange = function ( n, lo, hi ) {
+              return !( ( outOfRange = n < lo || n > hi ) ||
+                parse(n) != n && n !== 0 )
+            },
+            has = o && typeof o == 'object'
+              ? function () {if ( o.hasOwnProperty(p) ) return ( v = o[p] ) != null}
+              : function () {if ( a.length > i ) return ( v = a[i++] ) != null};
+
+        // [DECIMAL_PLACES] {number} Integer, 0 to MAX inclusive.
+        if ( has( p = 'DECIMAL_PLACES' ) ) {
+
+            if ( inRange( v, 0, MAX ) ) {
+                DECIMAL_PLACES = v | 0
+            } else {
+
+                // 'config() DECIMAL_PLACES not an integer: {v}'
+                // 'config() DECIMAL_PLACES out of range: {v}'
+                ifExceptionsThrow( v, p, c )
+            }
+        }
+        r[p] = DECIMAL_PLACES;
+
+        // [ROUNDING_MODE] {number} Integer, 0 to 8 inclusive.
+        if ( has( p = 'ROUNDING_MODE' ) ) {
+
+            if ( inRange( v, 0, 8 ) ) {
+                ROUNDING_MODE = v | 0
+            } else {
+
+                // 'config() ROUNDING_MODE not an integer: {v}'
+                // 'config() ROUNDING_MODE out of range: {v}'
+                ifExceptionsThrow( v, p, c )
+            }
+        }
+        r[p] = ROUNDING_MODE;
+
+        /*
+         * [EXPONENTIAL_AT] {number|number[]} Integer, -MAX to MAX inclusive or
+         * [ integer -MAX to 0 inclusive, 0 to MAX inclusive ].
+         */
+        if ( has( p = 'EXPONENTIAL_AT' ) ) {
+
+            if ( inRange( v, -MAX, MAX ) ) {
+                TO_EXP_NEG = -( TO_EXP_POS = ~~( v < 0 ? -v : +v ) )
+            } else if ( !outOfRange && v && inRange( v[0], -MAX, 0 ) &&
+              inRange( v[1], 0, MAX ) ) {
+                TO_EXP_NEG = ~~v[0], TO_EXP_POS = ~~v[1]
+            } else {
+
+                // 'config() EXPONENTIAL_AT not an integer or not [integer, integer]: {v}'
+                // 'config() EXPONENTIAL_AT out of range or not [negative, positive: {v}'
+                ifExceptionsThrow( v, p, c, 1 )
+            }
+        }
+        r[p] = [ TO_EXP_NEG, TO_EXP_POS ];
+
+        /*
+         * [RANGE][ {number|number[]} Non-zero integer, -MAX to MAX inclusive or
+         * [ integer -MAX to -1 inclusive, integer 1 to MAX inclusive ].
+         */
+        if ( has( p = 'RANGE' ) ) {
+
+            if ( inRange( v, -MAX, MAX ) && ~~v ) {
+                MIN_EXP = -( MAX_EXP = ~~( v < 0 ? -v : +v ) )
+            } else if ( !outOfRange && v && inRange( v[0], -MAX, -1 ) &&
+              inRange( v[1], 1, MAX ) ) {
+                MIN_EXP = ~~v[0], MAX_EXP = ~~v[1]
+            } else {
+
+                // 'config() RANGE not a non-zero integer or not [integer, integer]: {v}'
+                // 'config() RANGE out of range or not [negative, positive: {v}'
+                ifExceptionsThrow( v, p, c, 1, 1 )
+            }
+        }
+        r[p] = [ MIN_EXP, MAX_EXP ];
+
+        // [ERRORS] {boolean|number} true, false, 1 or 0.
+        if ( has( p = 'ERRORS' ) ) {
+
+            if ( v === !!v || v === 1 || v === 0 ) {
+                parse = ( outOfRange = id = 0, ERRORS = !!v )
+                  ? parseInt
+                  : parseFloat
+            } else {
+
+                // 'config() ERRORS not a boolean or binary digit: {v}'
+                ifExceptionsThrow( v, p, c, 0, 0, 1 )
+            }
+        }
+        r[p] = ERRORS;
+
+        return r
+    };
+
+
+    // PRIVATE FUNCTIONS
+
+
+    // Assemble error messages. Throw BigNumber Errors.
+    function ifExceptionsThrow( arg, i, j, isArray, isRange, isErrors) {
+
+        if ( ERRORS ) {
+            var error,
+                method = ['new BigNumber', 'cmp', 'div', 'eq', 'gt', 'gte', 'lt',
+                     'lte', 'minus', 'mod', 'plus', 'times', 'toFr'
+                    ][ id ? id < 0 ? -id : id : 1 / id < 0 ? 1 : 0 ] + '()',
+                message = outOfRange ? ' out of range' : ' not a' +
+                  ( isRange ? ' non-zero' : 'n' ) + ' integer';
+
+            message = ( [
+                method + ' number type has more than 15 significant digits',
+                method + ' not a base ' + j + ' number',
+                method + ' base' + message,
+                method + ' not a number' ][i] ||
+                  j + '() ' + i + ( isErrors
+                    ? ' not a boolean or binary digit'
+                    : message + ( isArray
+                      ? ' or not [' + ( outOfRange
+                        ? ' negative, positive'
+                        : ' integer, integer' ) + ' ]'
+                      : '' ) ) ) + ': ' + arg;
+
+            outOfRange = id = 0;
+            error = new Error(message);
+            error['name'] = 'BigNumber Error';
+
+            throw error
+        }
+    }
+
+
+    /*
+     * Convert a numeric string of baseIn to a numeric string of baseOut.
+     */
+    function convert( nStr, baseOut, baseIn, sign ) {
+        var e, dvs, dvd, nArr, fracArr, fracBN;
+
+        // Convert string of base bIn to an array of numbers of baseOut.
+        // Eg. strToArr('255', 10) where baseOut is 16, returns [15, 15].
+        // Eg. strToArr('ff', 16)  where baseOut is 10, returns [2, 5, 5].
+        function strToArr( str, bIn ) {
+            var j,
+                i = 0,
+                strL = str.length,
+                arrL,
+                arr = [0];
+
+            for ( bIn = bIn || baseIn; i < strL; i++ ) {
+
+                for ( arrL = arr.length, j = 0; j < arrL; arr[j] *= bIn, j++ ) {
+                }
+
+                for ( arr[0] += DIGITS.indexOf( str.charAt(i) ), j = 0;
+                      j < arr.length;
+                      j++ ) {
+
+                    if ( arr[j] > baseOut - 1 ) {
+
+                        if ( arr[j + 1] == null ) {
+                            arr[j + 1] = 0
+                        }
+                        arr[j + 1] += arr[j] / baseOut ^ 0;
+                        arr[j] %= baseOut
+                    }
+                }
+            }
+
+            return arr.reverse()
+        }
+
+        // Convert array to string.
+        // E.g. arrToStr( [9, 10, 11] ) becomes '9ab' (in bases above 11).
+        function arrToStr( arr ) {
+            var i = 0,
+                arrL = arr.length,
+                str = '';
+
+            for ( ; i < arrL; str += DIGITS.charAt( arr[i++] ) ) {
+            }
+
+            return str
+        }
+
+        if ( baseIn < 37 ) {
+            nStr = nStr.toLowerCase()
+        }
+
+        /*
+         * If non-integer convert integer part and fraction part separately.
+         * Convert the fraction part as if it is an integer than use division to
+         * reduce it down again to a value less than one.
+         */
+        if ( ( e = nStr.indexOf( '.' ) ) > -1 ) {
+
+            /*
+             * Calculate the power to which to raise the base to get the number
+             * to divide the fraction part by after it has been converted as an
+             * integer to the required base.
+             */
+            e = nStr.length - e - 1;
+
+            // Use toFixed to avoid possible exponential notation.
+            dvs = strToArr( new BigNumber(baseIn)['pow'](e)['toF'](), 10 );
+
+            nArr = nStr.split('.');
+
+            // Convert the base of the fraction part (as integer).
+            dvd = strToArr( nArr[1] );
+
+            // Convert the base of the integer part.
+            nArr = strToArr( nArr[0] );
+
+            // Result will be a BigNumber with a value less than 1.
+            fracBN = divide( dvd, dvs, dvd.length - dvs.length, sign, baseOut,
+              // Is least significant digit of integer part an odd number?
+              nArr[nArr.length - 1] & 1 );
+
+            fracArr = fracBN['c'];
+
+            // e can be <= 0  ( if e == 0, fracArr is [0] or [1] ).
+            if ( e = fracBN['e'] ) {
+
+                // Append zeros according to the exponent of the result.
+                for ( ; ++e; fracArr.unshift(0) ) {
+                }
+
+                // Append the fraction part to the converted integer part.
+                nStr = arrToStr(nArr) + '.' + arrToStr(fracArr)
+
+            // fracArr is [1].
+            // Fraction digits rounded up, so increment last digit of integer part.
+            } else if ( fracArr[0] ) {
+
+                if ( nArr[ e = nArr.length - 1 ] < baseOut - 1 ) {
+                    ++nArr[e];
+                    nStr = arrToStr(nArr)
+                } else {
+                    nStr = new BigNumber( arrToStr(nArr),
+                      baseOut )['plus'](ONE)['toS'](baseOut)
+                }
+
+            // fracArr is [0]. No fraction digits.
+            } else {
+                nStr = arrToStr(nArr)
+            }
+        } else {
+
+            // Simple integer. Convert base.
+            nStr = arrToStr( strToArr(nStr) )
+        }
+
+        return nStr
+    }
+
+
+    // Perform division in the specified base. Called by div and convert.
+    function divide( dvd, dvs, exp, s, base, isOdd ) {
+        var dvsL, dvsT, next, cmp, remI,
+            dvsZ = dvs.slice(),
+            dvdI = dvsL = dvs.length,
+            dvdL = dvd.length,
+            rem = dvd.slice( 0, dvsL ),
+            remL = rem.length,
+            quo = new BigNumber(ONE),
+            qc = quo['c'] = [],
+            qi = 0,
+            dig = DECIMAL_PLACES + ( quo['e'] = exp ) + 1;
+
+        quo['s'] = s;
+        s = dig < 0 ? 0 : dig;
+
+        // Add zeros to make remainder as long as divisor.
+        for ( ; remL++ < dvsL; rem.push(0) ) {
+        }
+
+        // Create version of divisor with leading zero.
+        dvsZ.unshift(0);
+
+        do {
+
+            // 'next' is how many times the divisor goes into the current remainder.
+            for ( next = 0; next < base; next++ ) {
+
+                // Compare divisor and remainder.
+                if ( dvsL != ( remL = rem.length ) ) {
+                    cmp = dvsL > remL ? 1 : -1
+                } else {
+                    for ( remI = -1, cmp = 0; ++remI < dvsL; ) {
+
+                        if ( dvs[remI] != rem[remI] ) {
+                            cmp = dvs[remI] > rem[remI] ? 1 : -1;
+                            break
+                        }
+                    }
+                }
+
+                // Subtract divisor from remainder (if divisor < remainder).
+                if ( cmp < 0 ) {
+
+                    // Remainder cannot be more than one digit longer than divisor.
+                    // Equalise lengths using divisor with extra leading zero?
+                    for ( dvsT = remL == dvsL ? dvs : dvsZ; remL; ) {
+
+                        if ( rem[--remL] < dvsT[remL] ) {
+
+                            for ( remI = remL;
+                              remI && !rem[--remI];
+                                rem[remI] = base - 1 ) {
+                            }
+                            --rem[remI];
+                            rem[remL] += base
+                        }
+                        rem[remL] -= dvsT[remL]
+                    }
+                    for ( ; !rem[0]; rem.shift() ) {
+                    }
+                } else {
+                    break
+                }
+            }
+
+            // Add the 'next' digit to the result array.
+            qc[qi++] = cmp ? next : ++next;
+
+            // Update the remainder.
+            rem[0] && cmp
+              ? ( rem[remL] = dvd[dvdI] || 0 )
+              : ( rem = [ dvd[dvdI] ] )
+
+        } while ( ( dvdI++ < dvdL || rem[0] != null ) && s-- );
+
+        // Leading zero? Do not remove if result is simply zero (qi == 1).
+        if ( !qc[0] && qi != 1 ) {
+
+            // There can't be more than one zero.
+            --quo['e'];
+            qc.shift()
+        }
+
+        // Round?
+        if ( qi > dig ) {
+            rnd( quo, DECIMAL_PLACES, base, isOdd, rem[0] != null )
+        }
+
+        // Overflow?
+        if ( quo['e'] > MAX_EXP ) {
+
+            // Infinity.
+            quo['c'] = quo['e'] = null
+
+        // Underflow?
+        } else if ( quo['e'] < MIN_EXP ) {
+
+            // Zero.
+            quo['c'] = [quo['e'] = 0]
+        }
+
+        return quo
+    }
+
+
+    /*
+     * Return a string representing the value of BigNumber n in normal or
+     * exponential notation rounded to the specified decimal places or
+     * significant digits.
+     * Called by toString, toExponential (exp 1), toFixed, and toPrecision (exp 2).
+     * d is the index (with the value in normal notation) of the digit that may be
+     * rounded up.
+     */
+    function format( n, d, exp ) {
+
+        // Initially, i is the number of decimal places required.
+        var i = d - (n = new BigNumber(n))['e'],
+            c = n['c'];
+
+        // +-Infinity or NaN?
+        if ( !c ) {
+            return n['toS']()
+        }
+
+        // Round?
+        if ( c.length > ++d ) {
+            rnd( n, i, 10 )
+        }
+
+        // Recalculate d if toFixed as n['e'] may have changed if value rounded up.
+        i = c[0] == 0 ? i + 1 : exp ? d : n['e'] + i + 1;
+
+        // Append zeros?
+        for ( ; c.length < i; c.push(0) ) {
+        }
+        i = n['e'];
+
+        /*
+         * toPrecision returns exponential notation if the number of significant
+         * digits specified is less than the number of digits necessary to
+         * represent the integer part of the value in normal notation.
+         */
+        return exp == 1 || exp == 2 && ( --d < i || i <= TO_EXP_NEG )
+
+          // Exponential notation.
+          ? ( n['s'] < 0 && c[0] ? '-' : '' ) + ( c.length > 1
+            ? ( c.splice( 1, 0, '.' ), c.join('') )
+            : c[0] ) + ( i < 0 ? 'e' : 'e+' ) + i
+
+          // Normal notation.
+          : n['toS']()
+    }
+
+
+    // Round if necessary.
+    // Called by divide, format, setMode and sqrt.
+    function rnd( x, dp, base, isOdd, r ) {
+        var xc = x['c'],
+            isNeg = x['s'] < 0,
+            half = base / 2,
+            i = x['e'] + dp + 1,
+
+            // 'next' is the digit after the digit that may be rounded up.
+            next = xc[i],
+
+            /*
+             * 'more' is whether there are digits after 'next'.
+             * E.g.
+             * 0.005 (e = -3) to be rounded to 0 decimal places (dp = 0) gives i = -2
+             * The 'next' digit is zero, and there ARE 'more' digits after it.
+             * 0.5 (e = -1) dp = 0 gives i = 0
+             * The 'next' digit is 5 and there are no 'more' digits after it.
+             */
+            more = r || i < 0 || xc[i + 1] != null;
+
+        r = ROUNDING_MODE < 4
+          ? ( next != null || more ) &&
+            ( ROUNDING_MODE == 0 ||
+               ROUNDING_MODE == 2 && !isNeg ||
+                 ROUNDING_MODE == 3 && isNeg )
+          : next > half || next == half &&
+            ( ROUNDING_MODE == 4 || more ||
+
+              /*
+               * isOdd is used in base conversion and refers to the least significant
+               * digit of the integer part of the value to be converted. The fraction
+               * part is rounded by this method separately from the integer part.
+               */
+              ROUNDING_MODE == 6 && ( xc[i - 1] & 1 || !dp && isOdd ) ||
+                ROUNDING_MODE == 7 && !isNeg ||
+                  ROUNDING_MODE == 8 && isNeg );
+
+        if ( i < 1 || !xc[0] ) {
+            xc.length = 0;
+            xc.push(0);
+
+            if ( r ) {
+
+                // 1, 0.1, 0.01, 0.001, 0.0001 etc.
+                xc[0] = 1;
+                x['e'] = -dp
+            } else {
+
+                // Zero.
+                x['e'] = 0
+            }
+
+            return x
+        }
+
+        // Remove any digits after the required decimal places.
+        xc.length = i--;
+
+        // Round up?
+        if ( r ) {
+
+            // Rounding up may mean the previous digit has to be rounded up and so on.
+            for ( --base; ++xc[i] > base; ) {
+                xc[i] = 0;
+
+                if ( !i-- ) {
+                    ++x['e'];
+                    xc.unshift(1)
+                }
+            }
+        }
+
+        // Remove trailing zeros.
+        for ( i = xc.length; !xc[--i]; xc.pop() ) {
+        }
+
+        return x
+    }
+
+
+    // Round after setting the appropriate rounding mode.
+    // Handles ceil, floor and round.
+    function setMode( x, dp, rm ) {
+        var r = ROUNDING_MODE;
+
+        ROUNDING_MODE = rm;
+        x = new BigNumber(x);
+        x['c'] && rnd( x, dp, 10 );
+        ROUNDING_MODE = r;
+
+        return x
+    }
+
+
+    // PROTOTYPE/INSTANCE METHODS
+
+
+    /*
+     * Return a new BigNumber whose value is the absolute value of this BigNumber.
+     */
+    P['abs'] = P['absoluteValue'] = function () {
+        var x = new BigNumber(this);
+
+        if ( x['s'] < 0 ) {
+            x['s'] = 1
+        }
+
+        return x
+    };
+
+
+    /*
+     * Return a new BigNumber whose value is the value of this BigNumber
+     * rounded to a whole number in the direction of Infinity.
+     */
+    P['ceil'] = function () {
+        return setMode( this, 0, 2 )
+    };
+
+
+    /*
+     * Return
+     * 1 if the value of this BigNumber is greater than the value of BigNumber(y, b),
+     * -1 if the value of this BigNumber is less than the value of BigNumber(y, b),
+     * 0 if they have the same value,
+     * or null if the value of either is NaN.
+     */
+    P['comparedTo'] = P['cmp'] = function ( y, b ) {
+        var a,
+            x = this,
+            xc = x['c'],
+            yc = ( id = -id, y = new BigNumber( y, b ) )['c'],
+            i = x['s'],
+            j = y['s'],
+            k = x['e'],
+            l = y['e'];
+
+        // Either NaN?
+        if ( !i || !j ) {
+            return null
+        }
+
+        a = xc && !xc[0], b = yc && !yc[0];
+
+        // Either zero?
+        if ( a || b ) {
+            return a ? b ? 0 : -j : i
+        }
+
+        // Signs differ?
+        if ( i != j ) {
+            return i
+        }
+
+        // Either Infinity?
+        if ( a = i < 0, b = k == l, !xc || !yc ) {
+            return b ? 0 : !xc ^ a ? 1 : -1
+        }
+
+        // Compare exponents.
+        if ( !b ) {
+            return k > l ^ a ? 1 : -1
+        }
+
+        // Compare digit by digit.
+        for ( i = -1,
+              j = ( k = xc.length ) < ( l = yc.length ) ? k : l;
+              ++i < j; ) {
+
+            if ( xc[i] != yc[i] ) {
+                return xc[i] > yc[i] ^ a ? 1 : -1
+            }
+        }
+        // Compare lengths.
+        return k == l ? 0 : k > l ^ a ? 1 : -1
+    };
+
+
+    /*
+     *  n / 0 = I
+     *  n / N = N
+     *  n / I = 0
+     *  0 / n = 0
+     *  0 / 0 = N
+     *  0 / N = N
+     *  0 / I = 0
+     *  N / n = N
+     *  N / 0 = N
+     *  N / N = N
+     *  N / I = N
+     *  I / n = I
+     *  I / 0 = I
+     *  I / N = N
+     *  I / I = N
+     *
+     * Return a new BigNumber whose value is the value of this BigNumber
+     * divided by the value of BigNumber(y, b), rounded according to
+     * DECIMAL_PLACES and ROUNDING_MODE.
+     */
+    P['dividedBy'] = P['div'] = function ( y, b ) {
+        var xc = this['c'],
+            xe = this['e'],
+            xs = this['s'],
+            yc = ( id = 2, y = new BigNumber( y, b ) )['c'],
+            ye = y['e'],
+            ys = y['s'],
+            s = xs == ys ? 1 : -1;
+
+        // Either NaN/Infinity/0?
+        return !xe && ( !xc || !xc[0] ) || !ye && ( !yc || !yc[0] )
+
+          // Either NaN?
+          ? new BigNumber( !xs || !ys ||
+
+            // Both 0 or both Infinity?
+            ( xc ? yc && xc[0] == yc[0] : !yc )
+
+              // Return NaN.
+              ? NaN
+
+              // x is 0 or y is Infinity?
+              : xc && xc[0] == 0 || !yc
+
+                // Return +-0.
+                ? s * 0
+
+                // y is 0. Return +-Infinity.
+                : s / 0 )
+
+          : divide( xc, yc, xe - ye, s, 10 )
+    };
+
+
+    /*
+     * Return true if the value of this BigNumber is equal to the value of
+     * BigNumber(n, b), otherwise returns false.
+     */
+    P['equals'] = P['eq'] = function ( n, b ) {
+        id = 3;
+        return this['cmp']( n, b ) === 0
+    };
+
+
+    /*
+     * Return a new BigNumber whose value is the value of this BigNumber
+     * rounded to a whole number in the direction of -Infinity.
+     */
+    P['floor'] = function () {
+        return setMode( this, 0, 3 )
+    };
+
+
+    /*
+     * Return true if the value of this BigNumber is greater than the value of
+     * BigNumber(n, b), otherwise returns false.
+     */
+    P['greaterThan'] = P['gt'] = function ( n, b ) {
+        id = 4;
+        return this['cmp']( n, b ) > 0
+    };
+
+
+    /*
+     * Return true if the value of this BigNumber is greater than or equal to
+     * the value of BigNumber(n, b), otherwise returns false.
+     */
+    P['greaterThanOrEqualTo'] = P['gte'] = function ( n, b ) {
+        id = 5;
+        return ( b = this['cmp']( n, b ) ) == 1 || b === 0
+    };
+
+
+    /*
+     * Return true if the value of this BigNumber is a finite number, otherwise
+     * returns false.
+     */
+    P['isFinite'] = P['isF'] = function () {
+        return !!this['c']
+    };
+
+
+    /*
+     * Return true if the value of this BigNumber is NaN, otherwise returns
+     * false.
+     */
+    P['isNaN'] = function () {
+        return !this['s']
+    };
+
+
+    /*
+     * Return true if the value of this BigNumber is negative, otherwise
+     * returns false.
+     */
+    P['isNegative'] = P['isNeg'] = function () {
+        return this['s'] < 0
+    };
+
+
+    /*
+     * Return true if the value of this BigNumber is 0 or -0, otherwise returns
+     * false.
+     */
+    P['isZero'] = P['isZ'] = function () {
+        return !!this['c'] && this['c'][0] == 0
+    };
+
+
+    /*
+     * Return true if the value of this BigNumber is less than the value of
+     * BigNumber(n, b), otherwise returns false.
+     */
+    P['lessThan'] = P['lt'] = function ( n, b ) {
+        id = 6;
+        return this['cmp']( n, b ) < 0
+    };
+
+
+    /*
+     * Return true if the value of this BigNumber is less than or equal to the
+     * value of BigNumber(n, b), otherwise returns false.
+     */
+    P['lessThanOrEqualTo'] = P['lte'] = function ( n, b ) {
+        id = 7;
+        return ( b = this['cmp']( n, b ) ) == -1 || b === 0
+    };
+
+
+    /*
+     *  n - 0 = n
+     *  n - N = N
+     *  n - I = -I
+     *  0 - n = -n
+     *  0 - 0 = 0
+     *  0 - N = N
+     *  0 - I = -I
+     *  N - n = N
+     *  N - 0 = N
+     *  N - N = N
+     *  N - I = N
+     *  I - n = I
+     *  I - 0 = I
+     *  I - N = N
+     *  I - I = N
+     *
+     * Return a new BigNumber whose value is the value of this BigNumber minus
+     * the value of BigNumber(y, b).
+     */
+    P['minus'] = function ( y, b ) {
+        var d, i, j, xLTy,
+            x = this,
+            a = x['s'];
+
+        b = ( id = 8, y = new BigNumber( y, b ) )['s'];
+
+        // Either NaN?
+        if ( !a || !b ) {
+            return new BigNumber(NaN)
+        }
+
+        // Signs differ?
+        if ( a != b ) {
+            return y['s'] = -b, x['plus'](y)
+        }
+
+        var xc = x['c'],
+            xe = x['e'],
+            yc = y['c'],
+            ye = y['e'];
+
+        if ( !xe || !ye ) {
+
+            // Either Infinity?
+            if ( !xc || !yc ) {
+                return xc ? ( y['s'] = -b, y ) : new BigNumber( yc ? x : NaN )
+            }
+
+            // Either zero?
+            if ( !xc[0] || !yc[0] ) {
+
+                // y is non-zero?
+                return yc[0]
+                  ? ( y['s'] = -b, y )
+
+                  // x is non-zero?
+                  : new BigNumber( xc[0]
+                    ? x
+
+                    // Both are zero.
+                    // IEEE 754 (2008) 6.3: n - n = -0 when rounding to -Infinity
+                    : ROUNDING_MODE == 3 ? -0 : 0 )
+            }
+        }
+
+        // Determine which is the bigger number.
+        // Prepend zeros to equalise exponents.
+        if ( xc = xc.slice(), a = xe - ye ) {
+            d = ( xLTy = a < 0 ) ? ( a = -a, xc ) : ( ye = xe, yc );
+
+            for ( d.reverse(), b = a; b--; d.push(0) ) {
+            }
+            d.reverse()
+        } else {
+
+            // Exponents equal. Check digit by digit.
+            j = ( ( xLTy = xc.length < yc.length ) ? xc : yc ).length;
+
+            for ( a = b = 0; b < j; b++ ) {
+
+                if ( xc[b] != yc[b] ) {
+                    xLTy = xc[b] < yc[b];
+                    break
+                }
+            }
+        }
+
+        // x < y? Point xc to the array of the bigger number.
+        if ( xLTy ) {
+            d = xc, xc = yc, yc = d;
+            y['s'] = -y['s']
+        }
+
+        /*
+         * Append zeros to xc if shorter. No need to add zeros to yc if shorter
+         * as subtraction only needs to start at yc.length.
+         */
+        if ( ( b = -( ( j = xc.length ) - yc.length ) ) > 0 ) {
+
+            for ( ; b--; xc[j++] = 0 ) {
+            }
+        }
+
+        // Subtract yc from xc.
+        for ( b = yc.length; b > a; ){
+
+            if ( xc[--b] < yc[b] ) {
+
+                for ( i = b; i && !xc[--i]; xc[i] = 9 ) {
+                }
+                --xc[i];
+                xc[b] += 10
+            }
+            xc[b] -= yc[b]
+        }
+
+        // Remove trailing zeros.
+        for ( ; xc[--j] == 0; xc.pop() ) {
+        }
+
+        // Remove leading zeros and adjust exponent accordingly.
+        for ( ; xc[0] == 0; xc.shift(), --ye ) {
+        }
+
+        /*
+         * No need to check for Infinity as +x - +y != Infinity && -x - -y != Infinity
+         * when neither x or y are Infinity.
+         */
+
+        // Underflow?
+        if ( ye < MIN_EXP || !xc[0] ) {
+
+            /*
+             * Following IEEE 754 (2008) 6.3,
+             * n - n = +0  but  n - n = -0 when rounding towards -Infinity.
+             */
+            if ( !xc[0] ) {
+                y['s'] = ROUNDING_MODE == 3 ? -1 : 1
+            }
+
+            // Result is zero.
+            xc = [ye = 0]
+        }
+
+        return y['c'] = xc, y['e'] = ye, y
+    };
+
+
+    /*
+     *   n % 0 =  N
+     *   n % N =  N
+     *   0 % n =  0
+     *  -0 % n = -0
+     *   0 % 0 =  N
+     *   0 % N =  N
+     *   N % n =  N
+     *   N % 0 =  N
+     *   N % N =  N
+     *
+     * Return a new BigNumber whose value is the value of this BigNumber modulo
+     * the value of BigNumber(y, b).
+     */
+    P['modulo'] = P['mod'] = function ( y, b ) {
+        var x = this,
+            xc = x['c'],
+            yc = ( id = 9, y = new BigNumber( y, b ) )['c'],
+            i = x['s'],
+            j = y['s'];
+
+        // Is x or y NaN, or y zero?
+        b = !i || !j || yc && !yc[0];
+
+        if ( b || xc && !xc[0] ) {
+            return new BigNumber( b ? NaN : x )
+        }
+
+        x['s'] = y['s'] = 1;
+        b = y['cmp'](x) == 1;
+        x['s'] = i, y['s'] = j;
+
+        return b
+          ? new BigNumber(x)
+          : ( i = DECIMAL_PLACES, j = ROUNDING_MODE,
+            DECIMAL_PLACES = 0, ROUNDING_MODE = 1,
+              x = x['div'](y),
+                DECIMAL_PLACES = i, ROUNDING_MODE = j,
+                  this['minus']( x['times'](y) ) )
+    };
+
+
+    /*
+     * Return a new BigNumber whose value is the value of this BigNumber
+     * negated, i.e. multiplied by -1.
+     */
+    P['negated'] = P['neg'] = function () {
+        var x = new BigNumber(this);
+
+        return x['s'] = -x['s'] || null, x
+    };
+
+
+    /*
+     *  n + 0 = n
+     *  n + N = N
+     *  n + I = I
+     *  0 + n = n
+     *  0 + 0 = 0
+     *  0 + N = N
+     *  0 + I = I
+     *  N + n = N
+     *  N + 0 = N
+     *  N + N = N
+     *  N + I = N
+     *  I + n = I
+     *  I + 0 = I
+     *  I + N = N
+     *  I + I = I
+     *
+     * Return a new BigNumber whose value is the value of this BigNumber plus
+     * the value of BigNumber(y, b).
+     */
+    P['plus'] = function ( y, b ) {
+        var d,
+            x = this,
+            a = x['s'];
+
+        b = ( id = 10, y = new BigNumber( y, b ) )['s'];
+
+        // Either NaN?
+        if ( !a || !b ) {
+            return new BigNumber(NaN)
+        }
+
+        // Signs differ?
+        if ( a != b ) {
+            return y['s'] = -b, x['minus'](y)
+        }
+
+        var xe = x['e'],
+            xc = x['c'],
+            ye = y['e'],
+            yc = y['c'];
+
+        if ( !xe || !ye ) {
+
+            // Either Infinity?
+            if ( !xc || !yc ) {
+
+                // Return +-Infinity.
+                return new BigNumber( a / 0 )
+            }
+
+            // Either zero?
+            if ( !xc[0] || !yc[0] ) {
+
+                // y is non-zero?
+                return yc[0]
+                  ? y
+
+                  // x is non-zero?
+                  : new BigNumber( xc[0]
+                    ? x
+
+                    // Both are zero. Return zero.
+                    : a * 0 )
+            }
+        }
+
+        // Prepend zeros to equalise exponents.
+        // Note: Faster to use reverse then do unshifts.
+        if ( xc = xc.slice(), a = xe - ye ) {
+            d = a > 0 ? ( ye = xe, yc ) : ( a = -a, xc );
+
+            for ( d.reverse(); a--; d.push(0) ) {
+            }
+            d.reverse()
+        }
+
+        // Point xc to the longer array.
+        if ( xc.length - yc.length < 0 ) {
+            d = yc, yc = xc, xc = d
+        }
+
+        /*
+         * Only start adding at yc.length - 1 as the
+         * further digits of xc can be left as they are.
+         */
+        for ( a = yc.length, b = 0; a;
+             b = ( xc[--a] = xc[a] + yc[a] + b ) / 10 ^ 0, xc[a] %= 10 ) {
+        }
+
+        // No need to check for zero, as +x + +y != 0 && -x + -y != 0
+
+        if ( b ) {
+            xc.unshift(b);
+
+            // Overflow? (MAX_EXP + 1 possible)
+            if ( ++ye > MAX_EXP ) {
+
+                // Infinity.
+                xc = ye = null
+            }
+        }
+
+         // Remove trailing zeros.
+        for ( a = xc.length; xc[--a] == 0; xc.pop() ) {
+        }
+
+        return y['c'] = xc, y['e'] = ye, y
+    };
+
+
+    /*
+     * Return a BigNumber whose value is the value of this BigNumber raised to
+     * the power e. If e is negative round according to DECIMAL_PLACES and
+     * ROUNDING_MODE.
+     *
+     * e {number} Integer, -MAX_POWER to MAX_POWER inclusive.
+     */
+    P['toPower'] = P['pow'] = function ( e ) {
+
+        // e to integer, avoiding NaN or Infinity becoming 0.
+        var i = e * 0 == 0 ? e | 0 : e,
+            x = new BigNumber(this),
+            y = new BigNumber(ONE);
+
+        // Use Math.pow?
+        // Pass +-Infinity for out of range exponents.
+        if ( ( ( ( outOfRange = e < -MAX_POWER || e > MAX_POWER ) &&
+          (i = e * 1 / 0) ) ||
+
+             /*
+              * Any exponent that fails the parse becomes NaN.
+              *
+              * Include 'e !== 0' because on Opera -0 == parseFloat(-0) is false,
+              * despite -0 === parseFloat(-0) && -0 == parseFloat('-0') is true.
+              */
+             parse(e) != e && e !== 0 && !(i = NaN) ) &&
+
+              // 'pow() exponent not an integer: {e}'
+              // 'pow() exponent out of range: {e}'
+              !ifExceptionsThrow( e, 'exponent', 'pow' ) ||
+
+                // Pass zero to Math.pow, as any value to the power zero is 1.
+                !i ) {
+
+            // i is +-Infinity, NaN or 0.
+            return new BigNumber( Math.pow( x['toS'](), i ) )
+        }
+
+        for ( i = i < 0 ? -i : i; ; ) {
+
+            if ( i & 1 ) {
+                y = y['times'](x)
+            }
+            i >>= 1;
+
+            if ( !i ) {
+                break
+            }
+            x = x['times'](x)
+        }
+
+        return e < 0 ? ONE['div'](y) : y
+    };
+
+
+    /*
+     * Return a new BigNumber whose value is the value of this BigNumber
+     * rounded to a maximum of dp decimal places using rounding mode rm, or to
+     * 0 and ROUNDING_MODE respectively if omitted.
+     *
+     * [dp] {number} Integer, 0 to MAX inclusive.
+     * [rm] {number} Integer, 0 to 8 inclusive.
+     */
+    P['round'] = function ( dp, rm ) {
+
+        dp = dp == null || ( ( ( outOfRange = dp < 0 || dp > MAX ) ||
+          parse(dp) != dp ) &&
+
+            // 'round() decimal places out of range: {dp}'
+            // 'round() decimal places not an integer: {dp}'
+            !ifExceptionsThrow( dp, 'decimal places', 'round' ) )
+              ? 0
+              : dp | 0;
+
+        rm = rm == null || ( ( ( outOfRange = rm < 0 || rm > 8 ) ||
+
+          // Include '&& rm !== 0' because with Opera -0 == parseFloat(-0) is false.
+          parse(rm) != rm && rm !== 0 ) &&
+
+            // 'round() mode not an integer: {rm}'
+            // 'round() mode out of range: {rm}'
+            !ifExceptionsThrow( rm, 'mode', 'round' ) )
+              ? ROUNDING_MODE
+              : rm | 0;
+
+        return setMode( this, dp, rm )
+    };
+
+
+    /*
+     *  sqrt(-n) =  N
+     *  sqrt( N) =  N
+     *  sqrt(-I) =  N
+     *  sqrt( I) =  I
+     *  sqrt( 0) =  0
+     *  sqrt(-0) = -0
+     *
+     * Return a new BigNumber whose value is the square root of the value of
+     * this BigNumber, rounded according to DECIMAL_PLACES and ROUNDING_MODE.
+     */
+    P['squareRoot'] = P['sqrt'] = function () {
+        var i, n, r, re, t,
+            x = this,
+            c = x['c'],
+            s = x['s'],
+            e = x['e'],
+            dp = DECIMAL_PLACES,
+            rm = ROUNDING_MODE,
+            half = new BigNumber('0.5');
+
+        // Negative/NaN/Infinity/zero?
+        if ( s !== 1 || !c || !c[0] ) {
+
+            return new BigNumber( !s || s < 0 && ( !c || c[0] )
+              ? NaN
+              : c ? x : 1 / 0 )
+        }
+
+        // Initial estimate.
+        s = Math.sqrt( x['toS']() );
+        ROUNDING_MODE = 1;
+
+        /*
+          Math.sqrt underflow/overflow?
+          Pass x to Math.sqrt as integer, then adjust the exponent of the result.
+         */
+        if ( s == 0 || s == 1 / 0 ) {
+            n = c.join('');
+
+            if ( !( n.length + e & 1 ) ) {
+                n += '0'
+            }
+            r = new BigNumber( Math.sqrt(n) + '' );
+
+            // r may still not be finite.
+            if ( !r['c'] ) {
+                r['c'] = [1]
+            }
+            r['e'] = ( ( ( e + 1 ) / 2 ) | 0 ) - ( e < 0 || e & 1 )
+        } else {
+            r = new BigNumber( n = s.toString() )
+        }
+        re = r['e'];
+        s = re + ( DECIMAL_PLACES += 4 );
+
+        if ( s < 3 ) {
+            s = 0
+        }
+        e = s;
+
+        // Newton-Raphson iteration.
+        for ( ; ; ) {
+            t = r;
+            r = half['times']( t['plus']( x['div'](t) ) );
+
+            if ( t['c'].slice( 0, s ).join('') === r['c'].slice( 0, s ).join('') ) {
+                c = r['c'];
+
+                /*
+                  The exponent of r may here be one less than the final result
+                  exponent (re), e.g 0.0009999 (e-4) --> 0.001 (e-3), so adjust
+                  s so the rounding digits are indexed correctly.
+                 */
+                s = s - ( n && r['e'] < re );
+
+                /*
+                  The 4th rounding digit may be in error by -1 so if the 4 rounding
+                  digits are 9999 or 4999 (i.e. approaching a rounding boundary)
+                  continue the iteration.
+                 */
+                if ( c[s] == 9 && c[s - 1] == 9 && c[s - 2] == 9 &&
+                        ( c[s - 3] == 9 || n && c[s - 3] == 4 ) ) {
+
+                    /*
+                      If 9999 on first run through, check to see if rounding up
+                      gives the exact result as the nines may infinitely repeat.
+                     */
+                    if ( n && c[s - 3] == 9 ) {
+                        t = r['round']( dp, 0 );
+
+                        if ( t['times'](t)['eq'](x) ) {
+                            ROUNDING_MODE = rm;
+                            DECIMAL_PLACES = dp;
+
+                            return t
+                        }
+                    }
+                    DECIMAL_PLACES += 4;
+                    s += 4;
+                    n = ''
+                } else {
+
+                    /*
+                      If the rounding digits are null, 0000 or 5000, check for an
+                      exact result. If not, then there are further digits so
+                      increment the 1st rounding digit to ensure correct rounding.
+                     */
+                    if ( !c[e] && !c[e - 1] && !c[e - 2] &&
+                            ( !c[e - 3] || c[e - 3] == 5 ) ) {
+
+                        // Truncate to the first rounding digit.
+                        if ( c.length > e - 2 ) {
+                            c.length = e - 2
+                        }
+
+                        if ( !r['times'](r)['eq'](x) ) {
+
+                            while ( c.length < e - 3 ) {
+                                c.push(0)
+                            }
+                            c[e - 3]++
+                        }
+                    }
+                    ROUNDING_MODE = rm;
+                    rnd( r, DECIMAL_PLACES = dp, 10 );
+
+                    return r
+                }
+            }
+        }
+    };
+
+
+    /*
+     *  n * 0 = 0
+     *  n * N = N
+     *  n * I = I
+     *  0 * n = 0
+     *  0 * 0 = 0
+     *  0 * N = N
+     *  0 * I = N
+     *  N * n = N
+     *  N * 0 = N
+     *  N * N = N
+     *  N * I = N
+     *  I * n = I
+     *  I * 0 = N
+     *  I * N = N
+     *  I * I = I
+     *
+     * Return a new BigNumber whose value is the value of this BigNumber times
+     * the value of BigNumber(y, b).
+     */
+    P['times'] = function ( y, b ) {
+        var c,
+            x = this,
+            xc = x['c'],
+            yc = ( id = 11, y = new BigNumber( y, b ) )['c'],
+            i = x['e'],
+            j = y['e'],
+            a = x['s'];
+
+        y['s'] = a == ( b = y['s'] ) ? 1 : -1;
+
+        // Either NaN/Infinity/0?
+        if ( !i && ( !xc || !xc[0] ) || !j && ( !yc || !yc[0] ) ) {
+
+            // Either NaN?
+            return new BigNumber( !a || !b ||
+
+              // x is 0 and y is Infinity  or  y is 0 and x is Infinity?
+              xc && !xc[0] && !yc || yc && !yc[0] && !xc
+
+                // Return NaN.
+                ? NaN
+
+                // Either Infinity?
+                : !xc || !yc
+
+                  // Return +-Infinity.
+                  ? y['s'] / 0
+
+                  // x or y is 0. Return +-0.
+                  : y['s'] * 0 )
+        }
+        y['e'] = i + j;
+
+        if ( ( a = xc.length ) < ( b = yc.length ) ) {
+            c = xc, xc = yc, yc = c, j = a, a = b, b = j
+        }
+
+        for ( j = a + b, c = []; j--; c.push(0) ) {
+        }
+
+        // Multiply!
+        for ( i = b - 1; i > -1; i-- ) {
+
+            for ( b = 0, j = a + i;
+                  j > i;
+                  b = c[j] + yc[i] * xc[j - i - 1] + b,
+                  c[j--] = b % 10 | 0,
+                  b = b / 10 | 0 ) {
+            }
+
+            if ( b ) {
+                c[j] = ( c[j] + b ) % 10
+            }
+        }
+
+        b && ++y['e'];
+
+        // Remove any leading zero.
+        !c[0] && c.shift();
+
+        // Remove trailing zeros.
+        for ( j = c.length; !c[--j]; c.pop() ) {
+        }
+
+        // No zero check needed as only x * 0 == 0 etc.
+
+        // Overflow?
+        y['c'] = y['e'] > MAX_EXP
+
+          // Infinity.
+          ? ( y['e'] = null )
+
+          // Underflow?
+          : y['e'] < MIN_EXP
+
+            // Zero.
+            ? [ y['e'] = 0 ]
+
+            // Neither.
+            : c;
+
+        return y
+    };
+
+
+    /*
+     * Return a string representing the value of this BigNumber in exponential
+     * notation to dp fixed decimal places and rounded using ROUNDING_MODE if
+     * necessary.
+     *
+     * [dp] {number} Integer, 0 to MAX inclusive.
+     */
+    P['toExponential'] = P['toE'] = function ( dp ) {
+
+        return format( this,
+          ( dp == null || ( ( outOfRange = dp < 0 || dp > MAX ) ||
+
+            /*
+             * Include '&& dp !== 0' because with Opera -0 == parseFloat(-0) is
+             * false, despite -0 == parseFloat('-0') && 0 == -0 being true.
+             */
+            parse(dp) != dp && dp !== 0 ) &&
+
+              // 'toE() decimal places not an integer: {dp}'
+              // 'toE() decimal places out of range: {dp}'
+              !ifExceptionsThrow( dp, 'decimal places', 'toE' ) ) && this['c']
+                ? this['c'].length - 1
+                : dp | 0, 1 )
+    };
+
+
+    /*
+     * Return a string representing the value of this BigNumber in normal
+     * notation to dp fixed decimal places and rounded using ROUNDING_MODE if
+     * necessary.
+     *
+     * Note: as with JavaScript's number type, (-0).toFixed(0) is '0',
+     * but e.g. (-0.00001).toFixed(0) is '-0'.
+     *
+     * [dp] {number} Integer, 0 to MAX inclusive.
+     */
+    P['toFixed'] = P['toF'] = function ( dp ) {
+        var n, str, d,
+            x = this;
+
+        if ( !( dp == null || ( ( outOfRange = dp < 0 || dp > MAX ) ||
+            parse(dp) != dp && dp !== 0 ) &&
+
+            // 'toF() decimal places not an integer: {dp}'
+            // 'toF() decimal places out of range: {dp}'
+            !ifExceptionsThrow( dp, 'decimal places', 'toF' ) ) ) {
+              d = x['e'] + ( dp | 0 )
+        }
+
+        n = TO_EXP_NEG, dp = TO_EXP_POS;
+        TO_EXP_NEG = -( TO_EXP_POS = 1 / 0 );
+
+        // Note: str is initially undefined.
+        if ( d == str ) {
+            str = x['toS']()
+        } else {
+            str = format( x, d );
+
+            // (-0).toFixed() is '0', but (-0.1).toFixed() is '-0'.
+            // (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'.
+            if ( x['s'] < 0 && x['c'] ) {
+
+                // As e.g. -0 toFixed(3), will wrongly be returned as -0.000 from toString.
+                if ( !x['c'][0] ) {
+                    str = str.replace(/^-/, '')
+
+                // As e.g. -0.5 if rounded to -0 will cause toString to omit the minus sign.
+                } else if ( str.indexOf('-') < 0 ) {
+                    str = '-' + str
+                }
+            }
+        }
+        TO_EXP_NEG = n, TO_EXP_POS = dp;
+
+        return str
+    };
+
+
+    /*
+     * Return a string array representing the value of this BigNumber as a
+     * simple fraction with an integer numerator and an integer denominator.
+     * The denominator will be a positive non-zero value less than or equal to
+     * the specified maximum denominator. If a maximum denominator is not
+     * specified, the denominator will be the lowest value necessary to
+     * represent the number exactly.
+     *
+     * [maxD] {number|string|BigNumber} Integer >= 1 and < Infinity.
+     */
+    P['toFraction'] = P['toFr'] = function ( maxD ) {
+        var q, frac, n0, d0, d2, n, e,
+            n1 = d0 = new BigNumber(ONE),
+            d1 = n0 = new BigNumber('0'),
+            x = this,
+            xc = x['c'],
+            exp = MAX_EXP,
+            dp = DECIMAL_PLACES,
+            rm = ROUNDING_MODE,
+            d = new BigNumber(ONE);
+
+        // NaN, Infinity.
+        if ( !xc ) {
+            return x['toS']()
+        }
+
+        e = d['e'] = xc.length - x['e'] - 1;
+
+        // If max denominator is undefined or null...
+        if ( maxD == null ||
+
+             // or NaN...
+             ( !( id = 12, n = new BigNumber(maxD) )['s'] ||
+
+               // or less than 1, or Infinity...
+               ( outOfRange = n['cmp'](n1) < 0 || !n['c'] ) ||
+
+                 // or not an integer...
+                 ( ERRORS && n['e'] < n['c'].length - 1 ) ) &&
+
+                   // 'toFr() max denominator not an integer: {maxD}'
+                   // 'toFr() max denominator out of range: {maxD}'
+                   !ifExceptionsThrow( maxD, 'max denominator', 'toFr' ) ||
+
+                     // or greater than the maxD needed to specify the value exactly...
+                     ( maxD = n )['cmp'](d) > 0 ) {
+
+            // d is e.g. 10, 100, 1000, 10000... , n1 is 1.
+            maxD = e > 0 ? d : n1
+        }
+
+        MAX_EXP = 1 / 0;
+        n = new BigNumber( xc.join('') );
+
+        for ( DECIMAL_PLACES = 0, ROUNDING_MODE = 1; ; )  {
+            q = n['div'](d);
+            d2 = d0['plus']( q['times'](d1) );
+
+            if ( d2['cmp'](maxD) == 1 ) {
+                break
+            }
+
+            d0 = d1, d1 = d2;
+
+            n1 = n0['plus']( q['times']( d2 = n1 ) );
+            n0 = d2;
+
+            d = n['minus']( q['times']( d2 = d ) );
+            n = d2
+        }
+
+        d2 = maxD['minus'](d0)['div'](d1);
+        n0 = n0['plus']( d2['times'](n1) );
+        d0 = d0['plus']( d2['times'](d1) );
+
+        n0['s'] = n1['s'] = x['s'];
+
+        DECIMAL_PLACES = e * 2;
+        ROUNDING_MODE = rm;
+
+        // Determine which fraction is closer to x, n0 / d0 or n1 / d1?
+        frac = n1['div'](d1)['minus'](x)['abs']()['cmp'](
+          n0['div'](d0)['minus'](x)['abs']() ) < 1
+          ? [ n1['toS'](), d1['toS']() ]
+          : [ n0['toS'](), d0['toS']() ];
+
+        return MAX_EXP = exp, DECIMAL_PLACES = dp, frac
+    };
+
+
+    /*
+     * Return a string representing the value of this BigNumber to sd significant
+     * digits and rounded using ROUNDING_MODE if necessary.
+     * If sd is less than the number of digits necessary to represent the integer
+     * part of the value in normal notation, then use exponential notation.
+     *
+     * sd {number} Integer, 1 to MAX inclusive.
+     */
+    P['toPrecision'] = P['toP'] = function ( sd ) {
+
+        /*
+         * ERRORS true: Throw if sd not undefined, null or an integer in range.
+         * ERRORS false: Ignore sd if not a number or not in range.
+         * Truncate non-integers.
+         */
+        return sd == null || ( ( ( outOfRange = sd < 1 || sd > MAX ) ||
+          parse(sd) != sd ) &&
+
+            // 'toP() precision not an integer: {sd}'
+            // 'toP() precision out of range: {sd}'
+            !ifExceptionsThrow( sd, 'precision', 'toP' ) )
+              ? this['toS']()
+              : format( this, --sd | 0, 2 )
+    };
+
+
+    /*
+     * Return a string representing the value of this BigNumber in base b, or
+     * base 10 if b is omitted. If a base is specified, including base 10,
+     * round according to DECIMAL_PLACES and ROUNDING_MODE.
+     * If a base is not specified, and this BigNumber has a positive exponent
+     * that is equal to or greater than TO_EXP_POS, or a negative exponent equal
+     * to or less than TO_EXP_NEG, return exponential notation.
+     *
+     * [b] {number} Integer, 2 to 64 inclusive.
+     */
+    P['toString'] = P['toS'] = function ( b ) {
+        var u, str, strL,
+            x = this,
+            xe = x['e'];
+
+        // Infinity or NaN?
+        if ( xe === null ) {
+            str = x['s'] ? 'Infinity' : 'NaN'
+
+        // Exponential format?
+        } else if ( b === u && ( xe <= TO_EXP_NEG || xe >= TO_EXP_POS ) ) {
+            return format( x, x['c'].length - 1, 1 )
+        } else {
+            str = x['c'].join('');
+
+            // Negative exponent?
+            if ( xe < 0 ) {
+
+                // Prepend zeros.
+                for ( ; ++xe; str = '0' + str ) {
+                }
+                str = '0.' + str
+
+            // Positive exponent?
+            } else if ( strL = str.length, xe > 0 ) {
+
+                if ( ++xe > strL ) {
+
+                    // Append zeros.
+                    for ( xe -= strL; xe-- ; str += '0' ) {
+                    }
+                } else if ( xe < strL ) {
+                    str = str.slice( 0, xe ) + '.' + str.slice(xe)
+                }
+
+            // Exponent zero.
+            } else {
+                if ( u = str.charAt(0), strL > 1 ) {
+                    str = u + '.' + str.slice(1)
+
+                // Avoid '-0'
+                } else if ( u == '0' ) {
+                    return u
+                }
+            }
+
+            if ( b != null ) {
+
+                if ( !( outOfRange = !( b >= 2 && b < 65 ) ) &&
+                  ( b == (b | 0) || !ERRORS ) ) {
+                    str = convert( str, b | 0, 10, x['s'] );
+
+                    // Avoid '-0'
+                    if ( str == '0' ) {
+                        return str
+                    }
+                } else {
+
+                    // 'toS() base not an integer: {b}'
+                    // 'toS() base out of range: {b}'
+                    ifExceptionsThrow( b, 'base', 'toS' )
+                }
+            }
+
+        }
+
+        return x['s'] < 0 ? '-' + str : str
+    };
+
+
+    /*
+     * Return as toString, but do not accept a base argument.
+     */
+    P['valueOf'] = function () {
+        return this['toS']()
+    };
+
+
+    // Add aliases for BigDecimal methods.
+    //P['add'] = P['plus'];
+    //P['subtract'] = P['minus'];
+    //P['multiply'] = P['times'];
+    //P['divide'] = P['div'];
+    //P['remainder'] = P['mod'];
+    //P['compareTo'] = P['cmp'];
+    //P['negate'] = P['neg'];
+
+
+    // EXPORT
+
+
+    // Node and other CommonJS-like environments that support module.exports.
+    if ( typeof module !== 'undefined' && module.exports ) {
+        module.exports = BigNumber
+
+    //AMD.
+    } else if ( typeof define == 'function' && define.amd ) {
+        define( function () {
+            return BigNumber
+        })
+
+    //Browser.
+    } else {
+        global['BigNumber'] = BigNumber
+    }
+
+})( this );
+
+
+},{}]},{},[1])
+(1)
+});
+;/**
+ * Compatibility shims for legacy JavaScript engines
+ */
+
+// http://soledadpenades.com/2007/05/17/arrayindexof-in-internet-explorer/
+if(!Array.prototype.indexOf) {
+  Array.prototype.indexOf = function(obj){
+    for(var i = 0; i < this.length; i++){
+      if(this[i] == obj){
+        return i;
+      }
+    }
+    return -1;
+  };
+}
+
+// https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/forEach
+if (!Array.prototype.forEach) {
+  Array.prototype.forEach = function(fn, scope) {
+    for(var i = 0, len = this.length; i < len; ++i) {
+      fn.call(scope || this, this[i], i, this);
+    }
+  }
+}
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray
+if(!Array.isArray) {
+  Array.isArray = function (vArg) {
+    return Object.prototype.toString.call(vArg) === "[object Array]";
+  };
+}
+
+// https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/map
+// Production steps of ECMA-262, Edition 5, 15.4.4.19
+// Reference: http://es5.github.com/#x15.4.4.19
+if (!Array.prototype.map) {
+  Array.prototype.map = function(callback, thisArg) {
+
+    var T, A, k;
+
+    if (this == null) {
+      throw new TypeError(" this is null or not defined");
+    }
+
+    // 1. Let O be the result of calling ToObject passing the |this| value as the argument.
+    var O = Object(this);
+
+    // 2. Let lenValue be the result of calling the Get internal method of O with the argument "length".
+    // 3. Let len be ToUint32(lenValue).
+    var len = O.length >>> 0;
+
+    // 4. If IsCallable(callback) is false, throw a TypeError exception.
+    // See: http://es5.github.com/#x9.11
+    if (typeof callback !== "function") {
+      throw new TypeError(callback + " is not a function");
+    }
+
+    // 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
+    if (thisArg) {
+      T = thisArg;
+    }
+
+    // 6. Let A be a new array created as if by the expression new Array(len) where Array is
+    // the standard built-in constructor with that name and len is the value of len.
+    A = new Array(len);
+
+    // 7. Let k be 0
+    k = 0;
+
+    // 8. Repeat, while k < len
+    while(k < len) {
+
+      var kValue, mappedValue;
+
+      // a. Let Pk be ToString(k).
+      //   This is implicit for LHS operands of the in operator
+      // b. Let kPresent be the result of calling the HasProperty internal method of O with argument Pk.
+      //   This step can be combined with c
+      // c. If kPresent is true, then
+      if (k in O) {
+
+        // i. Let kValue be the result of calling the Get internal method of O with argument Pk.
+        kValue = O[ k ];
+
+        // ii. Let mappedValue be the result of calling the Call internal method of callback
+        // with T as the this value and argument list containing kValue, k, and O.
+        mappedValue = callback.call(T, kValue, k, O);
+
+        // iii. Call the DefineOwnProperty internal method of A with arguments
+        // Pk, Property Descriptor {Value: mappedValue, : true, Enumerable: true, Configurable: true},
+        // and false.
+
+        // In browsers that support Object.defineProperty, use the following:
+        // Object.defineProperty(A, Pk, { value: mappedValue, writable: true, enumerable: true, configurable: true });
+
+        // For best browser support, use the following:
+        A[ k ] = mappedValue;
+      }
+      // d. Increase k by 1.
+      k++;
+    }
+
+    // 9. return A
+    return A;
+  };
+}
+
+// https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/every
+if (!Array.prototype.every) {
+  Array.prototype.every = function(fun /*, thisp */) {
+    "use strict";
+
+    if (this == null) {
+      throw new TypeError();
+    }
+
+    var t = Object(this);
+    var len = t.length >>> 0;
+    if (typeof fun != "function") {
+      throw new TypeError();
+    }
+
+    var thisp = arguments[1];
+    for (var i = 0; i < len; i++) {
+      if (i in t && !fun.call(thisp, t[i], i, t)) {
+        return false;
+      }
+    }
+
+    return true;
+  };
+}
+
+// https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/some
+if (!Array.prototype.some) {
+  Array.prototype.some = function(fun /*, thisp */) {
+    "use strict";
+
+    if (this == null) {
+      throw new TypeError();
+    }
+
+    var t = Object(this);
+    var len = t.length >>> 0;
+    if (typeof fun != "function") {
+      throw new TypeError();
+    }
+
+    var thisp = arguments[1];
+    for (var i = 0; i < len; i++) {
+      if (i in t && fun.call(thisp, t[i], i, t)) {
+        return true;
+      }
+    }
+
+    return false;
+  };
+}
+
+// https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Function/bind
+if (!Function.prototype.bind) {
+  Function.prototype.bind = function (oThis) {
+    if (typeof this !== "function") {
+      // closest thing possible to the ECMAScript 5 internal IsCallable function
+      throw new TypeError("Function.prototype.bind - what is trying to be bound is not callable");
+    }
+
+    var aArgs = Array.prototype.slice.call(arguments, 1),
+        fToBind = this,
+        fNOP = function () {},
+        fBound = function () {
+          return fToBind.apply(this instanceof fNOP && oThis
+              ? this
+              : oThis,
+              aArgs.concat(Array.prototype.slice.call(arguments)));
+        };
+
+    fNOP.prototype = this.prototype;
+    fBound.prototype = new fNOP();
+
+    return fBound;
+  };
+}
diff --git a/ajax/libs/mathjs/0.16.0/math.min.js b/ajax/libs/mathjs/0.16.0/math.min.js
new file mode 100644
index 000000000..be7b8404e
--- /dev/null
+++ b/ajax/libs/mathjs/0.16.0/math.min.js
@@ -0,0 +1,32 @@
+/**
+ * math.js
+ * https://github.com/josdejong/mathjs
+ *
+ * Math.js is an extensive math library for JavaScript and Node.js,
+ * It features real and complex numbers, units, matrices, a large set of
+ * mathematical functions, and a flexible expression parser.
+ *
+ * @version 0.16.0
+ * @date    2013-11-28
+ *
+ * @license
+ * Copyright (C) 2013 Jos de Jong <wjosdejong@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy
+ * of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+!function(e){"object"==typeof exports?module.exports=e():"function"==typeof define&&define.amd?define(e):"undefined"!=typeof window?window.mathjs=e():"undefined"!=typeof global?global.mathjs=e():"undefined"!=typeof self&&(self.mathjs=e())}(function(){var e;return function n(e,t,r){function i(a,s){if(!t[a]){if(!e[a]){var u="function"==typeof require&&require;if(!s&&u)return u(a,!0);if(o)return o(a,!0);throw new Error("Cannot find module '"+a+"'")}var c=t[a]={exports:{}};e[a][0].call(c.exports,function(n){var t=e[a][1][n];return i(t?t:n)},c,c.exports,n,e,t,r)}return t[a].exports}for(var o="function"==typeof require&&require,a=0;a<r.length;a++)i(r[a]);return i}({1:[function(e,n){n.exports=e("./lib/math.js")},{"./lib/math.js":201}],2:[function(e,n){n.exports=function(n){function t(e){if(!(this instanceof t))throw new SyntaxError("Selector constructor must be called with the new operator");this.value=e instanceof t?e.value:e}function r(e,n){var r=Array.prototype.slice;t.prototype[e]="function"==typeof n?function(){var e=[this.value].concat(r.call(arguments,0));return new t(n.apply(this,e))}:new t(n)}var i=e("../util/string");t.prototype.done=function(){return this.value},t.prototype.get=function(){throw new Error("Selector.get is removed. Use Selector.subset(index) instead.")},t.prototype.set=function(){throw new Error("Selector.set is removed. Use Selector.subset(index, replacement) instead.")},t.prototype.valueOf=function(){return this.value},t.prototype.toString=function(){return i.format(this.value)},t.createProxy=r;for(var o in n)n.hasOwnProperty(o)&&o&&r(o,n[o]);return t}},{"../util/string":215}],3:[function(e,n){n.exports=function(n){var t=e("./type/Complex");n.pi=Math.PI,n.e=Math.E,n.tau=2*Math.PI,n.i=new t(0,1),n.Infinity=1/0,n.NaN=0/0,n["true"]=!0,n["false"]=!1,n.E=Math.E,n.LN2=Math.LN2,n.LN10=Math.LN10,n.LOG2E=Math.LOG2E,n.LOG10E=Math.LOG10E,n.PI=Math.PI,n.SQRT1_2=Math.SQRT1_2,n.SQRT2=Math.SQRT2}},{"./type/Complex":202}],4:[function(e,n){function t(e){if(!(this instanceof t))throw new SyntaxError("Parser constructor must be called with the new operator");this.math=e,this.scope=new r(e)}var r=e("./Scope");t.prototype.parse=function(e){return this.math.parse(e,this.scope)},t.prototype.eval=function(e){var n=this.math.parse(e,this.scope);return n.eval()},t.prototype.get=function(e){return this.scope.get(e)},t.prototype.set=function(e,n){return this.scope.set(e,n)},t.prototype.remove=function(e){this.scope.remove(e)},t.prototype.clear=function(){this.scope.clear()},n.exports=t},{"./Scope":5}],5:[function(e,n){function t(e,n,r){this.math=e,this.parentScope=null,this.subScopes=null,this.symbols={},this.cache={},n&&(n instanceof t?this.parentScope=n:n instanceof Object&&(this.symbols=n)),r&&r instanceof Object&&(this.symbols=r)}var r=e("../type/Unit");t.prototype={createSubScope:function(){var e=new t(this.math,this);return this.subScopes||(this.subScopes=[]),this.subScopes.push(e),e},get:function(e){var n;if(n=this.symbols[e],void 0!==n)return n;var t=this.cache[e];if(t)return t[e];for(var i=this.parentScope;i;){if(n=i.symbols[e],void 0!==n)return this.cache[e]=i.symbols,n;i=i.parentScope}return n=this.math[e],void 0!==n?(this.cache[e]=this.math,n):r.isPlainUnit(e)?(n=new r(null,e),this.cache[e]={},this.cache[e][e]=n,n):void 0},has:function(e){return void 0!==this.symbols[e]},set:function(e,n){return this.symbols[e]=n},remove:function(e){delete this.symbols[e]},clear:function(){var e=this.symbols;for(var n in e)e.hasOwnProperty(n)&&delete e[n];if(this.subScopes)for(var t=this.subScopes,r=0,i=t.length;i>r;r++)t[r].clear();this.clearCache()},clearCache:function(){this.cache={}}},t.context=[],n.exports=t},{"../type/Unit":207}],6:[function(e,n){n.exports={name:"Infinity",category:"Constants",syntax:["Infinity"],description:"Infinity, a number which is larger than the maximum number that can be handled by a floating point number.",examples:["Infinity","1 / 0"],seealso:[]}},{}],7:[function(e,n){n.exports={name:"LN10",category:"Constants",syntax:["LN10"],description:"Returns the natural logarithm of 10, approximately equal to 2.302",examples:["LN10","log(10)"],seealso:[]}},{}],8:[function(e,n){n.exports={name:"LN2",category:"Constants",syntax:["LN2"],description:"Returns the natural logarithm of 2, approximately equal to 0.693",examples:["LN2","log(2)"],seealso:[]}},{}],9:[function(e,n){n.exports={name:"LOG10E",category:"Constants",syntax:["LOG10E"],description:"Returns the base-10 logarithm of E, approximately equal to 0.434",examples:["LOG10E","log(e, 10)"],seealso:[]}},{}],10:[function(e,n){n.exports={name:"LOG2E",category:"Constants",syntax:["LOG2E"],description:"Returns the base-2 logarithm of E, approximately equal to 1.442",examples:["LOG2E","log(e, 2)"],seealso:[]}},{}],11:[function(e,n){n.exports={name:"NaN",category:"Constants",syntax:["NaN"],description:"Not a number",examples:["NaN","0 / 0"],seealso:[]}},{}],12:[function(e,n){n.exports={name:"SQRT1_2",category:"Constants",syntax:["SQRT1_2"],description:"Returns the square root of 1/2, approximately equal to 0.707",examples:["SQRT1_2","sqrt(1/2)"],seealso:[]}},{}],13:[function(e,n){n.exports={name:"SQRT2",category:"Constants",syntax:["SQRT2"],description:"Returns the square root of 2, approximately equal to 1.414",examples:["SQRT2","sqrt(2)"],seealso:[]}},{}],14:[function(e,n){n.exports={name:"e",category:"Constants",syntax:["e"],description:"Euler's number, the base of the natural logarithm. Approximately equal to 2.71828",examples:["e","e ^ 2","exp(2)","log(e)"],seealso:["exp"]}},{}],15:[function(e,n){n.exports={name:"false",category:"Constants",syntax:["false"],description:"Boolean value false",examples:["false"],seealso:["true"]}},{}],16:[function(e,n){n.exports={name:"i",category:"Constants",syntax:["i"],description:"Imaginary unit, defined as i*i=-1. A complex number is described as a + b*i, where a is the real part, and b is the imaginary part.",examples:["i","i * i","sqrt(-1)"],seealso:[]}},{}],17:[function(e,n){n.exports={name:"pi",category:"Constants",syntax:["pi"],description:"The number pi is a mathematical constant that is the ratio of a circle's circumference to its diameter, and is approximately equal to 3.14159",examples:["pi","sin(pi/2)"],seealso:["tau"]}},{}],18:[function(e,n){n.exports={name:"tau",category:"Constants",syntax:["pi"],description:"Tau is the ratio constant of a circle's circumference to radius, equal to 2 * pi, approximately 6.2832.",examples:["tau","2 * pi"],seealso:["pi"]}},{}],19:[function(e,n){n.exports={name:"true",category:"Constants",syntax:["true"],description:"Boolean value true",examples:["true"],seealso:["false"]}},{}],20:[function(e,n){n.exports={name:"abs",category:"Arithmetic",syntax:["abs(x)"],description:"Compute the absolute value.",examples:["abs(3.5)","abs(-4.2)"],seealso:["sign"]}},{}],21:[function(e,n){n.exports={name:"add",category:"Operators",syntax:["x + y","add(x, y)"],description:"Add two values.",examples:["2.1 + 3.6","ans - 3.6","3 + 2i",'"hello" + " world"',"3 cm + 2 inch"],seealso:["subtract"]}},{}],22:[function(e,n){n.exports={name:"ceil",category:"Arithmetic",syntax:["ceil(x)"],description:"Round a value towards plus infinity.If x is complex, both real and imaginary part are rounded towards plus infinity.",examples:["ceil(3.2)","ceil(3.8)","ceil(-4.2)"],seealso:["floor","fix","round"]}},{}],23:[function(e,n){n.exports={name:"cube",category:"Arithmetic",syntax:["cube(x)"],description:"Compute the cube of a value. The cube of x is x * x * x.",examples:["cube(2)","2^3","2 * 2 * 2"],seealso:["multiply","square","pow"]}},{}],24:[function(e,n){n.exports={name:"divide",category:"Operators",syntax:["x / y","divide(x, y)"],description:"Divide two values.",examples:["2 / 3","ans * 3","4.5 / 2","3 + 4 / 2","(3 + 4) / 2","18 km / 4.5"],seealso:["multiply"]}},{}],25:[function(e,n){n.exports={name:"edivide",category:"Operators",syntax:["x ./ y","edivide(x, y)"],description:"divide two values element wise.",examples:["a = [1, 2, 3; 4, 5, 6]","b = [2, 1, 1; 3, 2, 5]","a ./ b"],seealso:["multiply","emultiply","divide"]}},{}],26:[function(e,n){n.exports={name:"emultiply",category:"Operators",syntax:["x .* y","emultiply(x, y)"],description:"multiply two values element wise.",examples:["a = [1, 2, 3; 4, 5, 6]","b = [2, 1, 1; 3, 2, 5]","a .* b"],seealso:["multiply","divide","edivide"]}},{}],27:[function(e,n){n.exports={name:"epow",category:"Operators",syntax:["x .^ y","epow(x, y)"],description:"Calculates the power of x to y element wise.",examples:["a = [1, 2, 3; 4, 5, 6]","a .^ 2"],seealso:["pow"]}},{}],28:[function(e,n){n.exports={name:"equal",category:"Operators",syntax:["x == y","equal(x, y)"],description:"Check equality of two values. Returns 1 if the values are equal, and 0 if not.",examples:["2+2 == 3","2+2 == 4","a = 3.2","b = 6-2.8","a == b","50cm == 0.5m"],seealso:["unequal","smaller","larger","smallereq","largereq"]}},{}],29:[function(e,n){n.exports={name:"exp",category:"Arithmetic",syntax:["exp(x)"],description:"Calculate the exponent of a value.",examples:["exp(1.3)","e ^ 1.3","log(exp(1.3))","x = 2.4","(exp(i*x) == cos(x) + i*sin(x))   # Euler's formula"],seealso:["square","multiply","log"]}},{}],30:[function(e,n){n.exports={name:"fix",category:"Arithmetic",syntax:["fix(x)"],description:"Round a value towards zero.If x is complex, both real and imaginary part are rounded towards zero.",examples:["fix(3.2)","fix(3.8)","fix(-4.2)","fix(-4.8)"],seealso:["ceil","floor","round"]}},{}],31:[function(e,n){n.exports={name:"floor",category:"Arithmetic",syntax:["floor(x)"],description:"Round a value towards minus infinity.If x is complex, both real and imaginary part are rounded towards minus infinity.",examples:["floor(3.2)","floor(3.8)","floor(-4.2)"],seealso:["ceil","fix","round"]}},{}],32:[function(e,n){n.exports={name:"gcd",category:"Arithmetic",syntax:["gcd(a, b)","gcd(a, b, c, ...)"],description:"Compute the greatest common divisor.",examples:["gcd(8, 12)","gcd(-4, 6)","gcd(25, 15, -10)"],seealso:["lcm","xgcd"]}},{}],33:[function(e,n){n.exports={name:"larger",category:"Operators",syntax:["x > y","larger(x, y)"],description:"Check if value x is larger than y. Returns 1 if x is larger than y, and 0 if not.",examples:["2 > 3","5 > 2*2","a = 3.3","b = 6-2.8","(a > b)","(b < a)","5 cm > 2 inch"],seealso:["equal","unequal","smaller","smallereq","largereq"]}},{}],34:[function(e,n){n.exports={name:"largereq",category:"Operators",syntax:["x >= y","largereq(x, y)"],description:"Check if value x is larger or equal to y. Returns 1 if x is larger or equal to y, and 0 if not.",examples:["2 > 1+1","2 >= 1+1","a = 3.2","b = 6-2.8","(a > b)"],seealso:["equal","unequal","smallereq","smaller","largereq"]}},{}],35:[function(e,n){n.exports={name:"lcm",category:"Arithmetic",syntax:["lcm(x, y)"],description:"Compute the least common multiple.",examples:["lcm(4, 6)","lcm(6, 21)","lcm(6, 21, 5)"],seealso:["gcd"]}},{}],36:[function(e,n){n.exports={name:"log",category:"Arithmetic",syntax:["log(x)","log(x, base)"],description:"Compute the logarithm of a value. If no base is provided, the natural logarithm of x is calculated. If base if provided, the logarithm is calculated for the specified base. log(x, base) is defined as log(x) / log(base).",examples:["log(3.5)","a = log(2.4)","exp(a)","10 ^ 3","log(1000, 10)","log(1000) / log(10)","b = logb(1024, 2)","2 ^ b"],seealso:["exp","log10"]}},{}],37:[function(e,n){n.exports={name:"log10",category:"Arithmetic",syntax:["log10(x)"],description:"Compute the 10-base logarithm of a value.",examples:["log10(1000)","10 ^ 3","log10(0.01)","log(1000) / log(10)","log(1000, 10)"],seealso:["exp","log"]}},{}],38:[function(e,n){n.exports={name:"mod",category:"Operators",syntax:["x % y","x mod y","mod(x, y)"],description:"Calculates the modulus, the remainder of an integer division.",examples:["7 % 3","11 % 2","10 mod 4","function isOdd(x) = x % 2","isOdd(2)","isOdd(3)"],seealso:[]}},{}],39:[function(e,n){n.exports={name:"multiply",category:"Operators",syntax:["x * y","multiply(x, y)"],description:"multiply two values.",examples:["2.1 * 3.6","ans / 3.6","2 * 3 + 4","2 * (3 + 4)","3 * 2.1 km"],seealso:["divide"]}},{}],40:[function(e,n){n.exports={name:"pow",category:"Operators",syntax:["x ^ y","pow(x, y)"],description:"Calculates the power of x to y, x^y.",examples:["2^3 = 8","2*2*2","1 + e ^ (pi * i)"],seealso:["unequal","smaller","larger","smallereq","largereq"]}},{}],41:[function(e,n){n.exports={name:"round",category:"Arithmetic",syntax:["round(x)","round(x, n)"],description:"round a value towards the nearest integer.If x is complex, both real and imaginary part are rounded towards the nearest integer. When n is specified, the value is rounded to n decimals.",examples:["round(3.2)","round(3.8)","round(-4.2)","round(-4.8)","round(pi, 3)","round(123.45678, 2)"],seealso:["ceil","floor","fix"]}},{}],42:[function(e,n){n.exports={name:"sign",category:"Arithmetic",syntax:["sign(x)"],description:"Compute the sign of a value. The sign of a value x is 1 when x>1, -1 when x<0, and 0 when x=0.",examples:["sign(3.5)","sign(-4.2)","sign(0)"],seealso:["abs"]}},{}],43:[function(e,n){n.exports={name:"smaller",category:"Operators",syntax:["x < y","smaller(x, y)"],description:"Check if value x is smaller than value y. Returns 1 if x is smaller than y, and 0 if not.",examples:["2 < 3","5 < 2*2","a = 3.3","b = 6-2.8","(a < b)","5 cm < 2 inch"],seealso:["equal","unequal","larger","smallereq","largereq"]}},{}],44:[function(e,n){n.exports={name:"smallereq",category:"Operators",syntax:["x <= y","smallereq(x, y)"],description:"Check if value x is smaller or equal to value y. Returns 1 if x is smaller than y, and 0 if not.",examples:["2 < 1+1","2 <= 1+1","a = 3.2","b = 6-2.8","(a < b)"],seealso:["equal","unequal","larger","smaller","largereq"]}},{}],45:[function(e,n){n.exports={name:"sqrt",category:"Arithmetic",syntax:["sqrt(x)"],description:"Compute the square root value. If x = y * y, then y is the square root of x.",examples:["sqrt(25)","5 * 5","sqrt(-1)"],seealso:["square","multiply"]}},{}],46:[function(e,n){n.exports={name:"square",category:"Arithmetic",syntax:["square(x)"],description:"Compute the square of a value. The square of x is x * x.",examples:["square(3)","sqrt(9)","3^2","3 * 3"],seealso:["multiply","pow","sqrt","cube"]}},{}],47:[function(e,n){n.exports={name:"subtract",category:"Operators",syntax:["x - y","subtract(x, y)"],description:"subtract two values.",examples:["5.3 - 2","ans + 2","2/3 - 1/6","2 * 3 - 3","2.1 km - 500m"],seealso:["add"]}},{}],48:[function(e,n){n.exports={name:"unary",category:"Operators",syntax:["-x","unary(x)"],description:"Inverse the sign of a value.",examples:["-4.5","-(-5.6)"],seealso:["add","subtract"]}},{}],49:[function(e,n){n.exports={name:"unequal",category:"Operators",syntax:["x != y","unequal(x, y)"],description:"Check unequality of two values. Returns 1 if the values are unequal, and 0 if they are equal.",examples:["2+2 != 3","2+2 != 4","a = 3.2","b = 6-2.8","a != b","50cm != 0.5m","5 cm != 2 inch"],seealso:["equal","smaller","larger","smallereq","largereq"]}},{}],50:[function(e,n){n.exports={name:"xgcd",category:"Arithmetic",syntax:["xgcd(a, b)"],description:"Calculate the extended greatest common divisor for two values",examples:["xgcd(8, 12)","gcd(8, 12)","xgcd(36163, 21199)"],seealso:["gcd","lcm"]}},{}],51:[function(e,n){n.exports={name:"arg",category:"Complex",syntax:["arg(x)"],description:"Compute the argument of a complex value. If x = a+bi, the argument is computed as atan2(b, a).",examples:["arg(2 + 2i)","atan2(3, 2)","arg(2 - 3i)"],seealso:["re","im","conj","abs"]}},{}],52:[function(e,n){n.exports={name:"conj",category:"Complex",syntax:["conj(x)"],description:"Compute the complex conjugate of a complex value. If x = a+bi, the complex conjugate is a-bi.",examples:["conj(2 + 3i)","conj(2 - 3i)","conj(-5.2i)"],seealso:["re","im","abs","arg"]}},{}],53:[function(e,n){n.exports={name:"im",category:"Complex",syntax:["im(x)"],description:"Get the imaginary part of a complex number.",examples:["im(2 + 3i)","re(2 + 3i)","im(-5.2i)","im(2.4)"],seealso:["re","conj","abs","arg"]}},{}],54:[function(e,n){n.exports={name:"re",category:"Complex",syntax:["re(x)"],description:"Get the real part of a complex number.",examples:["re(2 + 3i)","im(2 + 3i)","re(-5.2i)","re(2.4)"],seealso:["im","conj","abs","arg"]}},{}],55:[function(e,n){n.exports={name:"bignumber",category:"Type",syntax:["bignumber(x)"],description:"Create a big number from a number or string.",examples:["0.1 + 0.2","bignumber(0.1) + bignumber(0.2)",'bignumber("7.2")','bignumber("7.2e500")',"bignumber([0.1, 0.2, 0.3])"],seealso:["boolean","complex","index","matrix","string","unit"]}},{}],56:[function(e,n){n.exports={name:"boolean",category:"Type",syntax:["x","boolean(x)"],description:"Convert a string or number into a boolean.",examples:["boolean(0)","boolean(1)","boolean(3)",'boolean("true")','boolean("false")',"boolean([1, 0, 1, 1])"],seealso:["bignumber","complex","index","matrix","number","string","unit"]}},{}],57:[function(e,n){n.exports={name:"complex",category:"Type",syntax:["complex()","complex(re, im)","complex(string)"],description:"Create a complex number.",examples:["complex()","complex(2, 3)",'complex("7 - 2i")'],seealso:["bignumber","boolean","index","matrix","number","string","unit"]}},{}],58:[function(e,n){n.exports={name:"index",category:"Type",syntax:["[start]","[start:end]","[start:step:end]","[start1, start 2, ...]","[start1:end1, start2:end2, ...]","[start1:step1:end1, start2:step2:end2, ...]"],description:"Create an index to get or replace a subset of a matrix",examples:["[]","[1, 2, 3]","A = [1, 2, 3; 4, 5, 6]","A[1, :]","A[1, 2] = 50","A[0:2, 0:2] = ones(2, 2)"],seealso:["bignumber","boolean","complex","matrix,","number","range","string","unit"]}},{}],59:[function(e,n){n.exports={name:"matrix",category:"Type",syntax:["[]","[a1, b1, ...; a2, b2, ...]","matrix()","matrix([...])"],description:"Create a matrix.",examples:["[]","[1, 2, 3]","[1, 2, 3; 4, 5, 6]","matrix()","matrix([3, 4])"],seealso:["bignumber","boolean","complex","index","number","string","unit"]}},{}],60:[function(e,n){n.exports={name:"number",category:"Type",syntax:["x","number(x)"],description:"Create a number or convert a string or boolean into a number.",examples:["2","2e3","4.05","number(2)",'number("7.2")',"number(true)","number([true, false, true, true])"],seealso:["bignumber","boolean","complex","index","matrix","string","unit"]}},{}],61:[function(e,n){n.exports={name:"string",category:"Type",syntax:['"text"',"string(x)"],description:"Create a string or convert a value to a string",examples:['"Hello World!"',"string(4.2)","string(3 + 2i)"],seealso:["bignumber","boolean","complex","index","matrix","number","unit"]}},{}],62:[function(e,n){n.exports={name:"unit",category:"Type",syntax:["value unit","unit(value, unit)","unit(string)"],description:"Create a unit.",examples:["5.5 mm","3 inch",'unit(7.1, "kilogram")','unit("23 deg")'],seealso:["bignumber","boolean","complex","index","matrix","number","string"]}},{}],63:[function(e,n){n.exports={name:"eval",category:"Expression",syntax:["eval(expression)","eval([expr1, expr2, expr3, ...])"],description:"Evaluate an expression or an array with expressions.",examples:['eval("2 + 3")','eval("sqrt(" + 4 + ")")'],seealso:[]}},{}],64:[function(e,n){n.exports={name:"help",category:"Expression",syntax:["help(object)","help(string)"],description:"Display documentation on a function or data type.",examples:["help(sqrt)",'help("complex")'],seealso:[]}},{}],65:[function(e,n){n.exports={name:"concat",category:"Matrix",syntax:["concat(a, b, c, ...)","concat(a, b, c, ..., dim)"],description:"Concatenate matrices. By default, the matrices are concatenated by the first dimension. The dimension on which to concatenate can be provided as last argument.",examples:["a = [1, 2; 5, 6]","b = [3, 4; 7, 8]","concat(a, b)","[a, b]","concat(a, b, 2)","[a; b]"],seealso:["det","diag","eye","inv","ones","range","size","squeeze","subset","transpose","zeros"]}},{}],66:[function(e,n){n.exports={name:"det",category:"Matrix",syntax:["det(x)"],description:"Calculate the determinant of a matrix",examples:["det([1, 2; 3, 4])","det([-2, 2, 3; -1, 1, 3; 2, 0, -1])"],seealso:["concat","diag","eye","inv","ones","range","size","squeeze","subset","transpose","zeros"]}},{}],67:[function(e,n){n.exports={name:"diag",category:"Matrix",syntax:["diag(x)","diag(x, k)"],description:"Create a diagonal matrix or retrieve the diagonal of a matrix. When x is a vector, a matrix with the vector values on the diagonal will be returned. When x is a matrix, a vector with the diagonal values of the matrix is returned.When k is provided, the k-th diagonal will be filled in or retrieved, if k is positive, the values are placed on the super diagonal. When k is negative, the values are placed on the sub diagonal.",examples:["diag(1:3)","diag(1:3, 1)","a = [1, 2, 3; 4, 5, 6; 7, 8, 9]","diag(a)"],seealso:["concat","det","eye","inv","ones","range","size","squeeze","subset","transpose","zeros"]}},{}],68:[function(e,n){n.exports={name:"eye",category:"Matrix",syntax:["eye(n)","eye(m, n)","eye([m, n])","eye"],description:"Returns the identity matrix with size m-by-n. The matrix has ones on the diagonal and zeros elsewhere.",examples:["eye(3)","eye(3, 5)","a = [1, 2, 3; 4, 5, 6]","eye(size(a))"],seealso:["concat","det","diag","inv","ones","range","size","squeeze","subset","transpose","zeros"]}},{}],69:[function(e,n){n.exports={name:"inv",category:"Matrix",syntax:["inv(x)"],description:"Calculate the inverse of a matrix",examples:["inv([1, 2; 3, 4])","inv(4)","1 / 4"],seealso:["concat","det","diag","eye","ones","range","size","squeeze","subset","transpose","zeros"]}},{}],70:[function(e,n){n.exports={name:"ones",category:"Matrix",syntax:["ones(m)","ones(m, n)","ones(m, n, p, ...)","ones([m])","ones([m, n])","ones([m, n, p, ...])","ones"],description:"Create a matrix containing ones.",examples:["ones(3)","ones(3, 5)","ones([2,3]) * 4.5","a = [1, 2, 3; 4, 5, 6]","ones(size(a))"],seealso:["concat","det","diag","eye","inv","range","size","squeeze","subset","transpose","zeros"]}},{}],71:[function(e,n){n.exports={name:"range",category:"Type",syntax:["start:end","start:step:end","range(start, end)","range(start, end, step)","range(string)"],description:"Create a range. Lower bound of the range is included, upper bound is excluded.",examples:["1:5","3:-1:-3","range(3, 7)","range(0, 12, 2)",'range("4:10")',"a = [1, 2, 3, 4; 5, 6, 7, 8]","a(1:2, 1:2)"],seealso:["concat","det","diag","eye","inv","ones","size","squeeze","subset","transpose","zeros"]}},{}],72:[function(e,n){n.exports={name:"resize",category:"Matrix",syntax:["resize(x, size)","resize(x, size, defaultValue)"],description:"Resize a matrix.",examples:["resize([1,2,3,4,5], [3])","resize([1,2,3], [5], 0)","resize(2, [2, 3], 0)",'resize("hello", [8], "!")'],seealso:["size","subset","squeeze"]}},{}],73:[function(e,n){n.exports={name:"size",category:"Matrix",syntax:["size(x)"],description:"Calculate the size of a matrix.",examples:["size(2.3)",'size("hello world")',"a = [1, 2; 3, 4; 5, 6]","size(a)","size(1:6)"],seealso:["concat","det","diag","eye","inv","ones","range","squeeze","subset","transpose","zeros"]}},{}],74:[function(e,n){n.exports={name:"squeeze",category:"Matrix",syntax:["squeeze(x)"],description:"Remove singleton dimensions from a matrix.",examples:["a = zeros(1,3,2)","size(squeeze(a))","b = zeros(3,1,1)","size(squeeze(b))"],seealso:["concat","det","diag","eye","inv","ones","range","size","subset","transpose","zeros"]}},{}],75:[function(e,n){n.exports={name:"subset",category:"Matrix",syntax:["value(index)","value(index) = replacement","subset(value, [index])","subset(value, [index], replacement)"],description:"Get or set a subset of a matrix or string. Indexes are one-based. Both the ranges lower-bound and upper-bound are included.",examples:["d = [1, 2; 3, 4]","e = []","e(1, 1:2) = [5, 6]","e(2, :) = [7, 8]","f = d * e","f(2, 1)","f(:, 1)"],seealso:["concat","det","diag","eye","inv","ones","range","size","squeeze","transpose","zeros"]}},{}],76:[function(e,n){n.exports={name:"transpose",category:"Matrix",syntax:["x'","transpose(x)"],description:"Transpose a matrix",examples:["a = [1, 2, 3; 4, 5, 6]","a'","transpose(a)"],seealso:["concat","det","diag","eye","inv","ones","range","size","squeeze","subset","zeros"]}},{}],77:[function(e,n){n.exports={name:"zeros",category:"Matrix",syntax:["zeros(m)","zeros(m, n)","zeros(m, n, p, ...)","zeros([m])","zeros([m, n])","zeros([m, n, p, ...])","zeros"],description:"Create a matrix containing zeros.",examples:["zeros(3)","zeros(3, 5)","a = [1, 2, 3; 4, 5, 6]","zeros(size(a))"],seealso:["concat","det","diag","eye","inv","ones","range","size","squeeze","subset","transpose"]}},{}],78:[function(e,n){n.exports={name:"distribution",category:"Probability",syntax:["distribution(name)","distribution(name, arg1, arg2, ...)"],description:'Create a distribution object of a specific type. A distribution object contains functions `random([size,] [min,] [max])`, `randomInt([size,] [min,] [max])`, and `pickRandom(array)`. Available types of distributions: "uniform", "normal". Note that the function distribution is currently not available via the expression parser.',examples:[],seealso:["random","randomInt"]}},{}],79:[function(e,n){n.exports={name:"factorial",category:"Probability",syntax:["x!","factorial(x)"],description:"Compute the factorial of a value",examples:["5!","5*4*3*2*1","3!"],seealso:[]}},{}],80:[function(e,n){n.exports={name:"pickRandom",category:"Probability",syntax:["pickRandom(array)"],description:"Pick a random entry from a given array.",examples:["pickRandom(0:10)","pickRandom([1, 3, 1, 6])"],seealso:["distribution","random","randomInt"]}},{}],81:[function(e,n){n.exports={name:"random",category:"Probability",syntax:["random()","random(max)","random(min, max)","random(size)","random(size, max)","random(size, min, max)"],description:"Return a random number.",examples:["random()","random(10, 20)","random([2, 3])"],seealso:["distribution","pickRandom","randomInt"]}},{}],82:[function(e,n){n.exports={name:"randInt",category:"Probability",syntax:["randInt()","randInt(max)","randInt(min, max)","randInt(size)","randInt(size, max)","randInt(size, min, max)"],description:"Return a random integer number",examples:["randInt()","randInt(10, 20)","randInt([2, 3], 10)"],seealso:["distribution","pickRandom","random"]}},{}],83:[function(e,n){n.exports={name:"max",category:"Statistics",syntax:["max(a, b, c, ...)","max(A)","max(A, dim)"],description:"Compute the maximum value of a list of values.",examples:["max(2, 3, 4, 1)","max([2, 3, 4, 1])","max([2, 5; 4, 3], 0)","max([2, 5; 4, 3], 1)","max(2.7, 7.1, -4.5, 2.0, 4.1)","min(2.7, 7.1, -4.5, 2.0, 4.1)"],seealso:["mean","min"]}},{}],84:[function(e,n){n.exports={name:"mean",category:"Statistics",syntax:["mean(a, b, c, ...)","mean(A)","mean(A, dim)"],description:"Compute the arithmetic mean of a list of values.",examples:["mean(2, 3, 4, 1)","mean([2, 3, 4, 1])","mean([2, 5; 4, 3], 0)","mean([2, 5; 4, 3], 1)","mean([1.0, 2.7, 3.2, 4.0])"],seealso:["max","min"]}},{}],85:[function(e,n){n.exports={name:"min",category:"Statistics",syntax:["min(a, b, c, ...)","min(A)","min(A, dim)"],description:"Compute the minimum value of a list of values.",examples:["min(2, 3, 4, 1)","min([2, 3, 4, 1])","min([2, 5; 4, 3], 0)","min([2, 5; 4, 3], 1)","min(2.7, 7.1, -4.5, 2.0, 4.1)","max(2.7, 7.1, -4.5, 2.0, 4.1)"],seealso:["max","mean","min"]}},{}],86:[function(e,n){n.exports={name:"acos",category:"Trigonometry",syntax:["acos(x)"],description:"Compute the inverse cosine of a value in radians.",examples:["acos(0.5)","acos(cos(2.3))"],seealso:["cos","acos","asin"]}},{}],87:[function(e,n){n.exports={name:"asin",category:"Trigonometry",syntax:["asin(x)"],description:"Compute the inverse sine of a value in radians.",examples:["asin(0.5)","asin(sin(2.3))"],seealso:["sin","acos","asin"]}},{}],88:[function(e,n){n.exports={name:"atan",category:"Trigonometry",syntax:["atan(x)"],description:"Compute the inverse tangent of a value in radians.",examples:["atan(0.5)","atan(tan(2.3))"],seealso:["tan","acos","asin"]}},{}],89:[function(e,n){n.exports={name:"atan2",category:"Trigonometry",syntax:["atan2(y, x)"],description:"Computes the principal value of the arc tangent of y/x in radians.",examples:["atan2(2, 2) / pi","angle = 60 deg in rad","x = cos(angle)","y = sin(angle)","atan2(y, x)"],seealso:["sin","cos","tan"]}},{}],90:[function(e,n){n.exports={name:"cos",category:"Trigonometry",syntax:["cos(x)"],description:"Compute the cosine of x in radians.",examples:["cos(2)","cos(pi / 4) ^ 2","cos(180 deg)","cos(60 deg)","sin(0.2)^2 + cos(0.2)^2"],seealso:["acos","sin","tan"]}},{}],91:[function(e,n){n.exports={name:"cot",category:"Trigonometry",syntax:["cot(x)"],description:"Compute the cotangent of x in radians. Defined as 1/tan(x)",examples:["cot(2)","1 / tan(2)"],seealso:["sec","csc","tan"]}},{}],92:[function(e,n){n.exports={name:"csc",category:"Trigonometry",syntax:["csc(x)"],description:"Compute the cosecant of x in radians. Defined as 1/sin(x)",examples:["csc(2)","1 / sin(2)"],seealso:["sec","cot","sin"]}},{}],93:[function(e,n){n.exports={name:"sec",category:"Trigonometry",syntax:["sec(x)"],description:"Compute the secant of x in radians. Defined as 1/cos(x)",examples:["sec(2)","1 / cos(2)"],seealso:["cot","csc","cos"]}},{}],94:[function(e,n){n.exports={name:"sin",category:"Trigonometry",syntax:["sin(x)"],description:"Compute the sine of x in radians.",examples:["sin(2)","sin(pi / 4) ^ 2","sin(90 deg)","sin(30 deg)","sin(0.2)^2 + cos(0.2)^2"],seealso:["asin","cos","tan"]}},{}],95:[function(e,n){n.exports={name:"tan",category:"Trigonometry",syntax:["tan(x)"],description:"Compute the tangent of x in radians.",examples:["tan(0.5)","sin(0.5) / cos(0.5)","tan(pi / 4)","tan(45 deg)"],seealso:["atan","sin","cos"]}},{}],96:[function(e,n){n.exports={name:"in",category:"Units",syntax:["x in unit","in(x, unit)"],description:"Change the unit of a value.",examples:["5 inch in cm","3.2kg in g","16 bytes in bits"],seealso:[]}},{}],97:[function(e,n){n.exports={name:"clone",category:"Utils",syntax:["clone(x)"],description:"Clone a variable. Creates a copy of primitive variables,and a deep copy of matrices",examples:["clone(3.5)","clone(2 - 4i)","clone(45 deg)","clone([1, 2; 3, 4])",'clone("hello world")'],seealso:[]}},{}],98:[function(e,n){n.exports={name:"forEach",category:"Utils",syntax:["forEach(x, callback)"],description:"Iterates over all elements of a matrix/array, and executes the given callback.",examples:["forEach([1, 2, 3], function(val) { console.log(val) })"],seealso:[]}},{}],99:[function(e,n){n.exports={name:"format",category:"Utils",syntax:["format(value)","format(value, precision)"],description:"Format a value of any type as string.",examples:["format(2.3)","format(3 - 4i)","format([])","format(pi, 3)"],seealso:["print"]}},{}],100:[function(e,n){n.exports={name:"import",category:"Utils",syntax:["import(string)"],description:"Import functions from a file.",examples:['import("numbers")','import("./mylib.js")'],seealso:[]}},{}],101:[function(e,n){n.exports={name:"map",category:"Utils",syntax:["map(x, callback)"],description:"Create a new matrix or array with the results of the callback function executed on each entry of the matrix/array.",examples:["map([1, 2, 3], function(val) { return math.max(val, 1.5) })"],seealso:[]}},{}],102:[function(e,n){n.exports={name:"typeof",category:"Utils",syntax:["typeof(x)"],description:"Get the type of a variable.",examples:["typeof(3.5)","typeof(2 - 4i)","typeof(45 deg)",'typeof("hello world")'],seealso:[]}},{}],103:[function(e,n,t){t.e=e("./constants/e"),t.E=e("./constants/e"),t["false"]=e("./constants/false"),t.i=e("./constants/i"),t.Infinity=e("./constants/Infinity"),t.LN2=e("./constants/LN2"),t.LN10=e("./constants/LN10"),t.LOG2E=e("./constants/LOG2E"),t.LOG10E=e("./constants/LOG10E"),t.NaN=e("./constants/NaN"),t.pi=e("./constants/pi"),t.PI=e("./constants/pi"),t.SQRT1_2=e("./constants/SQRT1_2"),t.SQRT2=e("./constants/SQRT2"),t.tau=e("./constants/tau"),t["true"]=e("./constants/true"),t.abs=e("./function/arithmetic/abs"),t.add=e("./function/arithmetic/add"),t.ceil=e("./function/arithmetic/ceil"),t.cube=e("./function/arithmetic/cube"),t.divide=e("./function/arithmetic/divide"),t.edivide=e("./function/arithmetic/edivide"),t.emultiply=e("./function/arithmetic/emultiply"),t.epow=e("./function/arithmetic/epow"),t.equal=e("./function/arithmetic/equal"),t.exp=e("./function/arithmetic/exp"),t.fix=e("./function/arithmetic/fix"),t.floor=e("./function/arithmetic/floor"),t.gcd=e("./function/arithmetic/gcd"),t.larger=e("./function/arithmetic/larger"),t.largereq=e("./function/arithmetic/largereq"),t.lcm=e("./function/arithmetic/lcm"),t.log=e("./function/arithmetic/log"),t.log10=e("./function/arithmetic/log10"),t.mod=e("./function/arithmetic/mod"),t.multiply=e("./function/arithmetic/multiply"),t.pow=e("./function/arithmetic/pow"),t.round=e("./function/arithmetic/round"),t.sign=e("./function/arithmetic/sign"),t.smaller=e("./function/arithmetic/smaller"),t.smallereq=e("./function/arithmetic/smallereq"),t.sqrt=e("./function/arithmetic/sqrt"),t.square=e("./function/arithmetic/square"),t.subtract=e("./function/arithmetic/subtract"),t.unary=e("./function/arithmetic/unary"),t.unequal=e("./function/arithmetic/unequal"),t.xgcd=e("./function/arithmetic/xgcd"),t.arg=e("./function/complex/arg"),t.conj=e("./function/complex/conj"),t.re=e("./function/complex/re"),t.im=e("./function/complex/im"),t.bignumber=e("./function/construction/bignumber"),t.boolean=e("./function/construction/boolean"),t.complex=e("./function/construction/complex"),t.index=e("./function/construction/index"),t.matrix=e("./function/construction/matrix"),t.number=e("./function/construction/number"),t.string=e("./function/construction/string"),t.unit=e("./function/construction/unit"),t.eval=e("./function/expression/eval"),t.help=e("./function/expression/help"),t.concat=e("./function/matrix/concat"),t.det=e("./function/matrix/det"),t.diag=e("./function/matrix/diag"),t.eye=e("./function/matrix/eye"),t.inv=e("./function/matrix/inv"),t.ones=e("./function/matrix/ones"),t.range=e("./function/matrix/range"),t.resize=e("./function/matrix/resize"),t.size=e("./function/matrix/size"),t.squeeze=e("./function/matrix/squeeze"),t.subset=e("./function/matrix/subset"),t.transpose=e("./function/matrix/transpose"),t.zeros=e("./function/matrix/zeros"),t.factorial=e("./function/probability/factorial"),t.distribution=e("./function/probability/distribution"),t.pickRandom=e("./function/probability/pickRandom"),t.random=e("./function/probability/random"),t.randomInt=e("./function/probability/randomInt"),t.min=e("./function/statistics/min"),t.mean=e("./function/statistics/mean"),t.max=e("./function/statistics/max"),t.acos=e("./function/trigonometry/acos"),t.asin=e("./function/trigonometry/asin"),t.atan=e("./function/trigonometry/atan"),t.atan2=e("./function/trigonometry/atan2"),t.cos=e("./function/trigonometry/cos"),t.cot=e("./function/trigonometry/cot"),t.csc=e("./function/trigonometry/csc"),t.sec=e("./function/trigonometry/sec"),t.sin=e("./function/trigonometry/sin"),t.tan=e("./function/trigonometry/tan"),t["in"]=e("./function/units/in"),t.clone=e("./function/utils/clone"),t.map=e("./function/utils/map"),t.forEach=e("./function/utils/forEach"),t.format=e("./function/utils/format"),t["import"]=e("./function/utils/import"),t["typeof"]=e("./function/utils/typeof")
+},{"./constants/Infinity":6,"./constants/LN10":7,"./constants/LN2":8,"./constants/LOG10E":9,"./constants/LOG2E":10,"./constants/NaN":11,"./constants/SQRT1_2":12,"./constants/SQRT2":13,"./constants/e":14,"./constants/false":15,"./constants/i":16,"./constants/pi":17,"./constants/tau":18,"./constants/true":19,"./function/arithmetic/abs":20,"./function/arithmetic/add":21,"./function/arithmetic/ceil":22,"./function/arithmetic/cube":23,"./function/arithmetic/divide":24,"./function/arithmetic/edivide":25,"./function/arithmetic/emultiply":26,"./function/arithmetic/epow":27,"./function/arithmetic/equal":28,"./function/arithmetic/exp":29,"./function/arithmetic/fix":30,"./function/arithmetic/floor":31,"./function/arithmetic/gcd":32,"./function/arithmetic/larger":33,"./function/arithmetic/largereq":34,"./function/arithmetic/lcm":35,"./function/arithmetic/log":36,"./function/arithmetic/log10":37,"./function/arithmetic/mod":38,"./function/arithmetic/multiply":39,"./function/arithmetic/pow":40,"./function/arithmetic/round":41,"./function/arithmetic/sign":42,"./function/arithmetic/smaller":43,"./function/arithmetic/smallereq":44,"./function/arithmetic/sqrt":45,"./function/arithmetic/square":46,"./function/arithmetic/subtract":47,"./function/arithmetic/unary":48,"./function/arithmetic/unequal":49,"./function/arithmetic/xgcd":50,"./function/complex/arg":51,"./function/complex/conj":52,"./function/complex/im":53,"./function/complex/re":54,"./function/construction/bignumber":55,"./function/construction/boolean":56,"./function/construction/complex":57,"./function/construction/index":58,"./function/construction/matrix":59,"./function/construction/number":60,"./function/construction/string":61,"./function/construction/unit":62,"./function/expression/eval":63,"./function/expression/help":64,"./function/matrix/concat":65,"./function/matrix/det":66,"./function/matrix/diag":67,"./function/matrix/eye":68,"./function/matrix/inv":69,"./function/matrix/ones":70,"./function/matrix/range":71,"./function/matrix/resize":72,"./function/matrix/size":73,"./function/matrix/squeeze":74,"./function/matrix/subset":75,"./function/matrix/transpose":76,"./function/matrix/zeros":77,"./function/probability/distribution":78,"./function/probability/factorial":79,"./function/probability/pickRandom":80,"./function/probability/random":81,"./function/probability/randomInt":82,"./function/statistics/max":83,"./function/statistics/mean":84,"./function/statistics/min":85,"./function/trigonometry/acos":86,"./function/trigonometry/asin":87,"./function/trigonometry/atan":88,"./function/trigonometry/atan2":89,"./function/trigonometry/cos":90,"./function/trigonometry/cot":91,"./function/trigonometry/csc":92,"./function/trigonometry/sec":93,"./function/trigonometry/sin":94,"./function/trigonometry/tan":95,"./function/units/in":96,"./function/utils/clone":97,"./function/utils/forEach":98,"./function/utils/format":99,"./function/utils/import":100,"./function/utils/map":101,"./function/utils/typeof":102}],104:[function(e,n){function t(e,n){this.settings=e,this.nodes=n||[]}var r=e("./Node"),i=(e("../../util/object"),e("../../util/string")),o=(e("../../type/collection"),e("../../type/Matrix"));t.prototype=new r,t.prototype.eval=function(){for(var e=this.nodes,n=[],t=0,r=e.length;r>t;t++){var i=e[t],a=i.eval();n[t]=a instanceof o?a.valueOf():a}return"array"===this.settings.matrix.defaultType?n:new o(n)},t.prototype.find=function(e){var n=[];this.match(e)&&n.push(this);for(var t=this.nodes,r=0,i=t.length;i>r;r++)for(var o=t[r],a=0,s=o.length;s>a;a++)n=n.concat(o[a].find(e));return n},t.prototype.toString=function(){return i.format(this.nodes)},n.exports=t},{"../../type/Matrix":205,"../../type/collection":208,"../../util/object":214,"../../util/string":215,"./Node":109}],105:[function(e,n){function t(e,n,t){this.name=e,this.expr=n,this.scope=t}var r=e("./Node");t.prototype=new r,t.prototype.eval=function(){if(void 0===this.expr)throw new Error("Undefined symbol "+this.name);var e=this.expr.eval();return this.scope.set(this.name,e),e},t.prototype.find=function(e){var n=[];return this.match(e)&&n.push(this),this.expr&&(n=n.concat(this.expr.find(e))),n},t.prototype.toString=function(){return this.name+" = "+this.expr.toString()},n.exports=t},{"./Node":109}],106:[function(e,n){function t(){this.params=[],this.visible=[]}var r=e("./Node");t.prototype=new r,t.prototype.add=function(e,n){var t=this.params.length;this.params[t]=e,this.visible[t]=void 0!=n?n:!0},t.prototype.eval=function(){for(var e=[],n=0,t=this.params.length;t>n;n++){var r=this.params[n].eval();this.visible[n]&&e.push(r)}return e},t.prototype.find=function(e){var n=[];this.match(e)&&n.push(this);var t=this.params;if(t)for(var r=0,i=t.length;i>r;r++)n=n.concat(t[r].find(e));return n},t.prototype.toString=function(){for(var e=[],n=0,t=this.params.length;t>n;n++)this.visible[n]&&e.push("\n  "+this.params[n].toString());return"["+e.join(",")+"\n]"},n.exports=t},{"./Node":109}],107:[function(e,n){function t(e){this.value=e}var r=e("./Node"),i=e("../../util/string");t.prototype=new r,t.prototype.eval=function(){return this.value},t.prototype.toString=function(){return i.format(this.value)},n.exports=t},{"../../util/string":215,"./Node":109}],108:[function(e,n){function t(e,n,t,r,i){this.name=e,this.variables=n,this.expr=t,this.scope=i,this.fn=function(){var i=n?n.length:0;if(arguments.length!=i)throw new SyntaxError("Wrong number of arguments in function "+e+" ("+arguments.length+" provided, "+i+" expected)");for(var o=0;i>o;o++)r.set(n[o],arguments[o]);return t.eval()},this.fn.toString=function(){return e+"("+n.join(", ")+")"}}var r=e("./Node");t.prototype=new r,t.prototype.eval=function(){return this.scope.set(this.name,this.fn),this.fn},t.prototype.find=function(e){var n=[];return this.match(e)&&n.push(this),this.expr&&(n=n.concat(this.expr.find(e))),n},t.prototype.toString=function(){return this.fn.toString()},n.exports=t},{"./Node":109}],109:[function(e,n){function t(){}t.prototype.eval=function(){throw new Error("Cannot evaluate a Node interface")},t.prototype.find=function(e){return this.match(e)?[this]:[]},t.prototype.match=function(e){var n=!0;if(e&&(!e.type||this instanceof e.type||(n=!1),n&&e.properties))for(var t in e.properties)if(e.properties.hasOwnProperty(t)&&this[t]!=e.properties[t]){n=!1;break}return n},t.prototype.toString=function(){return""},n.exports=t},{}],110:[function(e,n){function t(e,n,t){this.name=e,this.fn=n,this.params=t}var r=e("./Node");t.prototype=new r,t.prototype.eval=function(){return this.fn.apply(this,this.params.map(function(e){return e.eval()}))},t.prototype.find=function(e){var n=[];this.match(e)&&n.push(this);var t=this.params;if(t)for(var r=0,i=t.length;i>r;r++)n=n.concat(t[r].find(e));return n},t.prototype.toString=function(){var e=this.params;switch(e.length){case 1:return"-"==this.name?"-"+e[0].toString():e[0].toString()+this.name;case 2:var n=e[0].toString();e[0]instanceof t&&(n="("+n+")");var r=e[1].toString();return e[1]instanceof t&&(r="("+r+")"),n+" "+this.name+" "+r;default:return this.name+"("+this.params.join(", ")+")"}},n.exports=t},{"./Node":109}],111:[function(e,n){function t(e,n,t,r){if(this.math=e,this.object=n,this.params=t,this.paramScopes=r,this.hasContextParams=!1,t)for(var i={type:a,properties:{name:"end"}},o=0,s=t.length;s>o;o++)if(t[o].find(i).length>0){this.hasContextParams=!0;break}}var r=e("../../util/number"),i=e("./Node"),o=e("./RangeNode"),a=e("./SymbolNode"),s=e("bignumber.js"),u=e("../../type/Index"),c=e("../../type/Range"),f=r.isNumber,l=r.toNumber;t.prototype=new i,t.prototype.eval=function(){var e,n,t,r,i=this.object;if(void 0==i)throw new Error("Node undefined");var a=i.eval();if(this.hasContextParams&&"function"!=typeof a){var m=this.paramScopes,p=this.math.size(a).valueOf();if(m&&p)for(e=0,n=this.params.length;n>e;e++){var h=m[e];h&&h.set("end",p[e])}}if("function"==typeof a){for(t=this.params,r=[],e=0,n=this.params.length;n>e;e++)r[e]=t[e].eval();return a.apply(this,r)}for(t=this.params,r=[],e=0,n=this.params.length;n>e;e++){var g,x=t[e];if(g=x instanceof o?x.toRange():x.eval(),g instanceof s&&(g=l(g)),g instanceof c)g.start--,g.end--;else{if(!f(g))throw new TypeError("Number or Range expected");g--}r[e]=g}var d=u.create(r);return this.math.subset(a,d)},t.prototype.find=function(e){var n=[];this.match(e)&&n.push(this),this.object&&(n=n.concat(this.object.find(e)));var t=this.params;if(t)for(var r=0,i=t.length;i>r;r++)n=n.concat(t[r].find(e));return n},t.prototype.toString=function(){var e=this.object?this.object.toString():"";return this.params&&(e+="("+this.params.join(", ")+")"),e},n.exports=t},{"../../type/Index":204,"../../type/Range":206,"../../util/number":213,"./Node":109,"./RangeNode":112,"./SymbolNode":113,"bignumber.js":217}],112:[function(e,n){function t(e,n,t){if(this.math=e,this.settings=n,this.start=null,this.end=null,this.step=null,2==t.length)this.start=t[0],this.end=t[1];else{if(3!=t.length)throw new SyntaxError("Wrong number of arguments");this.start=t[0],this.step=t[1],this.end=t[2]}}var r=e("../../util/number"),i=e("./Node"),o=e("bignumber.js"),a=e("../../type/Range"),s=e("../../type/Matrix"),u=r.toNumber;t.prototype=new i,t.prototype.eval=function(){var e=this._evalParams(),n=e.start,t=e.step,r=e.end,i=[],o=n;if(t>0)for(;r>=o;)i.push(o),o+=t;else if(0>t)for(;o>=r;)i.push(o),o+=t;return"array"===this.settings.matrix.defaultType?i:new s(i)},t.prototype.toRange=function(){var e=this._evalParams(),n=e.start,t=e.step,r=e.end;return r=this.math.add(r,t>0?1:-1),new a(n,r,t)},t.prototype._evalParams=function(){var e=this.start.eval(),n=this.end.eval(),t=this.step?this.step.eval():1;if(e instanceof o&&(e=u(e)),n instanceof o&&(n=u(n)),t instanceof o&&(t=u(t)),!r.isNumber(e))throw new TypeError("Parameter start must be a number");if(!r.isNumber(n))throw new TypeError("Parameter end must be a number");if(!r.isNumber(t))throw new TypeError("Parameter step must be a number");return{start:e,end:n,step:t}},t.prototype.find=function(e){var n=[];return this.match(e)&&n.push(this),this.start&&(n=n.concat(this.start.find(e))),this.step&&(n=n.concat(this.step.find(e))),this.end&&(n=n.concat(this.end.find(e))),n},t.prototype.toString=function(){var e=this.start.toString();return this.step&&(e+=":"+this.step.toString()),e+=":"+this.end.toString()},n.exports=t},{"../../type/Matrix":205,"../../type/Range":206,"../../util/number":213,"./Node":109,"bignumber.js":217}],113:[function(e,n){function t(e,n){this.name=e,this.scope=n}var r=e("./Node");t.prototype=new r,t.prototype.eval=function(){var e=this.scope.get(this.name);if(void 0===e)throw new Error("Undefined symbol "+this.name);return e},t.prototype.toString=function(){return this.name},n.exports=t},{"./Node":109}],114:[function(e,n){function t(e,n,t,r,i,o){this.math=e,this.name=n,this.params=t,this.paramScopes=r,this.expr=i,this.scope=o,this.hasContextParams=!1;for(var s={type:a,properties:{name:"end"}},u=0,c=t.length;c>u;u++)if(t[u].find(s).length>0){this.hasContextParams=!0;break}}var r=e("../../util/number"),i=e("./Node"),o=e("./RangeNode"),a=e("./SymbolNode"),s=e("bignumber.js"),u=e("../../type/Index"),c=e("../../type/Range"),f=r.isNumber,l=r.toNumber;t.prototype=new i,t.prototype.eval=function(){if(void 0===this.expr)throw new Error("Undefined symbol "+this.name);var e,n=this.scope.get(this.name);if(void 0==n)throw new Error("Undefined symbol "+this.name);if(this.hasContextParams&&"function"!=typeof n){var t=this.paramScopes,r=this.math.size(n).valueOf();if(t&&r)for(var i=0,a=this.params.length;a>i;i++){var m=t[i];m&&m.set("end",r[i])}}var p=[];this.params.forEach(function(e){var n;if(n=e instanceof o?e.toRange():e.eval(),n instanceof s&&(n=l(n)),n instanceof c)n.start--,n.end--;else{if(!f(n))throw new TypeError("Number or Range expected");n--}p.push(n)});var h=this.expr.eval(),g=u.create(p);return e=this.math.subset(n,g,h),this.scope.set(this.name,e),e},t.prototype.find=function(e){var n=[];this.match(e)&&n.push(this);var t=this.params;if(t)for(var r=0,i=t.length;i>r;r++)n=n.concat(t[r].find(e));return this.expr&&(n=n.concat(this.expr.find(e))),n},t.prototype.toString=function(){var e="";return e+=this.name,this.params&&this.params.length&&(e+="("+this.params.join(", ")+")"),e+=" = ",e+=this.expr.toString()},n.exports=t},{"../../type/Index":204,"../../type/Range":206,"../../util/number":213,"./Node":109,"./RangeNode":112,"./SymbolNode":113,"bignumber.js":217}],115:[function(){},{}],116:[function(e,n,t){t.AssignmentNode=e("./AssignmentNode"),t.BlockNode=e("./BlockNode"),t.ConstantNode=e("./ConstantNode"),t.FunctionNode=e("./FunctionNode"),t.ArrayNode=e("./ArrayNode"),t.Node=e("./Node"),t.OperatorNode=e("./OperatorNode"),t.ParamsNode=e("./ParamsNode"),t.RangeNode=e("./RangeNode"),t.SymbolNode=e("./SymbolNode"),t.UpdateNode=e("./UpdateNode"),t.handlers=e("./handlers")},{"./ArrayNode":104,"./AssignmentNode":105,"./BlockNode":106,"./ConstantNode":107,"./FunctionNode":108,"./Node":109,"./OperatorNode":110,"./ParamsNode":111,"./RangeNode":112,"./SymbolNode":113,"./UpdateNode":114,"./handlers":115}],117:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=(e("../../type/Matrix"),e("../../type/collection")),a=t.number.isNumber,s=t.boolean.isBoolean,u=i.isComplex,c=o.isCollection;n.abs=function f(e){if(1!=arguments.length)throw new n.error.ArgumentsError("abs",arguments.length,1);if(a(e))return Math.abs(e);if(u(e))return Math.sqrt(e.re*e.re+e.im*e.im);if(e instanceof r)return e.abs();if(c(e))return o.deepMap(e,f);if(s(e))return Math.abs(e);throw new n.error.UnsupportedTypeError("abs",e)}}},{"../../type/Complex":202,"../../type/Matrix":205,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],118:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=(e("../../type/Matrix"),e("../../type/Unit")),a=e("../../type/collection"),s=t.boolean.isBoolean,u=t.number.isNumber,c=t.number.toNumber,f=t.number.toBigNumber,l=t.string.isString,m=i.isComplex,p=o.isUnit,h=a.isCollection;n.add=function g(e,t){if(2!=arguments.length)throw new n.error.ArgumentsError("add",arguments.length,2);if(u(e)){if(u(t))return e+t;if(m(t))return new i(e+t.re,t.im)}if(m(e)){if(m(t))return new i(e.re+t.re,e.im+t.im);if(u(t))return new i(e.re+t,e.im)}if(p(e)&&p(t)){if(!e.equalBase(t))throw new Error("Units do not match");if(null==e.value)throw new Error("Unit on left hand side of operator + has an undefined value");if(null==t.value)throw new Error("Unit on right hand side of operator + has an undefined value");var o=e.clone();return o.value+=t.value,o.fixPrefix=!1,o}if(e instanceof r)return u(t)?t=f(t):s(t)&&(t=new r(t?1:0)),t instanceof r?e.plus(t):g(c(e),t);if(t instanceof r)return u(e)?e=f(e):s(e)&&(e=new r(e?1:0)),e instanceof r?e.plus(t):g(e,c(t));if(l(e)||l(t))return e+t;if(h(e)||h(t))return a.deepMap2(e,t,g);if(s(e))return g(+e,t);if(s(t))return g(e,+t);throw new n.error.UnsupportedTypeError("add",e,t)}}},{"../../type/Complex":202,"../../type/Matrix":205,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],119:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/collection"),a=t.number.isNumber,s=t.boolean.isBoolean,u=o.isCollection,c=i.isComplex;n.ceil=function f(e){if(1!=arguments.length)throw new n.error.ArgumentsError("ceil",arguments.length,1);if(a(e))return Math.ceil(e);if(c(e))return new i(Math.ceil(e.re),Math.ceil(e.im));if(e instanceof r)return e.ceil();if(u(e))return o.deepMap(e,f);if(s(e))return Math.ceil(e);throw new n.error.UnsupportedTypeError("ceil",e)}}},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],120:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/collection"),a=t.number.isNumber,s=t.boolean.isBoolean,u=i.isComplex,c=o.isCollection;n.cube=function f(e){if(1!=arguments.length)throw new n.error.ArgumentsError("cube",arguments.length,1);if(a(e))return e*e*e;if(u(e))return n.multiply(n.multiply(e,e),e);if(e instanceof r)return e.times(e).times(e);if(c(e))return o.deepMap(e,f);if(s(e))return f(+e);throw new n.error.UnsupportedTypeError("cube",e)}}},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],121:[function(e,n){n.exports=function(n){function t(e,n){var t=n.re*n.re+n.im*n.im;return 0!=t?new o((e.re*n.re+e.im*n.im)/t,(e.im*n.re-e.re*n.im)/t):new o(0!=e.re?e.re/0:0,0!=e.im?e.im/0:0)}var r=e("../../util/index"),i=e("bignumber.js"),o=e("../../type/Complex"),a=(e("../../type/Matrix"),e("../../type/Unit")),s=e("../../type/collection"),u=r.number.isNumber,c=r.number.toNumber,f=r.number.toBigNumber,l=r.boolean.isBoolean,m=o.isComplex,p=a.isUnit,h=s.isCollection;n.divide=function g(e,r){if(2!=arguments.length)throw new n.error.ArgumentsError("divide",arguments.length,2);if(u(e)){if(u(r))return e/r;if(m(r))return t(new o(e,0),r)}if(m(e)){if(m(r))return t(e,r);if(u(r))return t(e,new o(r,0))}if(e instanceof i)return u(r)?r=f(r):l(r)&&(r=new i(r?1:0)),r instanceof i?e.div(r):g(c(e),r);if(r instanceof i)return u(e)?e=f(e):l(e)&&(e=new i(e?1:0)),e instanceof i?e.div(r):g(e,c(r));if(p(e)&&u(r)){var a=e.clone();return a.value/=r,a}if(h(e))return h(r)?n.multiply(e,n.inv(r)):s.deepMap2(e,r,g);if(h(r))return n.multiply(e,n.inv(r));if(l(e))return g(+e,r);if(l(r))return g(e,+r);throw new n.error.UnsupportedTypeError("divide",e,r)}}},{"../../type/Complex":202,"../../type/Matrix":205,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],122:[function(e,n){n.exports=function(n){var t=e("../../type/collection");n.edivide=function(e,r){if(2!=arguments.length)throw new n.error.ArgumentsError("edivide",arguments.length,2);return t.deepMap2(e,r,n.divide)}}},{"../../type/collection":208}],123:[function(e,n){n.exports=function(n){var t=e("../../type/collection");n.emultiply=function(e,r){if(2!=arguments.length)throw new n.error.ArgumentsError("emultiply",arguments.length,2);return t.deepMap2(e,r,n.multiply)}}},{"../../type/collection":208}],124:[function(e,n){n.exports=function(n){var t=e("../../type/collection");n.epow=function(e,r){if(2!=arguments.length)throw new n.error.ArgumentsError("epow",arguments.length,2);return t.deepMap2(e,r,n.pow)}}},{"../../type/collection":208}],125:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/Unit"),a=e("../../type/collection"),s=t.number.isNumber,u=t.number.toNumber,c=t.number.toBigNumber,f=t.boolean.isBoolean,l=t.string.isString,m=i.isComplex,p=o.isUnit,h=a.isCollection;n.equal=function g(e,t){if(2!=arguments.length)throw new n.error.ArgumentsError("equal",arguments.length,2);if(s(e)){if(s(t))return e==t;if(m(t))return e==t.re&&0==t.im}if(m(e)){if(s(t))return e.re==t&&0==e.im;if(m(t))return e.re==t.re&&e.im==t.im}if(e instanceof r)return s(t)?t=c(t):f(t)&&(t=new r(t?1:0)),t instanceof r?e.eq(t):g(u(e),t);if(t instanceof r)return s(e)?e=c(e):f(e)&&(e=new r(e?1:0)),e instanceof r?e.eq(t):g(e,u(t));if(p(e)&&p(t)){if(!e.equalBase(t))throw new Error("Cannot compare units with different base");return e.value==t.value}if(l(e)||l(t))return e==t;if(h(e)||h(t))return a.deepMap2(e,t,g);if(f(e))return g(+e,t);if(f(t))return g(e,+t);throw new n.error.UnsupportedTypeError("equal",e,t)}}},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],126:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=(e("../../type/Matrix"),e("../../type/collection")),a=t.number.isNumber,s=t.boolean.isBoolean,u=i.isComplex,c=o.isCollection;n.exp=function f(e){if(1!=arguments.length)throw new n.error.ArgumentsError("exp",arguments.length,1);if(a(e))return Math.exp(e);if(u(e)){var l=Math.exp(e.re);return new i(l*Math.cos(e.im),l*Math.sin(e.im))}if(e instanceof r)return f(t.number.toNumber(e));if(c(e))return o.deepMap(e,f);if(s(e))return Math.exp(e);throw new n.error.UnsupportedTypeError("exp",e)}}},{"../../type/Complex":202,"../../type/Matrix":205,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],127:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/collection"),a=t.number.isNumber,s=t.boolean.isBoolean,u=i.isComplex,c=o.isCollection;n.fix=function f(e){if(1!=arguments.length)throw new n.error.ArgumentsError("fix",arguments.length,1);if(a(e))return e>0?Math.floor(e):Math.ceil(e);if(u(e))return new i(e.re>0?Math.floor(e.re):Math.ceil(e.re),e.im>0?Math.floor(e.im):Math.ceil(e.im));if(e instanceof r)return e.isNegative()?e.ceil():e.floor();if(c(e))return o.deepMap(e,f);if(s(e))return f(+e);throw new n.error.UnsupportedTypeError("fix",e)}}},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],128:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/collection"),a=t.number.isNumber,s=t.boolean.isBoolean,u=i.isComplex,c=o.isCollection;n.floor=function f(e){if(1!=arguments.length)throw new n.error.ArgumentsError("floor",arguments.length,1);if(a(e))return Math.floor(e);if(u(e))return new i(Math.floor(e.re),Math.floor(e.im));if(e instanceof r)return e.floor();if(c(e))return o.deepMap(e,f);if(s(e))return f(+e);throw new n.error.UnsupportedTypeError("floor",e)}}},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],129:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/collection"),o=t.number.isNumber,a=t.number.toNumber,s=t.boolean.isBoolean,u=t.number.isInteger,c=i.isCollection;n.gcd=function f(){var e,t=arguments[0],l=arguments[1];if(2==arguments.length){if(o(t)&&o(l)){if(!u(t)||!u(l))throw new Error("Parameters in function gcd must be integer numbers");for(;0!=l;)e=t%l,t=l,l=e;return 0>t?-t:t}if(c(t)||c(l))return i.deepMap2(t,l,f);if(t instanceof r)return f(a(t),l);if(l instanceof r)return f(t,a(l));if(s(t))return f(+t,l);if(s(l))return f(t,+l);throw new n.error.UnsupportedTypeError("gcd",t,l)}if(arguments.length>2){for(var m=1;m<arguments.length;m++)t=f(t,arguments[m]);return t}throw new SyntaxError("Function gcd expects two or more arguments")}}},{"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],130:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/Unit"),a=e("../../type/collection"),s=t.number.isNumber,u=t.number.toNumber,c=t.number.toBigNumber,f=t.boolean.isBoolean,l=t.string.isString,m=i.isComplex,p=o.isUnit,h=a.isCollection;n.larger=function g(e,t){if(2!=arguments.length)throw new n.error.ArgumentsError("larger",arguments.length,2);if(s(e)&&s(t))return e>t;if(e instanceof r)return s(t)?t=c(t):f(t)&&(t=new r(t?1:0)),t instanceof r?e.gt(t):g(u(e),t);if(t instanceof r)return s(e)?e=c(e):f(e)&&(e=new r(e?1:0)),e instanceof r?e.gt(t):g(e,u(t));if(p(e)&&p(t)){if(!e.equalBase(t))throw new Error("Cannot compare units with different base");return e.value>t.value}if(l(e)||l(t))return e>t;if(h(e)||h(t))return a.deepMap2(e,t,g);if(f(e))return g(+e,t);if(f(t))return g(e,+t);if(m(e)||m(t))throw new TypeError("No ordering relation is defined for complex numbers");throw new n.error.UnsupportedTypeError("larger",e,t)}}},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],131:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/Unit"),a=e("../../type/collection"),s=t.number.isNumber,u=t.number.toNumber,c=t.number.toBigNumber,f=t.boolean.isBoolean,l=t.string.isString,m=i.isComplex,p=o.isUnit,h=a.isCollection;n.largereq=function g(e,t){if(2!=arguments.length)throw new n.error.ArgumentsError("largereq",arguments.length,2);if(s(e)&&s(t))return e>=t;if(e instanceof r)return s(t)?t=c(t):f(t)&&(t=new r(t?1:0)),t instanceof r?e.gte(t):g(u(e),t);if(t instanceof r)return s(e)?e=c(e):f(e)&&(e=new r(e?1:0)),e instanceof r?e.gte(t):g(e,u(t));if(p(e)&&p(t)){if(!e.equalBase(t))throw new Error("Cannot compare units with different base");return e.value>=t.value}if(l(e)||l(t))return e>=t;if(h(e)||h(t))return a.deepMap2(e,t,g);if(f(e))return g(+e,t);if(f(t))return g(e,+t);if(m(e)||m(t))throw new TypeError("No ordering relation is defined for complex numbers");throw new n.error.UnsupportedTypeError("largereq",e,t)}}},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],132:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/collection"),o=t.number.isNumber,a=t.number.toNumber,s=t.boolean.isBoolean,u=t.number.isInteger,c=i.isCollection;n.lcm=function f(){var e,t=arguments[0],l=arguments[1];if(2==arguments.length){if(o(t)&&o(l)){if(!u(t)||!u(l))throw new Error("Parameters in function lcm must be integer numbers");if(0==t||0==l)return 0;for(var m=t*l;0!=l;)e=l,l=t%e,t=e;return Math.abs(m/t)}if(c(t)||c(l))return i.deepMap2(t,l,f);if(s(t))return f(+t,l);if(s(l))return f(t,+l);if(t instanceof r)return f(a(t),l);if(l instanceof r)return f(t,a(l));throw new n.error.UnsupportedTypeError("lcm",t,l)}if(arguments.length>2){for(var p=1;p<arguments.length;p++)t=f(t,arguments[p]);return t}throw new SyntaxError("Function lcm expects two or more arguments")}}},{"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],133:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/collection"),a=t.number.isNumber,s=t.boolean.isBoolean,u=i.isComplex,c=o.isCollection;n.log=function f(e,l){if(1==arguments.length){if(a(e))return e>=0?Math.log(e):f(new i(e,0));if(u(e))return new i(Math.log(Math.sqrt(e.re*e.re+e.im*e.im)),Math.atan2(e.im,e.re));if(e instanceof r)return f(t.number.toNumber(e));if(c(e))return o.deepMap(e,f);if(s(e))return f(+e);throw new n.error.UnsupportedTypeError("log",e)}if(2==arguments.length)return n.divide(f(e),f(l));throw new n.error.ArgumentsError("log",arguments.length,1,2)}}},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],134:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/collection"),a=t.number.isNumber,s=t.boolean.isBoolean,u=i.isComplex,c=o.isCollection;n.log10=function f(e){if(1!=arguments.length)throw new n.error.ArgumentsError("log10",arguments.length,1);if(a(e))return e>=0?Math.log(e)/Math.LN10:f(new i(e,0));if(e instanceof r)return f(t.number.toNumber(e));if(u(e))return new i(Math.log(Math.sqrt(e.re*e.re+e.im*e.im))/Math.LN10,Math.atan2(e.im,e.re)/Math.LN10);if(c(e))return o.deepMap(e,f);if(s(e))return f(+e);throw new n.error.UnsupportedTypeError("log10",e)}}},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],135:[function(e,n){n.exports=function(n){function t(e,n){if(n>0)return e>0?e%n:0==e?0:e-n*Math.floor(e/n);if(0==n)return e;throw new Error("Cannot calculate mod for a negative divisor")}var r=e("../../util/index"),i=e("bignumber.js"),o=e("../../type/collection"),a=r.number.isNumber,s=r.number.toNumber,u=r.number.toBigNumber,c=r.boolean.isBoolean,f=o.isCollection;n.mod=function l(e,r){if(2!=arguments.length)throw new n.error.ArgumentsError("mod",arguments.length,2);if(a(e)&&a(r))return t(e,r);if(e instanceof i)return a(r)?r=u(r):c(r)&&(r=new i(r?1:0)),r instanceof i?e.mod(r):l(s(e),r);if(r instanceof i)return a(e)?e=u(e):c(e)&&(e=new i(e?1:0)),e instanceof i?e.mod(r):l(e,s(r));if(f(e)||f(r))return o.deepMap2(e,r,l);if(c(e))return l(+e,r);if(c(r))return l(e,+r);throw new n.error.UnsupportedTypeError("mod",e,r)}}},{"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],136:[function(e,n){n.exports=function(n){function t(e,t){for(var r=[],i=e.length,o=t[0].length,a=e[0].length,s=0;i>s;s++){r[s]=[];for(var u=0;o>u;u++){for(var c=null,f=0;a>f;f++){var l=n.multiply(e[s][f],t[f][u]);c=null===c?l:n.add(c,l)}r[s][u]=c}}return r}function r(e,t){for(var r=[],i=t.length,o=t[0].length,a=0;o>a;a++){for(var s=null,u=0;i>u;u++){var c=n.multiply(e[u],t[u][a]);s=0===u?c:n.add(s,c)}r[a]=s}return r}function i(e,t){for(var r=[],i=e.length,o=e[0].length,a=0;i>a;a++){for(var s=null,u=0;o>u;u++){var c=n.multiply(e[a][u],t[u]);s=0===u?c:n.add(s,c)}r[a]=s}return r}function o(e,t){var r=e.length,i=null;if(r){i=0;for(var o=0,a=e.length;a>o;o++)i=n.add(i,n.multiply(e[o],t[o]))}return i}function a(e,n){return 0==e.im?0==n.im?e.re*n.re:0==n.re?new c(0,e.re*n.im):new c(e.re*n.re,e.re*n.im):0==e.re?0==n.im?new c(0,e.im*n.re):0==n.re?-e.im*n.im:new c(-e.im*n.im,e.im*n.re):0==n.im?new c(e.re*n.re,e.im*n.re):0==n.re?new c(-e.im*n.im,e.re*n.im):new c(e.re*n.re-e.im*n.im,e.re*n.im+e.im*n.re)}var s=e("../../util/index"),u=e("bignumber.js"),c=e("../../type/Complex"),f=e("../../type/Matrix"),l=e("../../type/Unit"),m=e("../../type/collection"),p=s.array,h=s.number.isNumber,g=s.number.toNumber,x=s.number.toBigNumber,d=s.boolean.isBoolean,y=c.isComplex,b=Array.isArray,v=l.isUnit;n.multiply=function w(e,s){if(2!=arguments.length)throw new n.error.ArgumentsError("multiply",arguments.length,2);if(h(e)){if(h(s))return e*s;if(y(s))return a(new c(e,0),s);if(v(s))return res=s.clone(),res.value*=e,res}if(y(e)){if(h(s))return a(e,new c(s,0));if(y(s))return a(e,s)}if(e instanceof u)return h(s)?s=x(s):d(s)&&(s=new u(s?1:0)),s instanceof u?e.times(s):w(g(e),s);if(s instanceof u)return h(e)?e=x(e):d(e)&&(e=new u(e?1:0)),e instanceof u?e.times(s):w(e,g(s));if(v(e)&&h(s))return res=e.clone(),res.value*=s,res;if(b(e)){if(b(s)){var l=p.size(e),E=p.size(s);if(1==l.length){if(1==E.length){if(l[0]!=E[0])throw new RangeError("Dimensions mismatch in multiplication. Length of A must match length of B (A is "+l[0]+", B is "+E[0]+l[0]+" != "+E[0]+")");return o(e,s)}if(2==E.length){if(l[0]!=E[0])throw new RangeError("Dimensions mismatch in multiplication. Length of A must match rows of B (A is "+l[0]+", B is "+E[0]+"x"+E[1]+", "+l[0]+" != "+E[0]+")");return r(e,s)}throw new Error("Can only multiply a 1 or 2 dimensional matrix (B has "+E.length+" dimensions)")}if(2==l.length){if(1==E.length){if(l[1]!=E[0])throw new RangeError("Dimensions mismatch in multiplication. Columns of A must match length of B (A is "+l[0]+"x"+l[0]+", B is "+E[0]+", "+l[1]+" != "+E[0]+")");return i(e,s)}if(2==E.length){if(l[1]!=E[0])throw new RangeError("Dimensions mismatch in multiplication. Columns of A must match rows of B (A is "+l[0]+"x"+l[1]+", B is "+E[0]+"x"+E[1]+", "+l[1]+" != "+E[0]+")");return t(e,s)}throw new Error("Can only multiply a 1 or 2 dimensional matrix (B has "+E.length+" dimensions)")}throw new Error("Can only multiply a 1 or 2 dimensional matrix (A has "+l.length+" dimensions)")}return s instanceof f?new f(w(e,s.valueOf())):m.deepMap2(e,s,w)}if(e instanceof f)return s instanceof f?new f(w(e.valueOf(),s.valueOf())):new f(w(e.valueOf(),s));if(b(s))return m.deepMap2(e,s,w);if(s instanceof f)return new f(m.deepMap2(e,s.valueOf(),w));if(d(e))return w(+e,s);if(d(s))return w(e,+s);throw new n.error.UnsupportedTypeError("multiply",e,s)}}},{"../../type/Complex":202,"../../type/Matrix":205,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],137:[function(e,n){n.exports=function(n){function t(e,t){var r=n.log(e),i=n.multiply(r,t);return n.exp(i)}var r=e("../../util/index"),i=e("bignumber.js"),o=e("../../type/Complex"),a=e("../../type/Matrix"),s=(e("../../type/collection"),r.array),u=r.number.isNumber,c=r.number.toNumber,f=r.number.toBigNumber,l=r.boolean.isBoolean,m=Array.isArray,p=r.number.isInteger,h=o.isComplex;
+n.pow=function g(e,r){if(2!=arguments.length)throw new n.error.ArgumentsError("pow",arguments.length,2);if(u(e)){if(u(r))return p(r)||e>=0?Math.pow(e,r):t(new o(e,0),new o(r,0));if(h(r))return t(new o(e,0),r)}if(h(e)){if(u(r))return t(e,new o(r,0));if(h(r))return t(e,r)}if(e instanceof i)return u(r)?r=f(r):l(r)&&(r=new i(r?1:0)),r instanceof i?e.pow(r):g(c(e),r);if(r instanceof i)return u(e)?e=f(e):l(e)&&(e=new i(e?1:0)),e instanceof i?e.pow(r):g(e,c(r));if(m(e)){if(!u(r)||!p(r)||0>r)throw new TypeError("For A^b, b must be a positive integer (value is "+r+")");var x=s.size(e);if(2!=x.length)throw new Error("For A^b, A must be 2 dimensional (A has "+x.length+" dimensions)");if(x[0]!=x[1])throw new Error("For A^b, A must be square (size is "+x[0]+"x"+x[1]+")");if(0==r)return n.eye(x[0]);for(var d=e,y=1;r>y;y++)d=n.multiply(e,d);return d}if(e instanceof a)return new a(g(e.valueOf(),r));if(l(e))return g(+e,r);if(l(r))return g(e,+r);throw new n.error.UnsupportedTypeError("pow",e,r)}}},{"../../type/Complex":202,"../../type/Matrix":205,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],138:[function(e,n){n.exports=function(n){function t(e,n){if(n){var t=Math.pow(10,n);return Math.round(e*t)/t}return Math.round(e)}var r=e("../../util/index"),i=e("bignumber.js"),o=e("../../type/Complex"),a=e("../../type/collection"),s=r.number.isNumber,u=r.number.isInteger,c=r.boolean.isBoolean,f=o.isComplex,l=a.isCollection;n.round=function m(e,r){if(1!=arguments.length&&2!=arguments.length)throw new n.error.ArgumentsError("round",arguments.length,1,2);if(void 0==r){if(s(e))return Math.round(e);if(f(e))return new o(Math.round(e.re),Math.round(e.im));if(e instanceof i)return e.round();if(l(e))return a.deepMap(e,m);if(c(e))return Math.round(e);throw new n.error.UnsupportedTypeError("round",e)}if(r instanceof i&&(r=parseFloat(r.valueOf())),!s(r)||!u(r))throw new TypeError("Number of decimals in function round must be an integer");if(0>r||r>9)throw new Error("Number of decimals in function round must be in te range of 0-9");if(s(e))return t(e,r);if(f(e))return new o(t(e.re,r),t(e.im,r));if(e instanceof i&&s(r))return e.round(r);if(l(e)||l(r))return a.deepMap2(e,r,m);if(c(e))return m(+e,r);if(c(r))return m(e,+r);throw new n.error.UnsupportedTypeError("round",e,r)}}},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],139:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/collection"),a=t.number,s=t.number.isNumber,u=t.boolean.isBoolean,c=i.isComplex,f=o.isCollection;n.sign=function l(e){if(1!=arguments.length)throw new n.error.ArgumentsError("sign",arguments.length,1);if(s(e))return a.sign(e);if(c(e)){var t=Math.sqrt(e.re*e.re+e.im*e.im);return new i(e.re/t,e.im/t)}if(e instanceof r)return new r(e.cmp(0));if(f(e))return o.deepMap(e,l);if(u(e))return a.sign(e);throw new n.error.UnsupportedTypeError("sign",e)}}},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],140:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/Unit"),a=e("../../type/collection"),s=t.number.isNumber,u=t.number.toNumber,c=t.number.toBigNumber,f=t.boolean.isBoolean,l=t.string.isString,m=i.isComplex,p=o.isUnit,h=a.isCollection;n.smaller=function g(e,t){if(2!=arguments.length)throw new n.error.ArgumentsError("smaller",arguments.length,2);if(s(e)&&s(t))return t>e;if(e instanceof r)return s(t)?t=c(t):f(t)&&(t=new r(t?1:0)),t instanceof r?e.lt(t):g(u(e),t);if(t instanceof r)return s(e)?e=c(e):f(e)&&(e=new r(e?1:0)),e instanceof r?e.lt(t):g(e,u(t));if(p(e)&&p(t)){if(!e.equalBase(t))throw new Error("Cannot compare units with different base");return e.value<t.value}if(l(e)||l(t))return t>e;if(h(e)||h(t))return a.deepMap2(e,t,g);if(f(e))return g(+e,t);if(f(t))return g(e,+t);if(m(e)||m(t))throw new TypeError("No ordering relation is defined for complex numbers");throw new n.error.UnsupportedTypeError("smaller",e,t)}}},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],141:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/Unit"),a=e("../../type/collection"),s=t.number.isNumber,u=t.number.toNumber,c=t.number.toBigNumber,f=t.boolean.isBoolean,l=t.string.isString,m=i.isComplex,p=o.isUnit,h=a.isCollection;n.smallereq=function g(e,t){if(2!=arguments.length)throw new n.error.ArgumentsError("smallereq",arguments.length,2);if(s(e)&&s(t))return t>=e;if(e instanceof r)return s(t)?t=c(t):f(t)&&(t=new r(t?1:0)),t instanceof r?e.lte(t):g(u(e),t);if(t instanceof r)return s(e)?e=c(e):f(e)&&(e=new r(e?1:0)),e instanceof r?e.lte(t):g(e,u(t));if(p(e)&&p(t)){if(!e.equalBase(t))throw new Error("Cannot compare units with different base");return e.value<=t.value}if(l(e)||l(t))return t>=e;if(h(e)||h(t))return a.deepMap2(e,t,g);if(f(e))return g(+e,t);if(f(t))return g(e,+t);if(m(e)||m(t))throw new TypeError("No ordering relation is defined for complex numbers");throw new n.error.UnsupportedTypeError("smallereq",e,t)}}},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],142:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/collection"),a=t.number.isNumber,s=t.boolean.isBoolean,u=i.isComplex,c=o.isCollection;n.sqrt=function f(e){if(1!=arguments.length)throw new n.error.ArgumentsError("sqrt",arguments.length,1);if(a(e))return e>=0?Math.sqrt(e):f(new i(e,0));if(u(e)){var t=Math.sqrt(e.re*e.re+e.im*e.im);return e.im>=0?new i(.5*Math.sqrt(2*(t+e.re)),.5*Math.sqrt(2*(t-e.re))):new i(.5*Math.sqrt(2*(t+e.re)),-.5*Math.sqrt(2*(t-e.re)))}if(e instanceof r)return e.sqrt();if(c(e))return o.deepMap(e,f);if(s(e))return f(+e);throw new n.error.UnsupportedTypeError("sqrt",e)}}},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],143:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/collection"),a=t.number.isNumber,s=t.boolean.isBoolean,u=i.isComplex,c=o.isCollection;n.square=function f(e){if(1!=arguments.length)throw new n.error.ArgumentsError("square",arguments.length,1);if(a(e))return e*e;if(u(e))return n.multiply(e,e);if(e instanceof r)return e.times(e);if(c(e))return o.deepMap(e,f);if(s(e))return e*e;throw new n.error.UnsupportedTypeError("square",e)}}},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],144:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=(e("../../type/Matrix"),e("../../type/Unit")),a=e("../../type/collection"),s=t.number.toNumber,u=t.number.toBigNumber,c=t.boolean.isBoolean,f=t.number.isNumber,l=i.isComplex,m=o.isUnit,p=a.isCollection;n.subtract=function h(e,t){if(2!=arguments.length)throw new n.error.ArgumentsError("subtract",arguments.length,2);if(f(e)){if(f(t))return e-t;if(l(t))return new i(e-t.re,-t.im)}else if(l(e)){if(f(t))return new i(e.re-t,e.im);if(l(t))return new i(e.re-t.re,e.im-t.im)}if(e instanceof r)return f(t)?t=u(t):c(t)&&(t=new r(t?1:0)),t instanceof r?e.minus(t):h(s(e),t);if(t instanceof r)return f(e)?e=u(e):c(e)&&(e=new r(e?1:0)),e instanceof r?e.minus(t):h(e,s(t));if(m(e)&&m(t)){if(!e.equalBase(t))throw new Error("Units do not match");if(null==e.value)throw new Error("Unit on left hand side of operator - has an undefined value");if(null==t.value)throw new Error("Unit on right hand side of operator - has an undefined value");var o=e.clone();return o.value-=t.value,o.fixPrefix=!1,o}if(p(e)||p(t))return a.deepMap2(e,t,h);if(c(e))return h(+e,t);if(c(t))return h(e,+t);throw new n.error.UnsupportedTypeError("subtract",e,t)}}},{"../../type/Complex":202,"../../type/Matrix":205,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],145:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/Unit"),a=e("../../type/collection"),s=t.number.isNumber,u=t.boolean.isBoolean,c=i.isComplex,f=o.isUnit,l=a.isCollection;n.unary=function m(e){if(1!=arguments.length)throw new n.error.ArgumentsError("unary",arguments.length,1);if(s(e))return-e;if(c(e))return new i(-e.re,-e.im);if(e instanceof r)return e.neg();if(f(e)){var t=e.clone();return t.value=-e.value,t}if(l(e))return a.deepMap(e,m);if(u(e))return-e;throw new n.error.UnsupportedTypeError("unary",e)}}},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],146:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/Unit"),a=e("../../type/collection"),s=t.number.isNumber,u=t.number.toNumber,c=t.number.toBigNumber,f=t.boolean.isBoolean,l=t.string.isString,m=i.isComplex,p=o.isUnit,h=a.isCollection;n.unequal=function g(e,t){if(2!=arguments.length)throw new n.error.ArgumentsError("unequal",arguments.length,2);if(s(e)){if(s(t))return e!=t;if(m(t))return e!=t.re||0!=t.im}if(m(e)){if(s(t))return e.re!=t||0!=e.im;if(m(t))return e.re!=t.re||e.im!=t.im}if(e instanceof r)return s(t)?t=c(t):f(t)&&(t=new r(t?1:0)),t instanceof r?!e.eq(t):g(u(e),t);if(t instanceof r)return s(e)?e=c(e):f(e)&&(e=new r(e?1:0)),e instanceof r?!e.eq(t):g(e,u(t));if(p(e)&&p(t)){if(!e.equalBase(t))throw new Error("Cannot compare units with different base");return e.value!=t.value}if(l(e)||l(t))return e!=t;if(h(e)||h(t))return a.deepMap2(e,t,g);if(f(e))return g(+e,t);if(f(t))return g(e,+t);throw new n.error.UnsupportedTypeError("unequal",e,t)}}},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],147:[function(e,n){n.exports=function(n){function t(e,n){for(var t,r,i,o=0,a=1,s=1,u=0;n;)r=Math.floor(e/n),i=e%n,t=o,o=a-r*o,a=t,t=s,s=u-r*s,u=t,e=n,n=i;return 0>e?[-e,e?-a:0,-u]:[e,e?a:0,u]}var r=e("../../util/index"),i=e("bignumber.js"),o=r.number.toNumber,a=r.number.isNumber,s=r.boolean.isBoolean,u=r.number.isInteger;n.xgcd=function c(e,r){if(2==arguments.length){if(a(e)&&a(r)){if(!u(e)||!u(r))throw new Error("Parameters in function xgcd must be integer numbers");return t(e,r)}if(e instanceof i)return c(o(e),r);if(r instanceof i)return c(e,o(r));if(s(e))return c(+e,r);if(s(r))return c(e,+r);throw new n.error.UnsupportedTypeError("xgcd",e,r)}throw new SyntaxError("Function xgcd expects two arguments")}}},{"../../util/index":212,"bignumber.js":217}],148:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/collection"),a=t.number.isNumber,s=t.boolean.isBoolean,u=o.isCollection,c=i.isComplex;n.arg=function f(e){if(1!=arguments.length)throw new n.error.ArgumentsError("arg",arguments.length,1);if(a(e))return Math.atan2(0,e);if(c(e))return Math.atan2(e.im,e.re);if(u(e))return o.deepMap(e,f);if(s(e))return f(+e);if(e instanceof r)return f(t.number.toNumber(e));throw new n.error.UnsupportedTypeError("arg",e)}}},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],149:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/collection"),a=t.object,s=t.number.isNumber,u=t.boolean.isBoolean,c=o.isCollection,f=i.isComplex;n.conj=function l(e){if(1!=arguments.length)throw new n.error.ArgumentsError("conj",arguments.length,1);return s(e)?e:e instanceof r?new r(e):f(e)?new i(e.re,-e.im):c(e)?o.deepMap(e,l):u(e)?+e:a.clone(e)}}},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],150:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/collection"),a=t.number.isNumber,s=t.boolean.isBoolean,u=o.isCollection,c=i.isComplex;n.im=function f(e){if(1!=arguments.length)throw new n.error.ArgumentsError("im",arguments.length,1);return a(e)?0:e instanceof r?new r(0):c(e)?e.im:u(e)?o.deepMap(e,f):s(e)?0:0}}},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],151:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/collection"),a=t.object,s=t.number.isNumber,u=t.boolean.isBoolean,c=o.isCollection,f=i.isComplex;n.re=function l(e){if(1!=arguments.length)throw new n.error.ArgumentsError("re",arguments.length,1);return s(e)?e:e instanceof r?new r(e):f(e)?e.re:c(e)?o.deepMap(e,l):u(e)?+e:a.clone(e)}}},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],152:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/collection"),o=i.isCollection,a=t.number.isNumber,s=t.string.isString,u=t.boolean.isBoolean;"function"!=typeof r.prototype.clone&&(r.prototype.clone=function(){return new r(this)}),n.bignumber=function c(e){if(arguments.length>1)throw new n.error.ArgumentsError("bignumber",arguments.length,0,1);if(e instanceof r||a(e)||s(e))return new r(e);if(u(e))return new r(+e);if(o(e))return i.deepMap(e,c);if(0==arguments.length)return new r(0);throw new n.error.UnsupportedTypeError("bignumber",e)}}},{"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],153:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/collection"),o=i.isCollection,a=t.number.isNumber,s=t.string.isString;n["boolean"]=function u(e){if(1!=arguments.length)throw new n.error.ArgumentsError("boolean",arguments.length,0,1);if("true"===e||e===!0)return!0;if("false"===e||e===!1)return!1;if(e instanceof Boolean)return e?!0:!1;if(a(e))return 0!==e;if(e instanceof r)return!e.isZero();if(s(e)){var t=e.toLowerCase();if("true"===t)return!0;if("false"===t)return!1;var c=Number(e);if(""!=e&&!isNaN(c))return 0!==c}if(o(e))return i.deepMap(e,u);throw new SyntaxError(e.toString()+" is no valid boolean")}}},{"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],154:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/collection"),a=o.isCollection,s=t.number.isNumber,u=t.number.toNumber,c=t.string.isString,f=i.isComplex;n.complex=function l(){switch(arguments.length){case 0:return new i(0,0);case 1:var e=arguments[0];if(s(e))return new i(e,0);if(e instanceof r)return new i(u(e),0);if(f(e))return e.clone();if(c(e)){var t=i.parse(e);if(t)return t;throw new SyntaxError('String "'+e+'" is no valid complex number')}if(a(e))return o.deepMap(e,l);throw new TypeError("Two numbers or a single string expected in function complex");case 2:var m=arguments[0],p=arguments[1];if(m instanceof r&&(m=u(m)),p instanceof r&&(p=u(p)),s(m)&&s(p))return new i(m,p);throw new TypeError("Two numbers or a single string expected in function complex");default:throw new n.error.ArgumentsError("complex",arguments.length,0,2)}}}},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],155:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Index"),o=t.number.toNumber;n.index=function(){var e=new i,n=Array.prototype.slice.apply(arguments).map(function(e){return e instanceof r?o(e):Array.isArray(e)?e.map(function(e){return e instanceof r?o(e):e}):e});return i.apply(e,n),e}}},{"../../type/Index":204,"../../util/index":212,"bignumber.js":217}],156:[function(e,n){n.exports=function(n){var t=e("../../type/Matrix");n.matrix=function(e){if(arguments.length>1)throw new n.error.ArgumentsError("matrix",arguments.length,0,1);return new t(e)}}},{"../../type/Matrix":205}],157:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/collection"),o=i.isCollection,a=t.number.toNumber;n.number=function s(e){switch(arguments.length){case 0:return 0;case 1:if(o(e))return i.deepMap(e,s);if(e instanceof r)return a(e);var t=Number(e);if(isNaN(t)&&(t=Number(e.valueOf())),isNaN(t))throw new SyntaxError(e.toString()+" is no valid number");return t;default:throw new n.error.ArgumentsError("number",arguments.length,0,1)}}}},{"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],158:[function(e,n){n.exports=function(n){var t=e("../../expression/Parser");n.parser=function(){return new t(n)}}},{"../../expression/Parser":4}],159:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("../../type/collection"),i=t.number,o=t.number.isNumber,a=r.isCollection;n.string=function s(e){switch(arguments.length){case 0:return"";case 1:return o(e)?i.format(e):a(e)?r.deepMap(e,s):null===e?"null":e.toString();default:throw new n.error.ArgumentsError("string",arguments.length,0,1)}}}},{"../../type/collection":208,"../../util/index":212}],160:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Unit"),o=e("../../type/collection"),a=o.isCollection,s=t.number.toNumber,u=t.string.isString;n.unit=function c(e){switch(arguments.length){case 1:var t=arguments[0];if(t instanceof i)return t.clone();if(u(t)){if(i.isPlainUnit(t))return new i(null,t);var f=i.parse(t);if(f)return f;throw new SyntaxError('String "'+t+'" is no valid unit')}if(a(e))return o.deepMap(e,c);throw new TypeError("A string or a number and string expected in function unit");case 2:return arguments[0]instanceof r?new i(s(arguments[0]),arguments[1]):new i(arguments[0],arguments[1]);default:throw new n.error.ArgumentsError("unit",arguments.length,1,2)}}}},{"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],161:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("../../expression/Scope"),i=e("../../type/collection"),o=t.string.isString,a=i.isCollection;n.eval=function(e,t){if(1!=arguments.length&&2!=arguments.length)throw new n.error.ArgumentsError("eval",arguments.length,1,2);var s;if(s=t?t instanceof r?t:new r(n,t):new r(n),o(e)){var u=n.parse(e,s);return u.eval()}if(a(e))return i.deepMap(e,function(e){var t=n.parse(e,s);return t.eval()});throw new TypeError("String or matrix expected")}}},{"../../expression/Scope":5,"../../type/collection":208,"../../util/index":212}],162:[function(e,n){n.exports=function(n){var t=e("../../type/Help");n.help=function(e){if(1!=arguments.length)throw new SyntaxError("Wrong number of arguments in function help ("+arguments.length+" provided, 1 expected)");var r=null;if(e instanceof String||"string"==typeof e)r=e;else{var i;for(i in n)if(n.hasOwnProperty(i)&&e===n[i]){r=i;break}if(!r)for(i in n.type)if(n.type.hasOwnProperty(i)&&e===n.type[i]){r=i;break}}if(r){var o=n.expression.docs[r];if(!o)throw new Error('No documentation found on "'+r+'"');return new t(n,o)}throw new Error('Could not find search term "'+e+'"')}}},{"../../type/Help":203}],163:[function(e,n){n.exports=function(n,t){function r(){mn=0,pn=ln.charAt(0)}function i(){mn++,pn=ln.charAt(mn)}function o(){return ln.charAt(mn+1)}function a(){for(gn=un.NULL,hn="";" "==pn||"	"==pn;)i();if("#"==pn)for(;"\n"!=pn&&""!=pn;)i();if(""==pn)return gn=un.DELIMITER,void 0;var e=pn+o();if(cn[e])return gn=un.DELIMITER,hn=e,i(),i(),void 0;if(cn[pn])return gn=un.DELIMITER,hn=pn,i(),void 0;if(!u(pn)){if(s(pn)){for(;s(pn)||c(pn);)hn+=pn,i();return gn=fn[hn]?un.DELIMITER:un.SYMBOL,void 0}for(gn=un.UNKNOWN;""!=pn;)hn+=pn,i();throw B('Syntax error in part "'+hn+'"')}if(gn=un.NUMBER,"."==pn)hn+=pn,i(),c(pn)||(gn=un.UNKNOWN);else{for(;c(pn);)hn+=pn,i();"."==pn&&(hn+=pn,i())}for(;c(pn);)hn+=pn,i();if("E"==pn||"e"==pn)for(hn+=pn,i(),("+"==pn||"-"==pn)&&(hn+=pn,i()),c(pn)||(gn=un.UNKNOWN);c(pn);)hn+=pn,i()}function s(e){return e>="a"&&"z">=e||e>="A"&&"Z">=e||"_"==e}function u(e){return e>="0"&&"9">=e||"."==e}function c(e){return e>="0"&&"9">=e}function f(e){r(),a();var n;if(n=""==hn?new X(void 0):l(e),""!=hn)throw gn==un.DELIMITER?P("Unknown operator "+hn):B('Unexpected part "'+hn+'"');return n}function l(e){var n,t,r;for("\n"!=hn&&";"!=hn&&""!=hn&&(n=m(e));"\n"==hn||";"==hn;)t||(t=new $,n&&(r=";"!=hn,t.add(n,r))),a(),"\n"!=hn&&";"!=hn&&""!=hn&&(n=m(e),r=";"!=hn,t.add(n,r));return t?t:(n||(n=m(e)),n)}function m(e){var n=p(e),t="ans";return new K(t,n,e)}function p(e){if(gn==un.SYMBOL&&"function"==hn){if(a(),gn!=un.SYMBOL)throw B("Function name expected");var n=hn;if(a(),"("!=hn)throw B("Opening parenthesis ( expected");for(var t=e.createSubScope(),r=[];;)if(a(),gn==un.SYMBOL&&(r.push(hn),a()),","!=hn){if(")"==hn)break;throw B('Comma , or closing parenthesis ) expected"')}if(a(),"="!=hn)throw B("Equal sign = expected");a();var i=h(t);return new J(n,r,i,t,e)}return h(e)}function h(e){var t,r,i,o,s=g(e);if("="==hn){if(s instanceof on)return a(),t=s.name,r=null,o=h(e),new K(t,o,e);if(s instanceof tn&&s.object instanceof on)return a(),t=s.object.name,r=s.params,i=s.paramScopes,o=h(e),new an(n,t,r,i,o,e);throw B("Symbol expected at the left hand side of assignment operator =")}return s}function g(e){var r,i=[];if(":"==hn){var o="bignumber"===t.number.defaultType?new H(1):1;r=new X(o)}else r=x(e);if(":"==hn){for(i.push(r);":"==hn;)a(),")"==hn||","==hn||""==hn?i.push(new on("end",e)):i.push(x(e));i.length&&(r=new rn(n,t,i))}return r}function x(e){var n=d(e);return n}function d(e){var t,r,i,o,s;for(t=y(e),r={"==":n.equal,"!=":n.unequal,"<":n.smaller,">":n.larger,"<=":n.smallereq,">=":n.largereq};void 0!==r[hn];)i=hn,o=r[i],a(),s=[t,y(e)],t=new nn(i,o,s);return t}function y(e){var t,r,i,o,s;for(t=b(e),r={"in":n["in"]};void 0!==r[hn];)i=hn,o=r[i],a(),s=[t,b(e)],t=new nn(i,o,s);return t}function b(e){var t,r,i,o,s;for(t=v(e),r={"+":n.add,"-":n.subtract};void 0!==r[hn];)i=hn,o=r[i],a(),s=[t,v(e)],t=new nn(i,o,s);return t}function v(e){var t,r,i,o,s;for(t=w(e),r={"*":n.multiply,".*":n.emultiply,"/":n.divide,"./":n.edivide,"%":n.mod,mod:n.mod};void 0!==r[hn];)i=hn,o=r[i],a(),s=[t,w(e)],t=new nn(i,o,s);return t}function w(e){var t,r,i;return"-"==hn?(t=hn,r=n.unary,a(),i=[w(e)],new nn(t,r,i)):E(e)}function E(e){var t,r,i,o,s,u,c;for(i=[N(e)],o=[];"^"==hn||".^"==hn;)o.push(hn),a(),i.push(N(e));for(t=i.pop();i.length;)r=i.pop(),s=o.pop(),u="^"==s?n.pow:n.epow,c=[r,t],t=new nn(s,u,c);return t}function N(e){var t,r,i,o;for(t=M(e);"!"==hn;)r=hn,i=n.factorial,a(),o=[t],t=new nn(r,i,o);return t}function M(e){var t,r,i,o;for(t=j(e);"'"==hn;)r=hn,i=n.transpose,a(),o=[t],t=new nn(r,i,o);return t}function j(e){var n,t,r,i;if(gn==un.SYMBOL&&sn[hn]){if(i=sn[hn],a(),"("==hn){if(n=[],t=[],a(),")"!=hn)for(r=e.createSubScope(),t.push(r),n.push(g(r));","==hn;)a(),r=e.createSubScope(),t.push(r),n.push(g(r));if(")"!=hn)throw B("Parenthesis ) expected");a()}return new i(n,t)}return C(e)}function C(e){var n,t;return gn==un.SYMBOL?(t=hn,a(),n=new on(t,e),A(e,n)):O(e)}function A(e,t){for(var r,i,o,s;"("==hn;){if(r=hn,i=[],o=[],a(),")"!=hn)for(s=e.createSubScope(),o.push(s),i.push(g(s));","==hn;)a(),s=e.createSubScope(),o.push(s),i.push(g(s));if("("==r&&")"!=hn)throw B("Parenthesis ) expected");a(),t=new tn(n,t,i,o)}return t}function O(e){var n,t,r;if('"'==hn){for(t="",r="";""!=pn&&('"'!=pn||"\\"==r);)t+=pn,r=pn,i();if(a(),'"'!=hn)throw B('End of string " expected');return a(),n=new X(t),n=A(e,n)}return S(e)}function S(e){var n,r,i,o;if("["==hn){for(a();"\n"==hn;)a();if("]"!=hn){var s=T(e);if(";"==hn){for(i=1,r=[s];";"==hn;){for(a();"\n"==hn;)a();for(r[i]=T(e),i++;"\n"==hn;)a()}if("]"!=hn)throw B("End of matrix ] expected");a(),o=r.length>0?r[0].length:0;for(var u=1;i>u;u++)if(r[u].length!=o)throw P("Number of columns must match ("+r[u].length+" != "+o+")");n=new en(t,r)}else{if("]"!=hn)throw B("End of matrix ] expected");a(),n=s}}else a(),n=new en(t,[]);return n=A(e,n)}return U(e)}function T(e){for(var n=[h(e)],r=1;","==hn;){for(a();"\n"==hn;)a();for(n[r]=h(e),r++;"\n"==hn;)a()}return new en(t,n)}function U(e){var n,r,i;if(gn==un.NUMBER){if(i="bignumber"==t.number.defaultType?new H("."==hn?0:hn):"."==hn?0:Number(hn),a(),gn==un.SYMBOL){if(i=i instanceof H?k(i):i,"i"==hn||"I"==hn)return r=new V(0,i),a(),new X(r);if(Y.isPlainUnit(hn))return r=new Y(i,hn),a(),new X(r);throw _('Unknown unit "'+hn+'"')}return n=new X(i),n=A(e,n)}return q(e)}function q(e){var n;if("("==hn){if(a(),n=h(e),")"!=hn)throw B("Parenthesis ) expected");return a(),n=A(e,n)}return z(e)}function z(){throw""==hn?B("Unexpected end of expression"):B("Value expected")}function R(){return void 0}function I(){return mn-hn.length+1}function L(e){var n=R(),t=I();return void 0===n?void 0===t?e:e+" (char "+t+")":e+" (line "+n+", char "+t+")"}function B(e){return new SyntaxError(L(e))}function _(e){return new TypeError(L(e))}function P(e){return new Error(L(e))}var F=e("../../util/index"),k=F.number.toNumber,G=F.string.isString,D=Array.isArray,H=e("bignumber.js"),V=e("./../../type/Complex"),W=e("./../../type/Matrix"),Y=e("./../../type/Unit"),Q=e("../../type/collection"),Z=e("./../../expression/Scope"),K=e("../../expression/node/AssignmentNode"),$=e("../../expression/node/BlockNode"),X=e("../../expression/node/ConstantNode"),J=e("../../expression/node/FunctionNode"),en=e("../../expression/node/ArrayNode"),nn=e("../../expression/node/OperatorNode"),tn=e("../../expression/node/ParamsNode"),rn=e("../../expression/node/RangeNode"),on=e("../../expression/node/SymbolNode"),an=e("../../expression/node/UpdateNode"),sn=e("../../expression/node/handlers");n.parse=function(e,t){if(1!=arguments.length&&2!=arguments.length)throw new n.error.ArgumentsError("parse",arguments.length,1,2);var r;if(r=t?t instanceof Z?t:new Z(n,t):new Z(n),G(e))return ln=e||"",f(r);if(D(e)||e instanceof W)return Q.deepMap(e,function(e){return ln=e||"",f(r)});throw new TypeError("String or matrix expected")};var un={NULL:0,DELIMITER:1,NUMBER:2,SYMBOL:3,UNKNOWN:4},cn={",":!0,"(":!0,")":!0,"[":!0,"]":!0,'"':!0,"\n":!0,";":!0,"+":!0,"-":!0,"*":!0,".*":!0,"/":!0,"./":!0,"%":!0,"^":!0,".^":!0,"!":!0,"'":!0,"=":!0,":":!0,"==":!0,"!=":!0,"<":!0,">":!0,"<=":!0,">=":!0},fn={mod:!0,"in":!0},ln="",mn=0,pn="",hn="",gn=un.NULL}},{"../../expression/node/ArrayNode":104,"../../expression/node/AssignmentNode":105,"../../expression/node/BlockNode":106,"../../expression/node/ConstantNode":107,"../../expression/node/FunctionNode":108,"../../expression/node/OperatorNode":110,"../../expression/node/ParamsNode":111,"../../expression/node/RangeNode":112,"../../expression/node/SymbolNode":113,"../../expression/node/UpdateNode":114,"../../expression/node/handlers":115,"../../type/collection":208,"../../util/index":212,"./../../expression/Scope":5,"./../../type/Complex":202,"./../../type/Matrix":205,"./../../type/Unit":207,"bignumber.js":217}],164:[function(e,n){n.exports=function(n){function t(e,n,r,i){if(r>i){if(e.length!=n.length)throw new Error("Dimensions mismatch ("+e.length+" != "+n.length+")");for(var o=[],a=0;a<e.length;a++)o[a]=t(e[a],n[a],r,i+1);return o}return e.concat(n)}var r=e("../../util/index"),i=e("../../type/Matrix"),o=e("../../type/collection"),a=r.object,s=r.array,u=r.number.isNumber,c=r.number.isInteger,f=o.isCollection;n.concat=function(){var e,r,o=arguments.length,l=-1,m=!1,p=[];for(e=0;o>e;e++){var h=arguments[e];if(h instanceof i&&(m=!0),e==o-1&&u(h)){if(r=l,l=h,!c(l)||0>l)throw new TypeError("Dimension number must be a positive integer (dim = "+l+")");if(e>0&&l>r)throw new RangeError("Dimension out of range ("+l+" > "+r+")")}else{if(!f(h))throw new n.error.UnsupportedTypeError("concat",h);var g=a.clone(h).valueOf(),x=s.size(h.valueOf());if(p[e]=g,r=l,l=x.length-1,e>0&&l!=r)throw new RangeError("Dimension mismatch ("+r+" != "+l+")")}}if(0==p.length)throw new SyntaxError("At least one matrix expected");for(var d=p.shift();p.length;)d=t(d,p.shift(),l,0);return m?new i(d):d}}},{"../../type/Matrix":205,"../../type/collection":208,"../../util/index":212}],165:[function(e,n){n.exports=function(n){function t(e,t,r){if(1==t)return e[0][0];if(2==t)return n.subtract(n.multiply(e[0][0],e[1][1]),n.multiply(e[1][0],e[0][1]));for(var o=1,a=0,s=0;t>s&&!(a>=r);s++){for(var u=s;0==e[u][a];)if(u++,u==t&&(u=s,a++,a==r))return i.deepEqual(e,eye(t).valueOf())?n.round(o,6):0;if(u!=s){for(var c=0;r>c;c++){var f=e[u][c];e[u][c]=e[s][c],e[s][c]=f}o*=-1}for(var l=e[s][a],c=0;r>c;c++)e[s][c]=e[s][c]/l;o*=l;for(var m=0;t>m;m++)if(m!=s)for(var p=e[m][a],c=0;r>c;c++)e[m][c]=e[m][c]-e[s][c]*p;a++}return i.deepEqual(e,n.eye(t).valueOf())?n.round(o,6):0}var r=e("../../util/index"),i=(e("../../type/Matrix"),r.object),o=r.array,a=r.string;n.det=function(e){if(1!=arguments.length)throw new n.error.ArgumentsError("det",arguments.length,1);var r=o.size(e.valueOf());switch(r.length){case 0:return i.clone(e);case 1:if(1==r[0])return i.clone(e.valueOf()[0]);throw new RangeError("Matrix must be square (size: "+a.format(r)+")");case 2:var s=r[0],u=r[1];if(s==u)return t(e.valueOf(),s,u);throw new RangeError("Matrix must be square (size: "+a.format(r)+")");default:throw new RangeError("Matrix must be two dimensional (size: "+a.format(r)+")")}}}},{"../../type/Matrix":205,"../../util/index":212}],166:[function(e,n){n.exports=function(n,t){var r=e("../../util/index"),i=e("../../type/Matrix"),o=(e("../../type/collection"),r.object),a=r.array.isArray,s=r.number.isNumber,u=r.number.isInteger;n.diag=function(e,r){var c,f,l,m;if(1!=arguments.length&&2!=arguments.length)throw new n.error.ArgumentsError("diag",arguments.length,1,2);if(r){if(!s(r)||!u(r))throw new TypeError("Second parameter in function diag must be an integer")}else r=0;var p=r>0?r:0,h=0>r?-r:0;if(e instanceof i);else{if(!a(e))throw new TypeError("First parameter in function diag must be a Matrix or Array");e=new i(e)}var g=e.size();switch(g.length){case 1:f=e.valueOf();var x=new i,d=0;for(x.resize([f.length+h,f.length+p],d),c=x.valueOf(),m=f.length,l=0;m>l;l++)c[l+h][l+p]=o.clone(f[l]);return"array"===t.matrix.defaultType?x.valueOf():x;case 2:for(f=[],c=e.valueOf(),m=Math.min(g[0]-h,g[1]-p),l=0;m>l;l++)f[l]=o.clone(c[l+h][l+p]);return"array"===t.matrix.defaultType?f:new i(f);default:throw new RangeError("Matrix for function diag must be 2 dimensional")}}}},{"../../type/Matrix":205,"../../type/collection":208,"../../util/index":212}],167:[function(e,n){n.exports=function(n,t){var r=e("../../util/index"),i=e("bignumber.js"),o=e("../../type/Matrix"),a=e("../../type/collection"),s=r.number.toNumber,u=r.number.isNumber,c=r.number.isInteger,f=Array.isArray;n.eye=function(e){var r=a.argsToArray(arguments),l=e instanceof o?!0:f(e)?!1:"matrix"===t.matrix.defaultType;if(0==r.length)return l?new o:[];if(1==r.length)r[1]=r[0];else if(r.length>2)throw new n.error.ArgumentsError("eye",r.length,0,2);var m=r[0]instanceof i,p=r[0],h=r[1];if(p instanceof i&&(p=s(p)),h instanceof i&&(h=s(h)),!u(p)||!c(p)||1>p)throw new Error("Parameters in function eye must be positive integers");if(h&&(!u(h)||!c(h)||1>h))throw new Error("Parameters in function eye must be positive integers");var g=new o,x=m?new i(1):1,d=m?new i(0):0;g.resize(r.map(s),d);for(var y=n.min(r),b=g.valueOf(),v=0;y>v;v++)b[v][v]=x;return l?g:g.valueOf()}}},{"../../type/Matrix":205,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],168:[function(e,n){n.exports=function(n){function t(e,t,r){var i,o,a,s,u;if(1==t){if(s=e[0][0],0==s)throw Error("Cannot calculate inverse, determinant is zero");return[[n.divide(1,s)]]}if(2==t){var c=n.det(e);if(0==c)throw Error("Cannot calculate inverse, determinant is zero");return[[n.divide(e[1][1],c),n.divide(n.unary(e[0][1]),c)],[n.divide(n.unary(e[1][0]),c),n.divide(e[0][0],c)]]}var f=e.concat();for(i=0;t>i;i++)f[i]=f[i].concat();for(var l=n.eye(t).valueOf(),m=0;r>m;m++){for(i=m;t>i&&0==f[i][m];)i++;if(i==t||0==f[i][m])throw Error("Cannot calculate inverse, determinant is zero");i!=m&&(u=f[m],f[m]=f[i],f[i]=u,u=l[m],l[m]=l[i],l[i]=u);
+var p=f[m],h=l[m];for(i=0;t>i;i++){var g=f[i],x=l[i];if(i!=m){if(0!=g[m]){for(a=n.divide(n.unary(g[m]),p[m]),o=m;r>o;o++)g[o]=n.add(g[o],n.multiply(a,p[o]));for(o=0;r>o;o++)x[o]=n.add(x[o],n.multiply(a,h[o]))}}else{for(a=p[m],o=m;r>o;o++)g[o]=n.divide(g[o],a);for(o=0;r>o;o++)x[o]=n.divide(x[o],a)}}}return l}{var r=e("../../util/string"),i=e("../../type/Matrix");e("../../type/collection")}n.inv=function(e){if(1!=arguments.length)throw new n.error.ArgumentsError("inv",arguments.length,1);var o=n.size(e).valueOf();switch(o.length){case 0:return n.divide(1,e);case 1:if(1==o[0])return e instanceof i?new i([n.divide(1,e.valueOf()[0])]):[n.divide(1,e[0])];throw new RangeError("Matrix must be square (size: "+r.format(o)+")");case 2:var a=o[0],s=o[1];if(a==s)return e instanceof i?new i(t(e.valueOf(),a,s)):t(e,a,s);throw new RangeError("Matrix must be square (size: "+r.format(o)+")");default:throw new RangeError("Matrix must be two dimensional (size: "+r.format(o)+")")}}}},{"../../type/Matrix":205,"../../type/collection":208,"../../util/string":215}],169:[function(e,n){n.exports=function(n,t){var r=e("../../util/index"),i=e("bignumber.js"),o=e("../../type/Matrix"),a=e("../../type/collection"),s=r.array,u=r.number.toNumber,c=Array.isArray;n.ones=function(e){var n=a.argsToArray(arguments),r=e instanceof o?!0:c(e)?!1:"matrix"===t.matrix.defaultType;if(0==n.length)return r?new o:[];var f=[],l=n[0]instanceof i?new i(1):1;return f=s.resize(f,n.map(u),l),r?new o(f):f}}},{"../../type/Matrix":205,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],170:[function(e,n){n.exports=function(n,t){function r(e,n,t){var r=[],i=e;if(t>0)for(;n>i;)r.push(i),i+=t;else if(0>t)for(;i>n;)r.push(i),i+=t;return r}function i(e,n,t){var r=[],i=e.clone(),o=new s(0);if(t.gt(o))for(;i.lt(n);)r.push(i),i=i.plus(t);else if(t.lt(o))for(;i.gt(n);)r.push(i),i=i.plus(t);return r}function o(e){var n=e.split(":"),r=null;if("bignumber"===t.number.defaultType)try{r=n.map(function(e){return new s(e)})}catch(i){return null}else{r=n.map(function(e){return parseFloat(e)});var o=r.some(function(e){return isNaN(e)});if(o)return null}switch(r.length){case 2:return{start:r[0],end:r[1],step:1};case 3:return{start:r[0],end:r[2],step:r[1]};default:return null}}var a=e("../../util/index"),s=e("bignumber.js"),u=e("../../type/Matrix"),c=(e("../../type/collection"),a.string.isString),f=a.number.isNumber,l=a.number.toNumber,m=a.number.toBigNumber;n.range=function(e){var a,p,h;switch(arguments.length){case 1:if(!c(e))throw new TypeError("Two or three numbers or a single string expected in function range");var g=o(e);if(!g)throw new SyntaxError('String "'+g+'" is no valid range');a=g.start,p=g.end,h=g.step;break;case 2:a=arguments[0],p=arguments[1],h=1;break;case 3:a=arguments[0],p=arguments[1],h=arguments[2];break;default:throw new n.error.ArgumentsError("range",arguments.length,2,3)}if(!(f(a)||a instanceof s))throw new TypeError("Parameter start must be a number");if(!(f(p)||p instanceof s))throw new TypeError("Parameter end must be a number");if(!(f(h)||h instanceof s))throw new TypeError("Parameter step must be a number");if(a instanceof s||p instanceof s||h instanceof s){var x=!0;a instanceof s||(a=m(a)),p instanceof s||(p=m(p)),h instanceof s||(h=m(h)),a instanceof s&&p instanceof s&&h instanceof s||(x=!1,a=l(a),p=l(p),h=l(h))}var d=x?i(a,p,h):r(a,p,h);return"array"===t.matrix.defaultType?d:new u(d)}}},{"../../type/Matrix":205,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],171:[function(e,n){n.exports=function(n,t){function r(e,n,t){if(void 0!==t){if(!c(t)||1!==t.length)throw new TypeError("Single character expected as defaultValue")}else t=" ";if(1!==n.length)throw new Error("Dimension mismatch: ("+n.length+" != 1)");var r=n[0];if(!l(r)||!m(r))throw new TypeError("Size must contain numbers");if(e.length>r)return e.substring(0,r);if(e.length<r){for(var i=e,o=0,a=r-e.length;a>o;o++)i+=t;return i}return e}var i=e("../../util/index"),o=e("bignumber.js"),a=e("../../type/Matrix"),s=i.array,u=i.object.clone,c=i.string.isString,f=i.number.toNumber,l=i.number.isNumber,m=i.number.isInteger,p=s.isArray;n.resize=function(e,i,l){if(2!=arguments.length&&3!=arguments.length)throw new n.error.ArgumentsError("resize",arguments.length,2,3);var m=e instanceof a?!0:p(e)?!1:"array"!==t.matrix.defaultType;if(e instanceof a&&(e=e.valueOf()),i instanceof a&&(i=i.valueOf()),i.length&&i[0]instanceof o&&(i=i.map(f)),c(e))return r(e,i,l);if(0==i.length){for(;p(e);)e=e[0];return u(e)}p(e)||(e=[e]),e=u(e);var h=s.resize(e,i,l);return m?new a(h):h}}},{"../../type/Matrix":205,"../../util/index":212,"bignumber.js":217}],172:[function(e,n){n.exports=function(n,t){var r=e("../../util/index"),i=e("bignumber.js"),o=e("../../type/Complex"),a=e("../../type/Unit"),s=e("../../type/Matrix"),u=r.array,c=r.number.isNumber,f=r.boolean.isBoolean,l=r.string.isString,m=o.isComplex,p=a.isUnit;n.size=function(e){if(1!=arguments.length)throw new n.error.ArgumentsError("size",arguments.length,1);var r="array"===t.matrix.defaultType;if(c(e)||m(e)||p(e)||f(e)||null==e||e instanceof i)return r?[]:new s([]);if(l(e))return r?[e.length]:new s([e.length]);if(Array.isArray(e))return u.size(e);if(e instanceof s)return new s(e.size());throw new n.error.UnsupportedTypeError("size",e)}}},{"../../type/Complex":202,"../../type/Matrix":205,"../../type/Unit":207,"../../util/index":212,"bignumber.js":217}],173:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("../../type/Matrix"),i=t.object,o=t.array,a=Array.isArray;n.squeeze=function(e){if(1!=arguments.length)throw new n.error.ArgumentsError("squeeze",arguments.length,1);if(a(e))return o.squeeze(i.clone(e));if(e instanceof r){var t=o.squeeze(e.toArray());return a(t)?new r(t):t}return i.clone(e)}}},{"../../type/Matrix":205,"../../util/index":212}],174:[function(e,n){n.exports=function(n){function t(e,t){var i,o;if(l(e))return i=new s(e),o=i.subset(t),o.valueOf();if(e instanceof s)return e.subset(t);if(f(e))return r(e,t);throw new n.error.UnsupportedTypeError("subset",e)}function r(e,n){if(!(n instanceof u))throw new TypeError("Index expected");if(1!=n.size().length)throw new RangeError("Dimension mismatch ("+n.size().length+" != 1)");var t=n.range(0),r="",i=e.length;return t.forEach(function(n){c.validateIndex(n,i),r+=e.charAt(n)}),r}function i(e,t,r,i){var a;if(l(e))return a=new s(n.clone(e)),a.subset(t,r,i),a.valueOf();if(e instanceof s)return e.clone().subset(t,r,i);if(f(e))return o(e,t,r,i);throw new n.error.UnsupportedTypeError("subset",e)}function o(e,n,t,r){if(!(n instanceof u))throw new TypeError("Index expected");if(1!=n.size().length)throw new RangeError("Dimension mismatch ("+n.size().length+" != 1)");if(void 0!==r){if(!f(r)||1!==r.length)throw new TypeError("Single character expected as defaultValue")}else r=" ";var i=n.range(0),o=i.size()[0];if(o!=t.length)throw new RangeError("Dimension mismatch ("+i.size()[0]+" != "+t.length+")");for(var a=e.length,s=[],l=0;a>l;l++)s[l]=e.charAt(l);if(i.forEach(function(e,n){c.validateIndex(e),s[e]=t.charAt(n)}),s.length>a)for(l=a-1,o=s.length;o>l;l++)s[l]||(s[l]=r);return s.join("")}var a=e("../../util/index"),s=e("../../type/Matrix"),u=e("../../type/Index"),c=a.array,f=a.string.isString,l=Array.isArray;n.subset=function(){switch(arguments.length){case 2:return t(arguments[0],arguments[1]);case 3:case 4:return i(arguments[0],arguments[1],arguments[2],arguments[3]);default:throw new n.error.ArgumentsError("subset",arguments.length,2,4)}}}},{"../../type/Index":204,"../../type/Matrix":205,"../../util/index":212}],175:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("../../type/Matrix"),i=(e("../../type/collection"),t.object),o=t.string;n.transpose=function(e){if(1!=arguments.length)throw new n.error.ArgumentsError("transpose",arguments.length,1);var t=n.size(e).valueOf();switch(t.length){case 0:return i.clone(e);case 1:return i.clone(e);case 2:var a,s=t[1],u=t[0],c=e instanceof r,f=e.valueOf(),l=[],m=i.clone;if(0===s)throw new RangeError("Cannot transpose a 2D matrix with no rows(size: "+o.format(t)+")");for(var p=0;s>p;p++){a=l[p]=[];for(var h=0;u>h;h++)a[h]=m(f[h][p])}return 0==u&&(l[0]=[]),c?new r(l):l;default:throw new RangeError("Matrix must be two dimensional (size: "+o.format(t)+")")}}}},{"../../type/Matrix":205,"../../type/collection":208,"../../util/index":212}],176:[function(e,n){n.exports=function(n,t){var r=e("../../util/index"),i=e("bignumber.js"),o=e("../../type/Matrix"),a=e("../../type/collection"),s=r.array,u=r.number.toNumber,c=Array.isArray;n.zeros=function(e){var n=a.argsToArray(arguments),r=e instanceof o?!0:c(e)?!1:"matrix"===t.matrix.defaultType;if(0==n.length)return r?new o:[];var f=[],l=n[0]instanceof i?new i(0):0;return f=s.resize(f,n.map(u),l),r?new o(f):f}}},{"../../type/Matrix":205,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],177:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/collection"),o=t.number.isNumber,a=t.boolean.isBoolean,s=t.number.isInteger,u=i.isCollection;n.factorial=function c(e){var t,f;if(1!=arguments.length)throw new n.error.ArgumentsError("factorial",arguments.length,1);if(o(e)){if(!s(e)||0>e)throw new TypeError("Positive integer value expected in function factorial");for(t=e-1,f=e;t>1;)f*=t,t--;return 0==f&&(f=1),f}if(e instanceof r){if(!e.round().equals(e)||e.lt(0))throw new TypeError("Positive integer value expected in function factorial");var l=new r(1);for(t=e.minus(l),f=e;t.gt(l);)f=f.times(t),t=t.minus(l);return f.equals(0)&&(f=l),f}if(a(e))return 1;if(u(e))return i.deepMap(e,c);throw new n.error.UnsupportedTypeError("factorial",e)}}},{"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],178:[function(e,n){n.exports=function(n,t){var r=e("../../type/Matrix"),i=(e("../../type/collection"),{uniform:function(){return Math.random},normal:function(){return function(){for(var e,n,t=-1;0>t||t>1;)e=Math.random(),n=Math.random(),t=1/6*Math.pow(-2*Math.log(e),.5)*Math.cos(2*Math.PI*n)+.5;return t}}});n.distribution=function(e){if(!i.hasOwnProperty(e))throw new Error("unknown distribution "+e);var o=Array.prototype.slice.call(arguments,1),a=i[e].apply(this,o);return function(e){var i={random:function(e,i,a){var u,c,f;if(arguments.length>3)throw new n.error.ArgumentsError("random",arguments.length,0,3);if(1===arguments.length?Array.isArray(e)?u=e:f=e:2===arguments.length?Array.isArray(e)?u=e:(c=e,f=i):(u=e,c=i,f=a),void 0===f&&(f=1),void 0===c&&(c=0),void 0!==u){var l=s(u,c,f,o);return"array"===t.matrix.defaultType?l:new r(l)}return o(c,f)},randomInt:function(e,i,o){var u,c,f;if(arguments.length>3||arguments.length<1)throw new n.error.ArgumentsError("randomInt",arguments.length,1,3);if(1===arguments.length?f=e:2===arguments.length?"[object Array]"===Object.prototype.toString.call(e)?u=e:(c=e,f=i):(u=e,c=i,f=o),void 0===c&&(c=0),void 0!==u){var l=s(u,c,f,a);return"array"===t.matrix.defaultType?l:new r(l)}return a(c,f)},pickRandom:function(e){if(1!==arguments.length)throw new n.error.ArgumentsError("pickRandom",arguments.length,1);if(!Array.isArray(e))throw new n.error.UnsupportedTypeError("pickRandom",e);return e[Math.floor(Math.random()*e.length)]}},o=function(n,t){return n+e()*(t-n)},a=function(n,t){return Math.floor(n+e()*(t-n))},s=function(e,n,t,r){var i,o,a=[];if(e=e.slice(0),e.length>1)for(o=0,i=e.shift();i>o;o++)a.push(s(e,n,t,r));else for(o=0,i=e.shift();i>o;o++)a.push(r(n,t));return a};return i}(a)};var o=n.distribution("uniform");n.random=o.random,n.randomInt=o.randomInt,n.pickRandom=o.pickRandom}},{"../../type/Matrix":205,"../../type/collection":208}],179:[function(e,n){n.exports=function(n){function t(e,t){return n.larger(e,t)?e:t}function r(e){var t=null;if(i.deepForEach(e,function(e){(null===t||n.larger(e,t))&&(t=e)}),null===t)throw new Error("Cannot calculate max of an empty array");return t}var i=(e("../../type/Matrix"),e("../../type/collection")),o=i.isCollection;n.max=function(e){if(0==arguments.length)throw new SyntaxError("Function max requires one or more parameters (0 provided)");if(o(e)){if(1==arguments.length)return r(e);if(2==arguments.length)return i.reduce(arguments[0],arguments[1],t);throw new SyntaxError("Wrong number of parameters")}return r(arguments)}}},{"../../type/Matrix":205,"../../type/collection":208}],180:[function(e,n){n.exports=function(n){function t(e,t){var r;return r=i.reduce(e,t,n.add),n.divide(r,size(e)[t])}function r(e){var t=0,r=0;if(i.deepForEach(e,function(e){t=n.add(t,e),r++}),0===r)throw new Error("Cannot calculate mean of an empty array");return n.divide(t,r)}var i=(e("../../type/Matrix"),e("../../type/collection")),o=i.isCollection;n.mean=function(e){if(0==arguments.length)throw new SyntaxError("Function mean requires one or more parameters (0 provided)");if(o(e)){if(1==arguments.length)return r(e);if(2==arguments.length)return t(arguments[0],arguments[1]);throw new SyntaxError("Wrong number of parameters")}return r(arguments)}}},{"../../type/Matrix":205,"../../type/collection":208}],181:[function(e,n){n.exports=function(n){function t(e,t){return n.smaller(e,t)?e:t}function r(e){var t=null;if(i.deepForEach(e,function(e){(null===t||n.smaller(e,t))&&(t=e)}),null===t)throw new Error("Cannot calculate min of an empty array");return t}var i=(e("../../type/Matrix"),e("../../type/collection")),o=i.isCollection;n.min=function(e){if(0==arguments.length)throw new SyntaxError("Function min requires one or more parameters (0 provided)");if(o(e)){if(1==arguments.length)return r(e);if(2==arguments.length)return i.reduce(arguments[0],arguments[1],t);throw new SyntaxError("Wrong number of parameters")}return r(arguments)}}},{"../../type/Matrix":205,"../../type/collection":208}],182:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/collection"),a=t.number.isNumber,s=t.boolean.isBoolean,u=i.isComplex,c=o.isCollection;n.acos=function f(e){if(1!=arguments.length)throw new n.error.ArgumentsError("acos",arguments.length,1);if(a(e))return e>=-1&&1>=e?Math.acos(e):f(new i(e,0));if(u(e)){var l,m=new i(e.im*e.im-e.re*e.re+1,-2*e.re*e.im),p=n.sqrt(m);l=p instanceof i?new i(p.re-e.im,p.im+e.re):new i(p-e.im,e.re);var h=n.log(l);return h instanceof i?new i(1.5707963267948966-h.im,h.re):new i(1.5707963267948966,h)}if(c(e))return o.deepMap(e,f);if(s(e))return Math.acos(e);if(e instanceof r)return f(t.number.toNumber(e));throw new n.error.UnsupportedTypeError("acos",e)}}},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],183:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/collection"),a=t.number.isNumber,s=t.boolean.isBoolean,u=i.isComplex,c=o.isCollection;n.asin=function f(e){if(1!=arguments.length)throw new n.error.ArgumentsError("asin",arguments.length,1);if(a(e))return e>=-1&&1>=e?Math.asin(e):f(new i(e,0));if(u(e)){var l,m=e.re,p=e.im,h=new i(p*p-m*m+1,-2*m*p),g=n.sqrt(h);l=g instanceof i?new i(g.re-p,g.im+m):new i(g-p,m);var x=n.log(l);return x instanceof i?new i(x.im,-x.re):new i(0,-x)}if(c(e))return o.deepMap(e,f);if(s(e))return Math.asin(e);if(e instanceof r)return f(t.number.toNumber(e));throw new n.error.UnsupportedTypeError("asin",e)}}},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],184:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/collection"),a=t.number.isNumber,s=t.boolean.isBoolean,u=i.isComplex,c=o.isCollection;n.atan=function f(e){if(1!=arguments.length)throw new n.error.ArgumentsError("atan",arguments.length,1);if(a(e))return Math.atan(e);if(u(e)){var l=e.re,m=e.im,p=l*l+(1-m)*(1-m),h=new i((1-m*m-l*l)/p,-2*l/p),g=n.log(h);return g instanceof i?new i(-.5*g.im,.5*g.re):new i(0,.5*g)}if(c(e))return o.deepMap(e,f);if(s(e))return Math.atan(e);if(e instanceof r)return f(t.number.toNumber(e));throw new n.error.UnsupportedTypeError("atan",e)}}},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],185:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/collection"),a=t.number.toNumber,s=t.number.isNumber,u=t.boolean.isBoolean,c=i.isComplex,f=o.isCollection;n.atan2=function l(e,t){if(2!=arguments.length)throw new n.error.ArgumentsError("atan2",arguments.length,2);if(s(e)){if(s(t))return Math.atan2(e,t)}else if(c(e)&&s(t))return Math.atan2(e.re,t);if(f(e)||f(t))return o.deepMap2(e,t,l);if(u(e))return l(+e,t);if(u(t))return l(e,+t);if(e instanceof r)return l(a(e),t);if(t instanceof r)return l(e,a(t));throw new n.error.UnsupportedTypeError("atan2",e,t)}}},{"../../type/Complex":202,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],186:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/Unit"),a=e("../../type/collection"),s=t.number.isNumber,u=t.boolean.isBoolean,c=i.isComplex,f=o.isUnit,l=a.isCollection;n.cos=function m(e){if(1!=arguments.length)throw new n.error.ArgumentsError("cos",arguments.length,1);if(s(e))return Math.cos(e);if(c(e))return new i(.5*Math.cos(e.re)*(Math.exp(-e.im)+Math.exp(e.im)),.5*Math.sin(e.re)*(Math.exp(-e.im)-Math.exp(e.im)));if(f(e)){if(!e.hasBase(o.BASE_UNITS.ANGLE))throw new TypeError("Unit in function cos is no angle");return Math.cos(e.value)}if(l(e))return a.deepMap(e,m);if(u(e))return Math.cos(e);if(e instanceof r)return m(t.number.toNumber(e));throw new n.error.UnsupportedTypeError("cos",e)}}},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],187:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/Unit"),a=e("../../type/collection"),s=t.number.isNumber,u=t.boolean.isBoolean,c=i.isComplex,f=o.isUnit,l=a.isCollection;n.cot=function m(e){if(1!=arguments.length)throw new n.error.ArgumentsError("cot",arguments.length,1);if(s(e))return 1/Math.tan(e);if(c(e)){var p=Math.exp(-4*e.im)-2*Math.exp(-2*e.im)*Math.cos(2*e.re)+1;return new i(2*Math.exp(-2*e.im)*Math.sin(2*e.re)/p,(Math.exp(-4*e.im)-1)/p)}if(f(e)){if(!e.hasBase(o.BASE_UNITS.ANGLE))throw new TypeError("Unit in function cot is no angle");return 1/Math.tan(e.value)}if(l(e))return a.deepMap(e,m);if(u(e))return m(+e);if(e instanceof r)return m(t.number.toNumber(e));throw new n.error.UnsupportedTypeError("cot",e)}}},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],188:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/Unit"),a=e("../../type/collection"),s=t.number.isNumber,u=t.boolean.isBoolean,c=i.isComplex,f=o.isUnit,l=a.isCollection;n.csc=function m(e){if(1!=arguments.length)throw new n.error.ArgumentsError("csc",arguments.length,1);if(s(e))return 1/Math.sin(e);if(c(e)){var p=.25*(Math.exp(-2*e.im)+Math.exp(2*e.im))-.5*Math.cos(2*e.re);return new i(.5*Math.sin(e.re)*(Math.exp(-e.im)+Math.exp(e.im))/p,.5*Math.cos(e.re)*(Math.exp(-e.im)-Math.exp(e.im))/p)}if(f(e)){if(!e.hasBase(o.BASE_UNITS.ANGLE))throw new TypeError("Unit in function csc is no angle");return 1/Math.sin(e.value)}if(l(e))return a.deepMap(e,m);if(u(e))return m(+e);if(e instanceof r)return m(t.number.toNumber(e));throw new n.error.UnsupportedTypeError("csc",e)}}},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],189:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/Unit"),a=e("../../type/collection"),s=t.number.isNumber,u=t.boolean.isBoolean,c=i.isComplex,f=o.isUnit,l=a.isCollection;n.sec=function m(e){if(1!=arguments.length)throw new n.error.ArgumentsError("sec",arguments.length,1);if(s(e))return 1/Math.cos(e);if(c(e)){var p=.25*(Math.exp(-2*e.im)+Math.exp(2*e.im))+.5*Math.cos(2*e.re);return new i(.5*Math.cos(e.re)*(Math.exp(-e.im)+Math.exp(e.im))/p,.5*Math.sin(e.re)*(Math.exp(e.im)-Math.exp(-e.im))/p)}if(f(e)){if(!e.hasBase(o.BASE_UNITS.ANGLE))throw new TypeError("Unit in function sec is no angle");return 1/Math.cos(e.value)}if(l(e))return a.deepMap(e,m);if(u(e))return m(+e);if(e instanceof r)return m(t.number.toNumber(e));throw new n.error.UnsupportedTypeError("sec",e)}}},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],190:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/Unit"),a=e("../../type/collection"),s=t.number.isNumber,u=t.boolean.isBoolean,c=i.isComplex,f=o.isUnit,l=a.isCollection;n.sin=function m(e){if(1!=arguments.length)throw new n.error.ArgumentsError("sin",arguments.length,1);if(s(e))return Math.sin(e);if(c(e))return new i(.5*Math.sin(e.re)*(Math.exp(-e.im)+Math.exp(e.im)),.5*Math.cos(e.re)*(Math.exp(e.im)-Math.exp(-e.im)));if(f(e)){if(!e.hasBase(o.BASE_UNITS.ANGLE))throw new TypeError("Unit in function sin is no angle");return Math.sin(e.value)}if(l(e))return a.deepMap(e,m);if(u(e))return Math.sin(e);if(e instanceof r)return m(t.number.toNumber(e));throw new n.error.UnsupportedTypeError("sin",e)}}},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],191:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/Unit"),a=e("../../type/collection"),s=t.number.isNumber,u=t.boolean.isBoolean,c=i.isComplex,f=o.isUnit,l=a.isCollection;n.tan=function m(e){if(1!=arguments.length)throw new n.error.ArgumentsError("tan",arguments.length,1);if(s(e))return Math.tan(e);if(c(e)){var p=Math.exp(-4*e.im)+2*Math.exp(-2*e.im)*Math.cos(2*e.re)+1;return new i(2*Math.exp(-2*e.im)*Math.sin(2*e.re)/p,(1-Math.exp(-4*e.im))/p)}if(f(e)){if(!e.hasBase(o.BASE_UNITS.ANGLE))throw new TypeError("Unit in function tan is no angle");return Math.tan(e.value)}if(l(e))return a.deepMap(e,m);if(u(e))return Math.tan(e);if(e instanceof r)return m(t.number.toNumber(e));throw new n.error.UnsupportedTypeError("tan",e)}}},{"../../type/Complex":202,"../../type/Unit":207,"../../type/collection":208,"../../util/index":212,"bignumber.js":217}],192:[function(e,n){n.exports=function(n){var t=e("../../util/index"),r=e("../../type/Unit"),i=e("../../type/collection"),o=t.string.isString,a=r.isUnit,s=i.isCollection;n["in"]=function u(e,t){if(2!=arguments.length)throw new n.error.ArgumentsError("in",arguments.length,2);if(a(e)&&(a(t)||o(t)))return e["in"](t);if(s(e)||s(t))return i.deepMap2(e,t,u);throw new n.error.UnsupportedTypeError("in",e,t)}}},{"../../type/Unit":207,"../../type/collection":208,"../../util/index":212}],193:[function(e,n){n.exports=function(n){var t=e("../../util/object");n.clone=function(e){if(1!=arguments.length)throw new n.error.ArgumentsError("clone",arguments.length,1);return t.clone(e)}}},{"../../util/object":214}],194:[function(e,n){n.exports=function(n){function t(e,n){var t=[],r=function(i,o){Array.isArray(i)?i.forEach(function(e,n){t[o]=n,r(e,o+1)}):n(i,t,e)};r(e,0)}var r=e("../../type/Matrix").isMatrix;n.forEach=function(e,i){if(2!=arguments.length)throw new n.error.ArgumentsError("forEach",arguments.length,2);if(Array.isArray(e))return t(e,i);if(r(e))return e.forEach(i);throw new n.error.UnsupportedTypeError("forEach",e)}}},{"../../type/Matrix":205}],195:[function(e,n){n.exports=function(n){var t=e("../../util/string");n.format=function(e,r){var i=arguments.length;if(1!==i&&2!==i)throw new n.error.ArgumentsError("format",i,1,2);return t.format(e,r)}}},{"../../util/string":215}],196:[function(e,n){n.exports=function(n){function t(e,t,r){(r.override||void 0===n[e])&&(n[e]=r.wrap&&"function"==typeof t?function(){for(var e=[],r=0,i=arguments.length;i>r;r++)e[r]=arguments[r].valueOf();return t.apply(n,e)}:t,n.chaining.Selector.createProxy(e,t))}function r(e){return"function"==typeof e||s(e)||u(e)||c(e)||f(e)}var i=e("../../util/index"),o=e("../../type/Complex"),a=e("../../type/Unit"),s=i.number.isNumber,u=i.string.isString,c=o.isComplex,f=a.isUnit;n["import"]=function l(o,a){var s,c={override:!1,wrap:!0};if(a&&a instanceof Object&&i.object.extend(c,a),u(o)){if("undefined"==typeof e)throw new Error("Cannot load file: require not available.");var f=e(o);l(f)}else if(r(o)){if(s=o.name,!s)throw new Error("Cannot import an unnamed function or object");(c.override||void 0===n[s])&&t(s,o,c)}else if(o instanceof Object)for(s in o)if(o.hasOwnProperty(s)){var m=o[s];r(m)?t(s,m,c):l(m)}}}},{"../../type/Complex":202,"../../type/Unit":207,"../../util/index":212}],197:[function(e,n){n.exports=function(n){function t(e,n){var t=[],r=function(i,o){return Array.isArray(i)?i.map(function(e,n){return t[o]=n,r(e,o+1)}):n(i,t,e)};return r(e,0)}var r=e("../../type/Matrix").isMatrix;n.map=function(e,i){if(2!=arguments.length)throw new n.error.ArgumentsError("map",arguments.length,2);if(Array.isArray(e))return t(e,i);if(r(e))return e.map(i);throw new n.error.UnsupportedTypeError("map",e)}}},{"../../type/Matrix":205}],198:[function(e,n){n.exports=function(n){var t=e("../../util/string"),r=t.isString;n.print=function(e,t,i){var o=arguments.length;if(2!=o&&3!=o)throw new n.error.ArgumentsError("print",o,2,3);if(!r(e))throw new TypeError("String expected as first parameter in function format");if(!(t instanceof Object))throw new TypeError("Object expected as second parameter in function format");return e.replace(/\$([\w\.]+)/g,function(e,o){for(var a=o.split("."),s=t[a.shift()];a.length&&void 0!==s;){var u=a.shift();s=u?s[u]:s+"."}return void 0!==s?r(s)?s:n.format(s,i):e})}}},{"../../util/string":215}],199:[function(e,n){n.exports=function(e){e.select=function(n){return new e.chaining.Selector(n)}}},{}],200:[function(e,n){n.exports=function(n){var t=e("../../util/types"),r=e("bignumber.js"),i=e("../../type/Complex"),o=e("../../type/Matrix"),a=e("../../type/Unit"),s=e("../../type/Index"),u=e("../../type/Range"),c=e("../../type/Help");n["typeof"]=function(e){if(1!=arguments.length)throw new n.error.ArgumentsError("typeof",arguments.length,1);var f=t.type(e);if("object"===f){if(e instanceof i)return"complex";if(e instanceof r)return"bignumber";if(e instanceof o)return"matrix";if(e instanceof a)return"unit";if(e instanceof s)return"index";if(e instanceof u)return"range";if(e instanceof c)return"matrix";if(e instanceof n.chaining.Selector)return"selector"}return f}}},{"../../type/Complex":202,"../../type/Help":203,"../../type/Index":204,"../../type/Matrix":205,"../../type/Range":206,"../../type/Unit":207,"../../util/types":216,"bignumber.js":217}],201:[function(e,n){function t(n){var t={},i={matrix:{defaultType:"matrix"},number:{defaultType:"number"}};return t.config=function(n){var t=e("bignumber.js");if(n&&(r.deepExtend(i,n),n.number&&n.number.precision&&t.config({DECIMAL_PLACES:n.number.precision}),n.matrix&&n.matrix.default))throw new Error("setting matrix.default is deprecated. Use matrix.defaultType instead.");var o=r.clone(i);return o.number.precision=t.config().DECIMAL_PLACES,o},t.config(n),t.expression={},t.expression.node=e("./expression/node/index.js"),t.expression.Scope=e("./expression/Scope.js"),t.expression.Parser=e("./expression/Parser.js"),t.expression.docs=e("./expression/docs/index.js"),t.expr={},t.expr.Scope=function(){throw new Error("Moved to math.expression.Scope")},t.expr.Parser=function(){throw new Error("Moved to math.expression.Parser")},t.type={},t.type.BigNumber=e("bignumber.js"),t.type.Complex=e("./type/Complex"),t.type.Range=e("./type/Range"),t.type.Index=e("./type/Index"),t.type.Matrix=e("./type/Matrix"),t.type.Unit=e("./type/Unit"),t.type.Help=e("./type/Help"),t.collection=e("./type/collection"),e("./type/error")(t),e("./function/expression/eval.js")(t,i),e("./function/expression/help.js")(t,i),e("./function/expression/parse.js")(t,i),e("./function/arithmetic/abs.js")(t,i),e("./function/arithmetic/add.js")(t,i),e("./function/arithmetic/add.js")(t,i),e("./function/arithmetic/ceil.js")(t,i),e("./function/arithmetic/cube.js")(t,i),e("./function/arithmetic/divide.js")(t,i),e("./function/arithmetic/edivide.js")(t,i),e("./function/arithmetic/emultiply.js")(t,i),e("./function/arithmetic/epow.js")(t,i),e("./function/arithmetic/equal.js")(t,i),e("./function/arithmetic/exp.js")(t,i),e("./function/arithmetic/fix.js")(t,i),e("./function/arithmetic/floor.js")(t,i),e("./function/arithmetic/gcd.js")(t,i),e("./function/arithmetic/larger.js")(t,i),e("./function/arithmetic/largereq.js")(t,i),e("./function/arithmetic/lcm.js")(t,i),e("./function/arithmetic/log.js")(t,i),e("./function/arithmetic/log10.js")(t,i),e("./function/arithmetic/mod.js")(t,i),e("./function/arithmetic/multiply.js")(t,i),e("./function/arithmetic/pow.js")(t,i),e("./function/arithmetic/round.js")(t,i),e("./function/arithmetic/sign.js")(t,i),e("./function/arithmetic/smaller.js")(t,i),e("./function/arithmetic/smallereq.js")(t,i),e("./function/arithmetic/sqrt.js")(t,i),e("./function/arithmetic/square.js")(t,i),e("./function/arithmetic/subtract.js")(t,i),e("./function/arithmetic/unary.js")(t,i),e("./function/arithmetic/unequal.js")(t,i),e("./function/arithmetic/xgcd.js")(t,i),e("./function/complex/arg.js")(t,i),e("./function/complex/conj.js")(t,i),e("./function/complex/re.js")(t,i),e("./function/complex/im.js")(t,i),e("./function/construction/bignumber")(t,i),e("./function/construction/boolean.js")(t,i),e("./function/construction/complex.js")(t,i),e("./function/construction/index.js")(t,i),e("./function/construction/matrix.js")(t,i),e("./function/construction/number.js")(t,i),e("./function/construction/parser.js")(t,i),e("./function/construction/string.js")(t,i),e("./function/construction/unit.js")(t,i),e("./function/matrix/concat.js")(t,i),e("./function/matrix/det.js")(t,i),e("./function/matrix/diag.js")(t,i),e("./function/matrix/eye.js")(t,i),e("./function/matrix/inv.js")(t,i),e("./function/matrix/ones.js")(t,i),e("./function/matrix/range.js")(t,i),e("./function/matrix/resize.js")(t,i),e("./function/matrix/size.js")(t,i),e("./function/matrix/squeeze.js")(t,i),e("./function/matrix/subset.js")(t,i),e("./function/matrix/transpose.js")(t,i),e("./function/matrix/zeros.js")(t,i),e("./function/probability/factorial.js")(t,i),e("./function/probability/random.js")(t,i),e("./function/statistics/min.js")(t,i),e("./function/statistics/max.js")(t,i),e("./function/statistics/mean.js")(t,i),e("./function/trigonometry/acos.js")(t,i),e("./function/trigonometry/asin.js")(t,i),e("./function/trigonometry/atan.js")(t,i),e("./function/trigonometry/atan2.js")(t,i),e("./function/trigonometry/cos.js")(t,i),e("./function/trigonometry/cot.js")(t,i),e("./function/trigonometry/csc.js")(t,i),e("./function/trigonometry/sec.js")(t,i),e("./function/trigonometry/sin.js")(t,i),e("./function/trigonometry/tan.js")(t,i),e("./function/units/in.js")(t,i),e("./function/utils/clone.js")(t,i),e("./function/utils/format.js")(t,i),e("./function/utils/import.js")(t,i),e("./function/utils/map.js")(t,i),e("./function/utils/print.js")(t,i),e("./function/utils/select.js")(t,i),e("./function/utils/typeof.js")(t,i),e("./function/utils/forEach.js")(t,i),e("./constants.js")(t,i),t.chaining={},t.chaining.Selector=e("./chaining/Selector.js")(t,i),t.expr.Selector=function(){throw new Error("Moved to math.expression.Selector")},t}var r=e("./util/object");n.exports=t;var i=function(){throw new Error('Static function calls are deprecated. Create an instance of math.js:\n	"var math = require(\'mathjs\')();" on node.js, \n	"var math = mathjs();" in the browser.')},o=t();for(var a in o)if(o.hasOwnProperty(a)){var s=o[a];"function"==typeof s?t[a]=i:Object.defineProperty&&Object.defineProperty(t,a,{get:i,set:i,enumerable:!0,configurable:!1})
+}"undefined"!=typeof window&&(window.math=t)},{"./chaining/Selector.js":2,"./constants.js":3,"./expression/Parser.js":4,"./expression/Scope.js":5,"./expression/docs/index.js":103,"./expression/node/index.js":116,"./function/arithmetic/abs.js":117,"./function/arithmetic/add.js":118,"./function/arithmetic/ceil.js":119,"./function/arithmetic/cube.js":120,"./function/arithmetic/divide.js":121,"./function/arithmetic/edivide.js":122,"./function/arithmetic/emultiply.js":123,"./function/arithmetic/epow.js":124,"./function/arithmetic/equal.js":125,"./function/arithmetic/exp.js":126,"./function/arithmetic/fix.js":127,"./function/arithmetic/floor.js":128,"./function/arithmetic/gcd.js":129,"./function/arithmetic/larger.js":130,"./function/arithmetic/largereq.js":131,"./function/arithmetic/lcm.js":132,"./function/arithmetic/log.js":133,"./function/arithmetic/log10.js":134,"./function/arithmetic/mod.js":135,"./function/arithmetic/multiply.js":136,"./function/arithmetic/pow.js":137,"./function/arithmetic/round.js":138,"./function/arithmetic/sign.js":139,"./function/arithmetic/smaller.js":140,"./function/arithmetic/smallereq.js":141,"./function/arithmetic/sqrt.js":142,"./function/arithmetic/square.js":143,"./function/arithmetic/subtract.js":144,"./function/arithmetic/unary.js":145,"./function/arithmetic/unequal.js":146,"./function/arithmetic/xgcd.js":147,"./function/complex/arg.js":148,"./function/complex/conj.js":149,"./function/complex/im.js":150,"./function/complex/re.js":151,"./function/construction/bignumber":152,"./function/construction/boolean.js":153,"./function/construction/complex.js":154,"./function/construction/index.js":155,"./function/construction/matrix.js":156,"./function/construction/number.js":157,"./function/construction/parser.js":158,"./function/construction/string.js":159,"./function/construction/unit.js":160,"./function/expression/eval.js":161,"./function/expression/help.js":162,"./function/expression/parse.js":163,"./function/matrix/concat.js":164,"./function/matrix/det.js":165,"./function/matrix/diag.js":166,"./function/matrix/eye.js":167,"./function/matrix/inv.js":168,"./function/matrix/ones.js":169,"./function/matrix/range.js":170,"./function/matrix/resize.js":171,"./function/matrix/size.js":172,"./function/matrix/squeeze.js":173,"./function/matrix/subset.js":174,"./function/matrix/transpose.js":175,"./function/matrix/zeros.js":176,"./function/probability/factorial.js":177,"./function/probability/random.js":178,"./function/statistics/max.js":179,"./function/statistics/mean.js":180,"./function/statistics/min.js":181,"./function/trigonometry/acos.js":182,"./function/trigonometry/asin.js":183,"./function/trigonometry/atan.js":184,"./function/trigonometry/atan2.js":185,"./function/trigonometry/cos.js":186,"./function/trigonometry/cot.js":187,"./function/trigonometry/csc.js":188,"./function/trigonometry/sec.js":189,"./function/trigonometry/sin.js":190,"./function/trigonometry/tan.js":191,"./function/units/in.js":192,"./function/utils/clone.js":193,"./function/utils/forEach.js":194,"./function/utils/format.js":195,"./function/utils/import.js":196,"./function/utils/map.js":197,"./function/utils/print.js":198,"./function/utils/select.js":199,"./function/utils/typeof.js":200,"./type/Complex":202,"./type/Help":203,"./type/Index":204,"./type/Matrix":205,"./type/Range":206,"./type/Unit":207,"./type/collection":208,"./type/error":209,"./util/object":214,"bignumber.js":217}],202:[function(e,n,t){function r(e,n){if(!(this instanceof r))throw new SyntaxError("Complex constructor must be called with the new operator");switch(arguments.length){case 0:this.re=0,this.im=0;break;case 2:if(!p(e)||!p(n))throw new TypeError("Two numbers expected in Complex constructor");this.re=e,this.im=n;break;default:if(0!=arguments.length&&2!=arguments.length)throw new SyntaxError("Two or zero arguments expected in Complex constructor")}}function i(){for(;" "==d||"	"==d;)s()}function o(e){return e>="0"&&"9">=e||"."==e}function a(e){return e>="0"&&"9">=e}function s(){x++,d=g.charAt(x)}function u(e){x=e,d=g.charAt(x)}function c(){var e,n="";if(e=x,"+"==d?s():"-"==d&&(n+=d,s()),!o(d))return u(e),null;if("."==d){if(n+=d,s(),!a(d))return u(e),null}else{for(;a(d);)n+=d,s();"."==d&&(n+=d,s())}for(;a(d);)n+=d,s();if("E"==d||"e"==d){if(n+=d,s(),("+"==d||"-"==d)&&(n+=d,s()),!a(d))return u(e),null;for(;a(d);)n+=d,s()}return n}function f(){var e=g.charAt(x+1);if("I"==d||"i"==d)return s(),"1";if(!("+"!=d&&"-"!=d||"I"!=e&&"i"!=e)){var n="+"==d?"1":"-1";return s(),s(),n}return null}var l=e("../util/index"),m=l.number,p=l.number.isNumber,h=l.string.isString;r.isComplex=function(e){return e instanceof r};var g,x,d;r.parse=function(e){if(g=e,x=-1,d="",!h(g))return null;s(),i();var n=c();if(n){if("I"==d||"i"==d)return s(),i(),d?null:new r(0,Number(n));i();var t=d;if("+"!=t&&"-"!=t)return i(),d?null:new r(Number(n),0);s(),i();var o=c();if(o){if("I"!=d&&"i"!=d)return null;s()}else if(o=f(),!o)return null;return"-"==t&&(o="-"==o[0]?"+"+o.substring(1):"-"+o),s(),i(),d?null:new r(Number(n),Number(o))}return(n=f())?(i(),d?null:new r(0,Number(n))):null},r.prototype.clone=function(){return new r(this.re,this.im)},r.prototype.equals=function(e){return this.re===e.re&&this.im===e.im},r.prototype.format=function(e){var n="",t=m.format(this.re,e),r=m.format(this.im,e);return n=0==this.im?t:0==this.re?1==this.im?"i":-1==this.im?"-i":r+"i":this.im>0?1==this.im?t+" + i":t+" + "+r+"i":-1==this.im?t+" - i":t+" - "+r.substring(1)+"i"},r.prototype.toString=function(){return this.format()},n.exports=r,t.isComplex=r.isComplex,t.parse=r.parse},{"../util/index":212}],203:[function(e,n,t){function r(e,n){this.math=e,this.doc=n}var i=e("../util/index"),o=i.object,a=i.string;r.isHelp=function(e){return e instanceof r},r.prototype.toString=function(){var e=this.doc||{},n="\n";if(e.name&&(n+="Name: "+e.name+"\n\n"),e.category&&(n+="Category: "+e.category+"\n\n"),e.description&&(n+="Description:\n    "+e.description+"\n\n"),e.syntax&&(n+="Syntax:\n    "+e.syntax.join("\n    ")+"\n\n"),e.examples){var t=this.math.parser();n+="Examples:\n";for(var i=0;i<e.examples.length;i++){var o,s=e.examples[i];try{o=t.eval(s)}catch(u){o=u}n+="    "+s+"\n",!o||o instanceof r||(n+="        "+a.format(o)+"\n")}n+="\n"}return e.seealso&&(n+="See also: "+e.seealso.join(", ")+"\n"),n},r.prototype.toJSON=function(){return o.extend({},this.doc)},n.exports=r,t.isHelp=r.isHelp},{"../util/index":212}],204:[function(e,n,t){function r(){if(!(this instanceof r))throw new SyntaxError("Index constructor must be called with the new operator");this._ranges=[];for(var e=0,n=arguments.length;n>e;e++){var t=arguments[e];if(t instanceof a)this._ranges.push(t);else if(t&&(t=t.valueOf()),f(t))this._ranges.push(i(t));else{if(!u(t))throw new TypeError("Range expected as Array, Number, or String");this._ranges.push(i([t,t+1]))}}}function i(e){for(var n=e.length,t=0;n>t;t++)if(!u(e[t])||!c(e[t]))throw new TypeError("Index parameters must be integer numbers");switch(e.length){case 2:return new a(e[0],e[1]);case 3:return new a(e[0],e[1],e[2]);default:throw new SyntaxError("Wrong number of arguments in Index (2 or 3 expected)")}}{var o=e("../util/index"),a=e("./Range"),s=o.number,u=s.isNumber,c=s.isInteger,f=Array.isArray;o.array.validateIndex}r.prototype.clone=function(){var e=new r;return e._ranges=o.object.clone(this._ranges),e},r.isIndex=function(e){return e instanceof r},r.create=function(e){var n=new r;return r.apply(n,e),n},r.prototype.size=function l(){for(var l=[],e=0,n=this._ranges.length;n>e;e++){var t=this._ranges[e];l[e]=t.size()[0]}return l},r.prototype.max=function(){for(var e=[],n=0,t=this._ranges.length;t>n;n++){var r=this._ranges[n];e[n]=r.max()}return e},r.prototype.min=function(){for(var e=[],n=0,t=this._ranges.length;t>n;n++){var r=this._ranges[n];e[n]=r.min()}return e},r.prototype.forEach=function(e){for(var n=0,t=this._ranges.length;t>n;n++)e(this._ranges[n],n,this)},r.prototype.range=function(e){return this._ranges[e]},r.prototype.isScalar=function(){for(var e=this.size(),n=0,t=e.length;t>n;n++)if(1!==e[n])return!1;return!0},r.prototype.toArray=function(){for(var e=[],n=0,t=this._ranges.length;t>n;n++){var r=this._ranges[n],i=[],o=r.start,a=r.end,s=r.step;if(s>0)for(;a>o;)i.push(o),o+=s;else if(0>s)for(;o>a;)i.push(o),o+=s;e.push(i)}return e},r.prototype.valueOf=r.prototype.toArray,r.prototype.toString=function(){for(var e=[],n=0,t=this._ranges.length;t>n;n++){var r=this._ranges[n],i=s.format(r.start);1!=r.step&&(i+=":"+s.format(r.step)),i+=":"+s.format(r.end),e.push(i)}return"["+e.join(",")+"]"},n.exports=r,t.isIndex=r.isIndex,t.create=r.create},{"../util/index":212,"./Range":206}],205:[function(e,n,t){function r(e){if(!(this instanceof r))throw new SyntaxError("Matrix constructor must be called with the new operator");if(e instanceof r)this._data=e.clone()._data;else if(h(e))this._data=e;else{if(null!=e)throw new TypeError("Unsupported type of data ("+c.types.type(e)+")");this._data=[]}this._size=m.size(this._data)}function i(e,n){if(!(n instanceof f))throw new TypeError("Invalid index");var t=n.isScalar();if(t)return e.get(n.min());var i=n.size();if(i.length!=e._size.length)throw new RangeError("Dimension mismatch ("+i.length+" != "+e._size.length+")");for(var a=new r(o(e._data,n,i.length,0));h(a._data)&&1==a._data.length;)a._data=a._data[0],a._size.shift();return a}function o(e,n,t,r){var i=r==t-1,a=n.range(r);return i?a.map(function(n){return g(n,e.length),e[n]}):a.map(function(i){g(i,e.length);var a=e[i];return o(a,n,t,r+1)})}function a(e,n,t,i){if(!(n instanceof f))throw new TypeError("Invalid index");var o,a=n.size(),c=n.isScalar();if(t instanceof r?(o=t.size(),t=t.valueOf()):o=m.size(t),c){if(0!=o.length)throw new TypeError("Scalar value expected");e.set(n.min(),t,i)}else{if(a.length<e._size.length)throw new RangeError("Dimension mismatch ("+a.length+" < "+e._size.length+")");for(var h=0,g=a.length-o.length;g>h;h++)t=[t],o.unshift(1);if(!p.deepEqual(a,o))throw new RangeError("Dimensions mismatch ("+l.format(a)+" != "+l.format(o)+")");var x=n.max().map(function(e){return e+1});u(e,x,i);var d=a.length,y=0;s(e._data,n,t,d,y)}return e}function s(e,n,t,r,i){var o=i==r-1,a=n.range(i);o?a.forEach(function(n,r){g(n),e[n]=t[r]}):a.forEach(function(o,a){g(o),s(e[o],n,t[a],r,i+1)})}function u(e,n,t){if(!h(n))throw new Error("Array expected");for(var r=p.clone(e._size),i=!1;r.length<n.length;)r.unshift(0),i=!0;for(var o=0,a=n.length;a>o;o++)n[o]>r[o]&&(r[o]=n[o],i=!0);i&&e.resize(r,t)}var c=e("../util/index"),f=e("./Index"),l=(c.number,c.string),m=c.array,p=c.object,h=Array.isArray,g=m.validateIndex;r.isMatrix=function(e){return e instanceof r},r.prototype.subset=function(e,n,t){switch(arguments.length){case 1:return i(this,e);case 2:case 3:return a(this,e,n,t);default:throw new SyntaxError("Wrong number of arguments")}},r.prototype.get=function(e){if(!h(e))throw new Error("Array expected");if(e.length!=this._size.length)throw new RangeError("Dimension mismatch ("+e.length+" != "+this._size.length+")");for(var n=this._data,t=0,r=e.length;r>t;t++){var i=e[t];g(i,n.length),n=n[i]}return p.clone(n)},r.prototype.set=function(e,n,t){var r,i;if(!h(e))throw new Error("Array expected");if(e.length<this._size.length)throw new RangeError("Dimension mismatch ("+e.length+" < "+this._size.length+")");var o=e.map(function(e){return e+1});u(this,o,t);var a=this._data;for(r=0,i=e.length-1;i>r;r++){var s=e[r];g(s,a.length),a=a[s]}return s=e[e.length-1],g(s,a.length),a[s]=n,this},r.prototype.resize=function(e,n){return this._size=p.clone(e),this._data=m.resize(this._data,this._size,n),this},r.prototype.clone=function(){var e=new r;return e._data=p.clone(this._data),e._size=p.clone(this._size),e},r.prototype.size=function(){return this._size},r.prototype.map=function(e){var n=this,t=new r,i=[],o=function(t,r){return h(t)?t.map(function(e,n){return i[r]=n,o(e,r+1)}):e(t,i,n)};return t._data=o(this._data,0),t._size=p.clone(this._size),t},r.prototype.forEach=function(e){var n=this,t=[],r=function(i,o){h(i)?i.forEach(function(e,n){t[o]=n,r(e,o+1)}):e(i,t,n)};r(this._data,0)},r.prototype.toArray=function(){return p.clone(this._data)},r.prototype.valueOf=function(){return this._data},r.prototype.format=function(e){return l.format(this._data,e)},r.prototype.toString=function(){return l.format(this._data)},n.exports=r,t.isMatrix=r.isMatrix},{"../util/index":212,"./Index":204}],206:[function(e,n,t){function r(e,n,t){if(!(this instanceof r))throw new SyntaxError("Range constructor must be called with the new operator");if(null!=e&&!o.isNumber(e))throw new TypeError("Parameter start must be a number");if(null!=n&&!o.isNumber(n))throw new TypeError("Parameter end must be a number");if(null!=t&&!o.isNumber(t))throw new TypeError("Parameter step must be a number");this.start=null!=e?parseFloat(e):0,this.end=null!=n?parseFloat(n):0,this.step=null!=t?parseFloat(t):1}{var i=e("../util/index"),o=i.number,a=i.string;i.array}r.parse=function(e){if(!a.isString(e))return null;var n=e.split(":"),t=n.map(function(e){return parseFloat(e)}),i=t.some(function(e){return isNaN(e)});if(i)return null;switch(t.length){case 2:return new r(t[0],t[1]);case 3:return new r(t[0],t[2],t[1]);default:return null}},r.prototype.clone=function(){return new r(this.start,this.end,this.step)},r.isRange=function(e){return e instanceof r},r.prototype.size=function(){var e=0,n=this.start,t=this.step,r=this.end,i=r-n;return o.sign(t)==o.sign(i)?e=Math.ceil(i/t):0==i&&(e=0),isNaN(e)&&(e=0),[e]},r.prototype.min=function(){var e=this.size()[0];return e>0?this.step>0?this.start:this.start+(e-1)*this.step:void 0},r.prototype.max=function(){var e=this.size()[0];return e>0?this.step>0?this.start+(e-1)*this.step:this.start:void 0},r.prototype.forEach=function(e){var n=this.start,t=this.step,r=this.end,i=0;if(t>0)for(;r>n;)e(n,i,this),n+=t,i++;else if(0>t)for(;n>r;)e(n,i,this),n+=t,i++},r.prototype.map=function(e){var n=[];return this.forEach(function(t,r,i){n[r]=e(t,r,i)}),n},r.prototype.toArray=function(){var e=[];return this.forEach(function(n,t){e[t]=n}),e},r.prototype.valueOf=function(){return this.toArray()},r.prototype.format=function(e){var n=o.format(this.start,e);return 1!=this.step&&(n+=":"+o.format(this.step,e)),n+=":"+o.format(this.end,e)},r.prototype.toString=function(){return this.format()},n.exports=r,t.isRange=r.isRange,t.parse=r.parse},{"../util/index":212}],207:[function(e,n,t){function r(e,n){if(!(this instanceof r))throw new Error("Unit constructor must be called with the new operator");if(null!=e&&!y(e))throw new TypeError("First parameter in Unit constructor must be a number");if(null!=n&&!b(n))throw new TypeError("Second parameter in Unit constructor must be a string");if(null!=n){var t=l(n);if(!t)throw new SyntaxError('String "'+n+'" is no unit');this.unit=t.unit,this.prefix=t.prefix}else this.unit=UNIT_NONE,this.prefix=w;null!=e?(this.value=this._normalize(e),this.fixPrefix=!1):(this.value=null,this.fixPrefix=!0)}function i(){for(;" "==h||"	"==h;)s()}function o(e){return e>="0"&&"9">=e||"."==e}function a(e){return e>="0"&&"9">=e}function s(){p++,h=m.charAt(p)}function u(e){p=e,h=m.charAt(p)}function c(){var e,n="";if(e=p,"+"==h?s():"-"==h&&(n+=h,s()),!o(h))return u(e),null;if("."==h){if(n+=h,s(),!a(h))return u(e),null}else{for(;a(h);)n+=h,s();"."==h&&(n+=h,s())}for(;a(h);)n+=h,s();if("E"==h||"e"==h){if(n+=h,s(),("+"==h||"-"==h)&&(n+=h,s()),!a(h))return u(e),null;for(;a(h);)n+=h,s()}return n}function f(){var e="";for(i();h&&" "!=h&&"	"!=h;)e+=h,s();return e||null}function l(e){for(var n=0,t=N.length;t>n;n++){var r=N[n];if(d.endsWith(e,r.name)){var i=e.length-r.name.length,o=e.substring(0,i),a=r.prefixes[o];if(void 0!==a)return{unit:r,prefix:a}}}return null}var m,p,h,g=e("../util/index"),x=g.number,d=g.string,y=g.number.isNumber,b=g.string.isString;r.parse=function(e){if(m=e,p=-1,h="",!b(m))return null;s(),i();var n,t=c();return t?(n=f(),s(),i(),h?null:t&&n?new r(Number(t),n):null):(n=f(),s(),i(),h?null:new r(null,n))},r.isUnit=function(e){return e instanceof r},r.prototype.clone=function(){var e=new r;for(var n in this)this.hasOwnProperty(n)&&(e[n]=this[n]);return e},r.prototype._normalize=function(e){return(e+this.unit.offset)*this.unit.value*this.prefix.value},r.prototype._unnormalize=function(e,n){return void 0==n?e/this.unit.value/this.prefix.value-this.unit.offset:e/this.unit.value/n-this.unit.offset},r.isPlainUnit=function(e){return null!=l(e)},r.prototype.hasBase=function(e){return void 0===this.unit.base?void 0===e:this.unit.base===e},r.prototype.equalBase=function(e){return this.unit.base===e.unit.base},r.prototype.equals=function(e){return this.equalBase(e)&&this.value==e.value},r.prototype["in"]=function(e){var n;if(b(e)){if(n=new r(null,e),!this.equalBase(n))throw new Error("Units do not match");return n.value=this.value,n}if(e instanceof r){if(!this.equalBase(e))throw new Error("Units do not match");if(null!=e.value)throw new Error("Cannot convert to a unit with a value");if(null==e.unit)throw new Error("Unit expected on the right hand side of function in");return n=e.clone(),n.value=this.value,n.fixPrefix=!0,n}throw new Error("String or Unit expected as parameter")},r.prototype.toNumber=function(e){var n=this["in"](e),t=this.fixPrefix?n._bestPrefix():n.prefix;return n._unnormalize(n.value,t.value)},r.prototype.toString=function(){return this.format()},r.prototype.format=function(e){var n,t;if(this.fixPrefix)n=this._unnormalize(this.value),t=null!=this.value?x.format(n,e)+" ":"",t+=this.prefix.name+this.unit.name;else{var r=this._bestPrefix();n=this._unnormalize(this.value,r.value),t=null!=this.value?x.format(n,e)+" ":"",t+=r.name+this.unit.name}return t},r.prototype._bestPrefix=function(){var e=Math.abs(this.value/this.unit.value),n=w,t=Math.abs(Math.log(e/n.value)/Math.LN10-1.2),r=this.unit.prefixes;for(var i in r)if(r.hasOwnProperty(i)){var o=r[i];if(o.scientific){var a=Math.abs(Math.log(e/o.value)/Math.LN10-1.2);t>a&&(n=o,t=a)}}return n};var v={NONE:{"":{name:"",value:1,scientific:!0}},SHORT:{"":{name:"",value:1,scientific:!0},da:{name:"da",value:10,scientific:!1},h:{name:"h",value:100,scientific:!1},k:{name:"k",value:1e3,scientific:!0},M:{name:"M",value:1e6,scientific:!0},G:{name:"G",value:1e9,scientific:!0},T:{name:"T",value:1e12,scientific:!0},P:{name:"P",value:1e15,scientific:!0},E:{name:"E",value:1e18,scientific:!0},Z:{name:"Z",value:1e21,scientific:!0},Y:{name:"Y",value:1e24,scientific:!0},d:{name:"d",value:.1,scientific:!1},c:{name:"c",value:.01,scientific:!1},m:{name:"m",value:.001,scientific:!0},u:{name:"u",value:1e-6,scientific:!0},n:{name:"n",value:1e-9,scientific:!0},p:{name:"p",value:1e-12,scientific:!0},f:{name:"f",value:1e-15,scientific:!0},a:{name:"a",value:1e-18,scientific:!0},z:{name:"z",value:1e-21,scientific:!0},y:{name:"y",value:1e-24,scientific:!0}},LONG:{"":{name:"",value:1,scientific:!0},deca:{name:"deca",value:10,scientific:!1},hecto:{name:"hecto",value:100,scientific:!1},kilo:{name:"kilo",value:1e3,scientific:!0},mega:{name:"mega",value:1e6,scientific:!0},giga:{name:"giga",value:1e9,scientific:!0},tera:{name:"tera",value:1e12,scientific:!0},peta:{name:"peta",value:1e15,scientific:!0},exa:{name:"exa",value:1e18,scientific:!0},zetta:{name:"zetta",value:1e21,scientific:!0},yotta:{name:"yotta",value:1e24,scientific:!0},deci:{name:"deci",value:.1,scientific:!1},centi:{name:"centi",value:.01,scientific:!1},milli:{name:"milli",value:.001,scientific:!0},micro:{name:"micro",value:1e-6,scientific:!0},nano:{name:"nano",value:1e-9,scientific:!0},pico:{name:"pico",value:1e-12,scientific:!0},femto:{name:"femto",value:1e-15,scientific:!0},atto:{name:"atto",value:1e-18,scientific:!0},zepto:{name:"zepto",value:1e-21,scientific:!0},yocto:{name:"yocto",value:1e-24,scientific:!0}},BINARY_SHORT:{"":{name:"",value:1,scientific:!0},k:{name:"k",value:1024,scientific:!0},M:{name:"M",value:Math.pow(1024,2),scientific:!0},G:{name:"G",value:Math.pow(1024,3),scientific:!0},T:{name:"T",value:Math.pow(1024,4),scientific:!0},P:{name:"P",value:Math.pow(1024,5),scientific:!0},E:{name:"E",value:Math.pow(1024,6),scientific:!0},Z:{name:"Z",value:Math.pow(1024,7),scientific:!0},Y:{name:"Y",value:Math.pow(1024,8),scientific:!0},Ki:{name:"Ki",value:1024,scientific:!0},Mi:{name:"Mi",value:Math.pow(1024,2),scientific:!0},Gi:{name:"Gi",value:Math.pow(1024,3),scientific:!0},Ti:{name:"Ti",value:Math.pow(1024,4),scientific:!0},Pi:{name:"Pi",value:Math.pow(1024,5),scientific:!0},Ei:{name:"Ei",value:Math.pow(1024,6),scientific:!0},Zi:{name:"Zi",value:Math.pow(1024,7),scientific:!0},Yi:{name:"Yi",value:Math.pow(1024,8),scientific:!0}},BINARY_LONG:{"":{name:"",value:1,scientific:!0},kilo:{name:"kilo",value:1024,scientific:!0},mega:{name:"mega",value:Math.pow(1024,2),scientific:!0},giga:{name:"giga",value:Math.pow(1024,3),scientific:!0},tera:{name:"tera",value:Math.pow(1024,4),scientific:!0},peta:{name:"peta",value:Math.pow(1024,5),scientific:!0},exa:{name:"exa",value:Math.pow(1024,6),scientific:!0},zetta:{name:"zetta",value:Math.pow(1024,7),scientific:!0},yotta:{name:"yotta",value:Math.pow(1024,8),scientific:!0},kibi:{name:"kibi",value:1024,scientific:!0},mebi:{name:"mebi",value:Math.pow(1024,2),scientific:!0},gibi:{name:"gibi",value:Math.pow(1024,3),scientific:!0},tebi:{name:"tebi",value:Math.pow(1024,4),scientific:!0},pebi:{name:"pebi",value:Math.pow(1024,5),scientific:!0},exi:{name:"exi",value:Math.pow(1024,6),scientific:!0},zebi:{name:"zebi",value:Math.pow(1024,7),scientific:!0},yobi:{name:"yobi",value:Math.pow(1024,8),scientific:!0}}},w={name:"",value:1,scientific:!0},E={NONE:{},LENGTH:{},MASS:{},TIME:{},CURRENT:{},TEMPERATURE:{},LUMINOUS_INTENSITY:{},AMOUNT_OF_SUBSTANCE:{},FORCE:{},SURFACE:{},VOLUME:{},ANGLE:{},BIT:{}};BASE_UNIT_NONE={},UNIT_NONE={name:"",base:BASE_UNIT_NONE,value:1,offset:0};var N=[{name:"meter",base:E.LENGTH,prefixes:v.LONG,value:1,offset:0},{name:"inch",base:E.LENGTH,prefixes:v.NONE,value:.0254,offset:0},{name:"foot",base:E.LENGTH,prefixes:v.NONE,value:.3048,offset:0},{name:"yard",base:E.LENGTH,prefixes:v.NONE,value:.9144,offset:0},{name:"mile",base:E.LENGTH,prefixes:v.NONE,value:1609.344,offset:0},{name:"link",base:E.LENGTH,prefixes:v.NONE,value:.201168,offset:0},{name:"rod",base:E.LENGTH,prefixes:v.NONE,value:5.02921,offset:0},{name:"chain",base:E.LENGTH,prefixes:v.NONE,value:20.1168,offset:0},{name:"angstrom",base:E.LENGTH,prefixes:v.NONE,value:1e-10,offset:0},{name:"m",base:E.LENGTH,prefixes:v.SHORT,value:1,offset:0},{name:"ft",base:E.LENGTH,prefixes:v.NONE,value:.3048,offset:0},{name:"yd",base:E.LENGTH,prefixes:v.NONE,value:.9144,offset:0},{name:"mi",base:E.LENGTH,prefixes:v.NONE,value:1609.344,offset:0},{name:"li",base:E.LENGTH,prefixes:v.NONE,value:.201168,offset:0},{name:"rd",base:E.LENGTH,prefixes:v.NONE,value:5.02921,offset:0},{name:"ch",base:E.LENGTH,prefixes:v.NONE,value:20.1168,offset:0},{name:"mil",base:E.LENGTH,prefixes:v.NONE,value:254e-7,offset:0},{name:"m2",base:E.SURFACE,prefixes:v.SHORT,value:1,offset:0},{name:"sqin",base:E.SURFACE,prefixes:v.NONE,value:64516e-8,offset:0},{name:"sqft",base:E.SURFACE,prefixes:v.NONE,value:.09290304,offset:0},{name:"sqyd",base:E.SURFACE,prefixes:v.NONE,value:.83612736,offset:0},{name:"sqmi",base:E.SURFACE,prefixes:v.NONE,value:2589988.110336,offset:0},{name:"sqrd",base:E.SURFACE,prefixes:v.NONE,value:25.29295,offset:0},{name:"sqch",base:E.SURFACE,prefixes:v.NONE,value:404.6873,offset:0},{name:"sqmil",base:E.SURFACE,prefixes:v.NONE,value:6.4516e-10,offset:0},{name:"m3",base:E.VOLUME,prefixes:v.SHORT,value:1,offset:0},{name:"L",base:E.VOLUME,prefixes:v.SHORT,value:.001,offset:0},{name:"litre",base:E.VOLUME,prefixes:v.LONG,value:.001,offset:0},{name:"cuin",base:E.VOLUME,prefixes:v.NONE,value:16387064e-12,offset:0},{name:"cuft",base:E.VOLUME,prefixes:v.NONE,value:.028316846592,offset:0},{name:"cuyd",base:E.VOLUME,prefixes:v.NONE,value:.764554857984,offset:0},{name:"teaspoon",base:E.VOLUME,prefixes:v.NONE,value:5e-6,offset:0},{name:"tablespoon",base:E.VOLUME,prefixes:v.NONE,value:15e-6,offset:0},{name:"minim",base:E.VOLUME,prefixes:v.NONE,value:6.161152e-8,offset:0},{name:"fluiddram",base:E.VOLUME,prefixes:v.NONE,value:36966911e-13,offset:0},{name:"fluidounce",base:E.VOLUME,prefixes:v.NONE,value:2957353e-11,offset:0},{name:"gill",base:E.VOLUME,prefixes:v.NONE,value:.0001182941,offset:0},{name:"cup",base:E.VOLUME,prefixes:v.NONE,value:.0002365882,offset:0},{name:"pint",base:E.VOLUME,prefixes:v.NONE,value:.0004731765,offset:0},{name:"quart",base:E.VOLUME,prefixes:v.NONE,value:.0009463529,offset:0},{name:"gallon",base:E.VOLUME,prefixes:v.NONE,value:.003785412,offset:0},{name:"beerbarrel",base:E.VOLUME,prefixes:v.NONE,value:.1173478,offset:0},{name:"oilbarrel",base:E.VOLUME,prefixes:v.NONE,value:.1589873,offset:0},{name:"hogshead",base:E.VOLUME,prefixes:v.NONE,value:.238481,offset:0},{name:"fldr",base:E.VOLUME,prefixes:v.NONE,value:36966911e-13,offset:0},{name:"floz",base:E.VOLUME,prefixes:v.NONE,value:2957353e-11,offset:0},{name:"gi",base:E.VOLUME,prefixes:v.NONE,value:.0001182941,offset:0},{name:"cp",base:E.VOLUME,prefixes:v.NONE,value:.0002365882,offset:0},{name:"pt",base:E.VOLUME,prefixes:v.NONE,value:.0004731765,offset:0},{name:"qt",base:E.VOLUME,prefixes:v.NONE,value:.0009463529,offset:0},{name:"gal",base:E.VOLUME,prefixes:v.NONE,value:.003785412,offset:0},{name:"bbl",base:E.VOLUME,prefixes:v.NONE,value:.1173478,offset:0},{name:"obl",base:E.VOLUME,prefixes:v.NONE,value:.1589873,offset:0},{name:"g",base:E.MASS,prefixes:v.SHORT,value:.001,offset:0},{name:"gram",base:E.MASS,prefixes:v.LONG,value:.001,offset:0},{name:"ton",base:E.MASS,prefixes:v.SHORT,value:907.18474,offset:0},{name:"tonne",base:E.MASS,prefixes:v.SHORT,value:1e3,offset:0},{name:"grain",base:E.MASS,prefixes:v.NONE,value:6479891e-11,offset:0},{name:"dram",base:E.MASS,prefixes:v.NONE,value:.0017718451953125,offset:0},{name:"ounce",base:E.MASS,prefixes:v.NONE,value:.028349523125,offset:0},{name:"poundmass",base:E.MASS,prefixes:v.NONE,value:.45359237,offset:0},{name:"hundredweight",base:E.MASS,prefixes:v.NONE,value:45.359237,offset:0},{name:"stick",base:E.MASS,prefixes:v.NONE,value:.115,offset:0},{name:"gr",base:E.MASS,prefixes:v.NONE,value:6479891e-11,offset:0},{name:"dr",base:E.MASS,prefixes:v.NONE,value:.0017718451953125,offset:0},{name:"oz",base:E.MASS,prefixes:v.NONE,value:.028349523125,offset:0},{name:"lbm",base:E.MASS,prefixes:v.NONE,value:.45359237,offset:0},{name:"cwt",base:E.MASS,prefixes:v.NONE,value:45.359237,offset:0},{name:"s",base:E.TIME,prefixes:v.SHORT,value:1,offset:0},{name:"min",base:E.TIME,prefixes:v.NONE,value:60,offset:0},{name:"h",base:E.TIME,prefixes:v.NONE,value:3600,offset:0},{name:"seconds",base:E.TIME,prefixes:v.LONG,value:1,offset:0},{name:"second",base:E.TIME,prefixes:v.LONG,value:1,offset:0},{name:"sec",base:E.TIME,prefixes:v.LONG,value:1,offset:0},{name:"minutes",base:E.TIME,prefixes:v.NONE,value:60,offset:0},{name:"minute",base:E.TIME,prefixes:v.NONE,value:60,offset:0},{name:"hours",base:E.TIME,prefixes:v.NONE,value:3600,offset:0},{name:"hour",base:E.TIME,prefixes:v.NONE,value:3600,offset:0},{name:"day",base:E.TIME,prefixes:v.NONE,value:86400,offset:0},{name:"days",base:E.TIME,prefixes:v.NONE,value:86400,offset:0},{name:"rad",base:E.ANGLE,prefixes:v.NONE,value:1,offset:0},{name:"deg",base:E.ANGLE,prefixes:v.NONE,value:.017453292519943295,offset:0},{name:"grad",base:E.ANGLE,prefixes:v.NONE,value:.015707963267948967,offset:0},{name:"cycle",base:E.ANGLE,prefixes:v.NONE,value:6.283185307179586,offset:0},{name:"A",base:E.CURRENT,prefixes:v.SHORT,value:1,offset:0},{name:"ampere",base:E.CURRENT,prefixes:v.LONG,value:1,offset:0},{name:"K",base:E.TEMPERATURE,prefixes:v.NONE,value:1,offset:0},{name:"degC",base:E.TEMPERATURE,prefixes:v.NONE,value:1,offset:273.15},{name:"degF",base:E.TEMPERATURE,prefixes:v.NONE,value:1/1.8,offset:459.67},{name:"degR",base:E.TEMPERATURE,prefixes:v.NONE,value:1/1.8,offset:0},{name:"kelvin",base:E.TEMPERATURE,prefixes:v.NONE,value:1,offset:0},{name:"celsius",base:E.TEMPERATURE,prefixes:v.NONE,value:1,offset:273.15},{name:"fahrenheit",base:E.TEMPERATURE,prefixes:v.NONE,value:1/1.8,offset:459.67},{name:"rankine",base:E.TEMPERATURE,prefixes:v.NONE,value:1/1.8,offset:0},{name:"mol",base:E.AMOUNT_OF_SUBSTANCE,prefixes:v.NONE,value:1,offset:0},{name:"mole",base:E.AMOUNT_OF_SUBSTANCE,prefixes:v.NONE,value:1,offset:0},{name:"cd",base:E.LUMINOUS_INTENSITY,prefixes:v.NONE,value:1,offset:0},{name:"candela",base:E.LUMINOUS_INTENSITY,prefixes:v.NONE,value:1,offset:0},{name:"N",base:E.FORCE,prefixes:v.SHORT,value:1,offset:0},{name:"newton",base:E.FORCE,prefixes:v.LONG,value:1,offset:0},{name:"lbf",base:E.FORCE,prefixes:v.NONE,value:4.4482216152605,offset:0},{name:"poundforce",base:E.FORCE,prefixes:v.NONE,value:4.4482216152605,offset:0},{name:"b",base:E.BIT,prefixes:v.BINARY_SHORT,value:1,offset:0},{name:"bits",base:E.BIT,prefixes:v.BINARY_LONG,value:1,offset:0},{name:"B",base:E.BIT,prefixes:v.BINARY_SHORT,value:8,offset:0},{name:"bytes",base:E.BIT,prefixes:v.BINARY_LONG,value:8,offset:0}];r.PREFIXES=v,r.BASE_UNITS=E,r.UNITS=N,n.exports=r,t.isUnit=r.isUnit,t.isPlainUnit=r.isPlainUnit,t.parse=r.parse},{"../util/index":212}],208:[function(e,n,t){function r(e,n,t){var o,a,u,c;if(0>=n){if(s(e[0])){for(c=i(e),a=[],o=0;o<c.length;o++)a[o]=r(c[o],n-1,t);return a}for(u=e[0],o=1;o<e.length;o++)u=t(u,e[o]);return u}for(a=[],o=0;o<e.length;o++)a[o]=r(e[o],n-1,t);return a}function i(e){var n,t,r=e.length,i=e[0].length,o=[];for(t=0;i>t;t++){var a=[];for(n=0;r>n;n++)a.push(e[n][t]);o.push(a)}return o}{var o=e("../util/index"),a=e("./Matrix"),s=o.array.isArray;o.string.isString}t.argsToArray=function(e){var n;return 0==e.length?n=[]:1==e.length?(n=e[0],n instanceof a&&(n=n.valueOf()),s(n)||(n=[n])):n=Array.prototype.slice.apply(e),n},t.isCollection=function(e){return s(e)||e instanceof a},t.deepMap=function u(e,n){return e&&"function"==typeof e.map?e.map(function(e){return u(e,n)}):n(e)},t.deepMap2=function c(e,n,t){var r,i,o;if(s(e))if(s(n)){if(e.length!=n.length)throw new RangeError("Dimension mismatch ("+e.length+" != "+n.length+")");for(r=[],i=e.length,o=0;i>o;o++)r[o]=c(e[o],n[o],t)}else{if(n instanceof a)return r=c(e,n.valueOf(),t),new a(r);for(r=[],i=e.length,o=0;i>o;o++)r[o]=c(e[o],n,t)}else{if(e instanceof a)return n instanceof a?(r=c(e.valueOf(),n.valueOf(),t),new a(r)):(r=c(e.valueOf(),n,t),new a(r));if(s(n))for(r=[],i=n.length,o=0;i>o;o++)r[o]=c(e,n[o],t);else{if(n instanceof a)return r=c(e,n.valueOf(),t),new a(r);r=t(e,n)}}return r},t.reduce=function(e,n,t){return e instanceof a?new a(r(e.valueOf(),n,t)):r(e,n,t)},t.deepForEach=function f(e,n){e instanceof a&&(e=e.valueOf());for(var t=0,r=e.length;r>t;t++){var i=e[t];s(i)?f(i,n):n(i)}}},{"../util/index":212,"./Matrix":205}],209:[function(e,n){n.exports=function(n){var t=(e("./../util/types"),{});n.error=t,t.UnsupportedTypeError=function(e,t){if(2==arguments.length){var r=n["typeof"](t);this.message="Function "+e+"("+r+") not supported"}else if(arguments.length>2){var i=Array.prototype.splice.call(arguments,1),o=i.map(function(e){return n["typeof"](e)});this.message="Function "+e+"("+o.join(", ")+") not supported"}else this.message="Unsupported type of argument in function "+e},t.UnsupportedTypeError.prototype=new TypeError,t.UnsupportedTypeError.prototype.name="UnsupportedTypeError",t.ArgumentsError=function(e,n,t,r){this.message="Wrong number of arguments in function "+e+" ("+n+" provided, "+t+(void 0!=r?"-"+r:"")+" expected)"},t.ArgumentsError.prototype=new SyntaxError,t.ArgumentsError.prototype.name="ArgumentError"}},{"./../util/types":216}],210:[function(e,n,t){function r(e){for(var n=[];c(e);)n.push(e.length),e=e[0];return n}function i(e,n,t){var r,o=e.length;if(o!=n[t])throw new RangeError("Dimension mismatch ("+o+" != "+n[t]+")");if(t<n.length-1){var a=t+1;for(r=0;o>r;r++){var s=e[r];if(!c(s))throw new RangeError("Dimension mismatch ("+(n.length-1)+" < "+n.length+")");i(e[r],n,a)}}else for(r=0;o>r;r++)if(c(e[r]))throw new RangeError("Dimension mismatch ("+(n.length+1)+" > "+n.length+")")}function o(e,n,t,r){if(!c(e))throw Error("Array expected");
+var i,a,s=e.length,f=n[t],l=Math.min(s,f);if(e.length=f,t<n.length-1){var m=t+1;for(i=0;l>i;i++)a=e[i],o(a,n,m,r);for(i=l;f>i;i++)a=[],e[i]=a,o(a,n,m,r)}else if(void 0!==r)for(i=s;f>i;i++)e[i]=u.clone(r)}var a=e("./number"),s=e("./string"),u=e("./object"),c=(e("./types"),Array.isArray);t.size=function(e){var n=r(e);return t.validate(e,n),n},t.validate=function(e,n){var t=0==n.length;if(t){if(c(e))throw new RangeError("Dimension mismatch ("+e.length+" != 0)")}else i(e,n,0)},t.validateIndex=function(e,n){if(!a.isNumber(e)||!a.isInteger(e))throw new TypeError("Index must be an integer (value: "+e+")");if(0>e)throw new RangeError("Index out of range ("+e+" < 0)");if(void 0!==n&&e>=n)throw new RangeError("Index out of range ("+e+" > "+(n-1)+")")},t.resize=function(e,n,t){if(!c(e)||!c(n))throw new TypeError("Array expected");if(0===n.length)throw new Error("Resizing to scalar is not supported");n.forEach(function(e){if(!a.isNumber(e)||!a.isInteger(e)||0>e)throw new TypeError("Invalid size, must contain positive integers (size: "+s.format(n)+")")});for(var r=1,i=e[0];c(i);)r++,i=i[0];for(;r<n.length;)e=[e],r++;for(;r>n.length;)e=e[0],r--;return o(e,n,0,t),e},t.squeeze=function(e){for(;c(e)&&1===e.length;)e=e[0];return e},t.unsqueeze=function(e,n){for(var r=t.size(e),i=0,o=n-r.length;o>i;i++)e=[e];return e},t.isArray=c},{"./number":213,"./object":214,"./string":215,"./types":216}],211:[function(e,n,t){t.isBoolean=function(e){return e instanceof Boolean||"boolean"==typeof e}},{}],212:[function(e,n,t){t.array=e("./array"),t.boolean=e("./boolean"),t.number=e("./number"),t.object=e("./object"),t.string=e("./string"),t.types=e("./types")},{"./array":210,"./boolean":211,"./number":213,"./object":214,"./string":215,"./types":216}],213:[function(e,n,t){function r(e){return e instanceof o?e.isZero():0===e}function i(e,n,t){var r;return e instanceof o?(r=e.abs(),r.gte(n)&&r.lt(t)):(r=Math.abs(e),r>=n&&t>r)}var o=e("bignumber.js");t.isNumber=function(e){return e instanceof Number||"number"==typeof e},t.isInteger=function(e){return e==Math.round(e)},t.sign=function(e){return e>0?1:0>e?-1:0},t.format=function(e,n){if("function"==typeof n)return n(e);if(1/0===e)return"Infinity";if(e===-1/0)return"-Infinity";if(isNaN(e))return"NaN";var a="auto",s=void 0;switch(void 0!==n&&(n.notation&&(a=n.notation),n&&(t.isNumber(n)?s=n:n.precision&&(s=n.precision))),a){case"fixed":return t.toFixed(e,s);case"scientific":throw new Error('Format notation "scientific" is deprecated. Use "exponential" instead.');case"exponential":return t.toExponential(e,s);case"auto":var u=.001,c=1e5;if(n&&n.exponential)void 0!==n.exponential.lower&&(u=n.exponential.lower),void 0!==n.exponential.upper&&(c=n.exponential.upper);else if(n&&n.scientific)throw new Error("options.scientific is deprecated, use options.exponential instead.");var f=e instanceof o;if(f){var l=o.config().EXPONENTIAL_AT;o.config({EXPONENTIAL_AT:[Math.round(Math.log(u)/Math.LN10),Math.round(Math.log(c)/Math.LN10)]})}if(r(e))return"0";var m;return m=i(e,u,c)?f?new o(e.toPrecision(s)).toString():parseFloat(e.toPrecision(s?Math.min(s,21):s))+"":t.toExponential(e,s),f&&o.config({EXPONENTIAL_AT:l}),m.replace(/((\.\d*?)(0+))($|e)/,function(){var e=arguments[2],n=arguments[4];return"."!==e?e+n:n});default:throw new Error('Unknown notation "'+a+'". Choose "auto", "exponential", or "fixed".')}},t.toExponential=function(e,n){return void 0!==n?e instanceof o?e.toExponential(n-1):e.toExponential(Math.min(n-1,20)):e.toExponential()},t.toFixed=function(e,n){return e instanceof o?e.toFixed(n||0):e.toFixed(Math.min(n,20))},t.digits=function(e){return e.toExponential().replace(/e[\+\-0-9]*$/,"").replace(/^0\.0*|\./,"").length},t.toBigNumber=function(e){return t.digits(e)>15?e:new o(e)},t.toNumber=function(e){return parseFloat(e.valueOf())}},{"bignumber.js":217}],214:[function(e,n,t){var r=e("./number"),i=e("./string"),o=e("./boolean");t.clone=function a(e){if(null==e)return e;if("function"==typeof e.clone)return e.clone();if(r.isNumber(e)||i.isString(e)||o.isBoolean(e))return e;if(Array.isArray(e))return e.map(function(e){return a(e)});if(e instanceof Object){var n={};for(var t in e)e.hasOwnProperty(t)&&(n[t]=a(e[t]));return e}throw new TypeError("Cannot clone "+e)},t.extend=function(e,n){for(var t in n)n.hasOwnProperty(t)&&(e[t]=n[t]);return e},t.deepExtend=function s(e,n){for(var t in n)n.hasOwnProperty(t)&&(n[t]&&n[t].constructor===Object?(void 0===e[t]&&(e[t]={}),e[t].constructor===Object?s(e[t],n[t]):e[t]=n[t]):e[t]=n[t]);return e},t.deepEqual=function(e,n){var r,i,o;if(Array.isArray(e)){if(!Array.isArray(n))return!1;if(e.length!=n.length)return!1;for(i=0,o=e.length;o>i;i++)if(!t.deepEqual(e[i],n[i]))return!1;return!0}if(e instanceof Object){if(Array.isArray(n)||!(n instanceof Object))return!1;for(r in e)if(e.hasOwnProperty(r)&&!t.deepEqual(e[r],n[r]))return!1;for(r in n)if(n.hasOwnProperty(r)&&!t.deepEqual(e[r],n[r]))return!1;return!0}return e==n}},{"./boolean":211,"./number":213,"./string":215}],215:[function(e,n,t){function r(e,n){if(Array.isArray(e)){for(var i="[",o=e.length,a=0;o>a;a++)0!=a&&(i+=", "),i+=r(e[a],n);return i+="]"}return t.format(e,n)}var i=e("./number"),o=e("bignumber.js");t.isString=function(e){return e instanceof String||"string"==typeof e},t.endsWith=function(e,n){var t=e.length-n.length,r=e.length;return e.substring(t,r)===n},t.format=function(e,n){return i.isNumber(e)||e instanceof o?i.format(e,n):Array.isArray(e)?r(e,n):t.isString(e)?'"'+e+'"':e instanceof Object?"function"==typeof e.format?e.format(n):e.toString():String(e)}},{"./number":213,"bignumber.js":217}],216:[function(e,n,t){t.type=function r(e){var r=typeof e;if("object"===r){if(null===e)return"null";if(e instanceof Boolean)return"boolean";if(e instanceof Number)return"number";if(e instanceof String)return"string";if(Array.isArray(e))return"array";if(e instanceof Date)return"date"}return r}},{}],217:[function(n,t){!function(n){"use strict";function r(e,n){var t,a,s,u,l,m,g=this;if(!(g instanceof r))return new r(e,n);if(e instanceof r){if(N=0,n===t)return g.s=e.s,g.e=e.e,g.c=(e=e.c)?e.slice():e,void 0;e+=""}if("string"!=typeof e&&(e=(s="number"==typeof e||"[object Number]"==Object.prototype.toString.call(e))&&0===e&&0>1/e?"-0":e+""),m=e,n===t&&M.test(e))g.s="-"==e.charAt(0)?(e=e.slice(1),-1):1;else{if(10==n)return c(e,p,h);if(e=j.call(e).replace(/^\+(?!-)/,""),g.s="-"==e.charAt(0)?(e=e.replace(/^-(?!-)/,""),-1):1,null!=n?n!=(0|n)&&b||(f=!(n>=2&&65>n))?(i(n,2),l=M.test(e)):(u="["+E.slice(0,n=0|n)+"]+",e=e.replace(/\.$/,"").replace(/^\./,"0."),(l=new RegExp("^"+u+"(?:\\."+u+")?$",37>n?"i":"").test(e))?(s&&(e.replace(/^0\.0*|\./,"").length>15&&i(m,0),s=!s),e=o(e,10,n,g.s)):"Infinity"!=e&&"NaN"!=e&&(i(m,1,n),e="NaN")):l=M.test(e),!l)return g.c=g.e=null,"Infinity"!=e&&("NaN"!=e&&i(m,3),g.s=null),N=0,void 0}for((t=e.indexOf("."))>-1&&(e=e.replace(".","")),(a=e.search(/e/i))>0?(0>t&&(t=a),t+=+e.slice(a+1),e=e.substring(0,a)):0>t&&(t=e.length),a=0;"0"==e.charAt(a);a++);if(n=e.length,s&&n>15&&e.slice(a).length>15&&i(m,0),N=0,(t-=a+1)>y)g.c=g.e=null;else if(a==n||d>t)g.c=[g.e=0];else{for(;"0"==e.charAt(--n););for(g.e=t,g.c=[],t=0;n>=a;g.c[t++]=+e.charAt(a++));}}function i(e,n,t,r,i,o){if(b){var a,s=["new BigNumber","cmp","div","eq","gt","gte","lt","lte","minus","mod","plus","times","toFr"][N?0>N?-N:N:0>1/N?1:0]+"()",u=f?" out of range":" not a"+(i?" non-zero":"n")+" integer";throw u=([s+" number type has more than 15 significant digits",s+" not a base "+t+" number",s+" base"+u,s+" not a number"][n]||t+"() "+n+(o?" not a boolean or binary digit":u+(r?" or not ["+(f?" negative, positive":" integer, integer")+" ]":"")))+": "+e,f=N=0,a=new Error(u),a.name="BigNumber Error",a}}function o(e,n,t,i){function o(e,r){var i,o,a=0,s=e.length,u=[0];for(r=r||t;s>a;a++){for(o=u.length,i=0;o>i;u[i]*=r,i++);for(u[0]+=E.indexOf(e.charAt(a)),i=0;i<u.length;i++)u[i]>n-1&&(null==u[i+1]&&(u[i+1]=0),u[i+1]+=u[i]/n^0,u[i]%=n)}return u.reverse()}function s(e){for(var n=0,t=e.length,r="";t>n;r+=E.charAt(e[n++]));return r}var u,c,f,l,m,p;if(37>t&&(e=e.toLowerCase()),(u=e.indexOf("."))>-1)if(u=e.length-u-1,c=o(new r(t).pow(u).toF(),10),l=e.split("."),f=o(l[1]),l=o(l[0]),p=a(f,c,f.length-c.length,i,n,1&l[l.length-1]),m=p.c,u=p.e){for(;++u;m.unshift(0));e=s(l)+"."+s(m)}else m[0]?l[u=l.length-1]<n-1?(++l[u],e=s(l)):e=new r(s(l),n).plus(C).toS(n):e=s(l);else e=s(o(e));return e}function a(e,n,t,i,o,a){var s,c,f,l,m,h=n.slice(),g=s=n.length,x=e.length,b=e.slice(0,s),v=b.length,w=new r(C),E=w.c=[],N=0,M=p+(w.e=t)+1;for(w.s=i,i=0>M?0:M;v++<s;b.push(0));h.unshift(0);do{for(f=0;o>f;f++){if(s!=(v=b.length))l=s>v?1:-1;else for(m=-1,l=0;++m<s;)if(n[m]!=b[m]){l=n[m]>b[m]?1:-1;break}if(!(0>l))break;for(c=v==s?n:h;v;){if(b[--v]<c[v]){for(m=v;m&&!b[--m];b[m]=o-1);--b[m],b[v]+=o}b[v]-=c[v]}for(;!b[0];b.shift());}E[N++]=l?f:++f,b[0]&&l?b[v]=e[g]||0:b=[e[g]]}while((g++<x||null!=b[0])&&i--);return E[0]||1==N||(--w.e,E.shift()),N>M&&u(w,p,o,a,null!=b[0]),w.e>y?w.c=w.e=null:w.e<d&&(w.c=[w.e=0]),w}function s(e,n,t){var i=n-(e=new r(e)).e,o=e.c;if(!o)return e.toS();for(o.length>++n&&u(e,i,10),i=0==o[0]?i+1:t?n:e.e+i+1;o.length<i;o.push(0));return i=e.e,1==t||2==t&&(--n<i||g>=i)?(e.s<0&&o[0]?"-":"")+(o.length>1?(o.splice(1,0,"."),o.join("")):o[0])+(0>i?"e":"e+")+i:e.toS()}function u(e,n,t,r,i){var o=e.c,a=e.s<0,s=t/2,u=e.e+n+1,c=o[u],f=i||0>u||null!=o[u+1];if(i=4>h?(null!=c||f)&&(0==h||2==h&&!a||3==h&&a):c>s||c==s&&(4==h||f||6==h&&(1&o[u-1]||!n&&r)||7==h&&!a||8==h&&a),1>u||!o[0])return o.length=0,o.push(0),i?(o[0]=1,e.e=-n):e.e=0,e;if(o.length=u--,i)for(--t;++o[u]>t;)o[u]=0,u--||(++e.e,o.unshift(1));for(u=o.length;!o[--u];o.pop());return e}function c(e,n,t){var i=h;return h=t,e=new r(e),e.c&&u(e,n,10),h=i,e}var f,l=1e9,m=1e6,p=20,h=4,g=-7,x=21,x=21,d=-l,y=l,b=!0,v=parseInt,w=r.prototype,E="0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_",N=0,M=/^-?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i,j=String.prototype.trim||function(){return this.replace(/^\s+|\s+$/g,"")},C=r(1);r.ROUND_UP=0,r.ROUND_DOWN=1,r.ROUND_CEIL=2,r.ROUND_FLOOR=3,r.ROUND_HALF_UP=4,r.ROUND_HALF_DOWN=5,r.ROUND_HALF_EVEN=6,r.ROUND_HALF_CEIL=7,r.ROUND_HALF_FLOOR=8,r.config=function(){var e,n,t=0,r={},o=arguments,a=o[0],s="config",u=function(e,n,t){return!((f=n>e||e>t)||v(e)!=e&&0!==e)},c=a&&"object"==typeof a?function(){return a.hasOwnProperty(n)?null!=(e=a[n]):void 0}:function(){return o.length>t?null!=(e=o[t++]):void 0};return c(n="DECIMAL_PLACES")&&(u(e,0,l)?p=0|e:i(e,n,s)),r[n]=p,c(n="ROUNDING_MODE")&&(u(e,0,8)?h=0|e:i(e,n,s)),r[n]=h,c(n="EXPONENTIAL_AT")&&(u(e,-l,l)?g=-(x=~~(0>e?-e:+e)):!f&&e&&u(e[0],-l,0)&&u(e[1],0,l)?(g=~~e[0],x=~~e[1]):i(e,n,s,1)),r[n]=[g,x],c(n="RANGE")&&(u(e,-l,l)&&~~e?d=-(y=~~(0>e?-e:+e)):!f&&e&&u(e[0],-l,-1)&&u(e[1],1,l)?(d=~~e[0],y=~~e[1]):i(e,n,s,1,1)),r[n]=[d,y],c(n="ERRORS")&&(e===!!e||1===e||0===e?(f=N=0,v=(b=!!e)?parseInt:parseFloat):i(e,n,s,0,0,1)),r[n]=b,r},w.abs=w.absoluteValue=function(){var e=new r(this);return e.s<0&&(e.s=1),e},w.ceil=function(){return c(this,0,2)},w.comparedTo=w.cmp=function(e,n){var t,i=this,o=i.c,a=(N=-N,e=new r(e,n)).c,s=i.s,u=e.s,c=i.e,f=e.e;if(!s||!u)return null;if(t=o&&!o[0],n=a&&!a[0],t||n)return t?n?0:-u:s;if(s!=u)return s;if(t=0>s,n=c==f,!o||!a)return n?0:!o^t?1:-1;if(!n)return c>f^t?1:-1;for(s=-1,u=(c=o.length)<(f=a.length)?c:f;++s<u;)if(o[s]!=a[s])return o[s]>a[s]^t?1:-1;return c==f?0:c>f^t?1:-1},w.dividedBy=w.div=function(e,n){var t=this.c,i=this.e,o=this.s,s=(N=2,e=new r(e,n)).c,u=e.e,c=e.s,f=o==c?1:-1;return(i||t&&t[0])&&(u||s&&s[0])?a(t,s,i-u,f,10):new r(o&&c&&(t?!s||t[0]!=s[0]:s)?t&&0==t[0]||!s?0*f:f/0:0/0)},w.equals=w.eq=function(e,n){return N=3,0===this.cmp(e,n)},w.floor=function(){return c(this,0,3)},w.greaterThan=w.gt=function(e,n){return N=4,this.cmp(e,n)>0},w.greaterThanOrEqualTo=w.gte=function(e,n){return N=5,1==(n=this.cmp(e,n))||0===n},w.isFinite=w.isF=function(){return!!this.c},w.isNaN=function(){return!this.s},w.isNegative=w.isNeg=function(){return this.s<0},w.isZero=w.isZ=function(){return!!this.c&&0==this.c[0]},w.lessThan=w.lt=function(e,n){return N=6,this.cmp(e,n)<0},w.lessThanOrEqualTo=w.lte=function(e,n){return N=7,-1==(n=this.cmp(e,n))||0===n},w.minus=function(e,n){var t,i,o,a,s=this,u=s.s;if(n=(N=8,e=new r(e,n)).s,!u||!n)return new r(0/0);if(u!=n)return e.s=-n,s.plus(e);var c=s.c,f=s.e,l=e.c,m=e.e;if(!f||!m){if(!c||!l)return c?(e.s=-n,e):new r(l?s:0/0);if(!c[0]||!l[0])return l[0]?(e.s=-n,e):new r(c[0]?s:3==h?-0:0)}if(c=c.slice(),u=f-m){for(t=(a=0>u)?(u=-u,c):(m=f,l),t.reverse(),n=u;n--;t.push(0));t.reverse()}else for(o=((a=c.length<l.length)?c:l).length,u=n=0;o>n;n++)if(c[n]!=l[n]){a=c[n]<l[n];break}if(a&&(t=c,c=l,l=t,e.s=-e.s),(n=-((o=c.length)-l.length))>0)for(;n--;c[o++]=0);for(n=l.length;n>u;){if(c[--n]<l[n]){for(i=n;i&&!c[--i];c[i]=9);--c[i],c[n]+=10}c[n]-=l[n]}for(;0==c[--o];c.pop());for(;0==c[0];c.shift(),--m);return(d>m||!c[0])&&(c[0]||(e.s=3==h?-1:1),c=[m=0]),e.c=c,e.e=m,e},w.modulo=w.mod=function(e,n){var t=this,i=t.c,o=(N=9,e=new r(e,n)).c,a=t.s,s=e.s;return n=!a||!s||o&&!o[0],n||i&&!i[0]?new r(n?0/0:t):(t.s=e.s=1,n=1==e.cmp(t),t.s=a,e.s=s,n?new r(t):(a=p,s=h,p=0,h=1,t=t.div(e),p=a,h=s,this.minus(t.times(e))))},w.negated=w.neg=function(){var e=new r(this);return e.s=-e.s||null,e},w.plus=function(e,n){var t,i=this,o=i.s;if(n=(N=10,e=new r(e,n)).s,!o||!n)return new r(0/0);if(o!=n)return e.s=-n,i.minus(e);var a=i.e,s=i.c,u=e.e,c=e.c;if(!a||!u){if(!s||!c)return new r(o/0);if(!s[0]||!c[0])return c[0]?e:new r(s[0]?i:0*o)}if(s=s.slice(),o=a-u){for(t=o>0?(u=a,c):(o=-o,s),t.reverse();o--;t.push(0));t.reverse()}for(s.length-c.length<0&&(t=c,c=s,s=t),o=c.length,n=0;o;n=(s[--o]=s[o]+c[o]+n)/10^0,s[o]%=10);for(n&&(s.unshift(n),++u>y&&(s=u=null)),o=s.length;0==s[--o];s.pop());return e.c=s,e.e=u,e},w.toPower=w.pow=function(e){var n=0*e==0?0|e:e,t=new r(this),o=new r(C);if(((f=-m>e||e>m)&&(n=1*e/0)||v(e)!=e&&0!==e&&!(n=0/0))&&!i(e,"exponent","pow")||!n)return new r(Math.pow(t.toS(),n));for(n=0>n?-n:n;1&n&&(o=o.times(t)),n>>=1,n;)t=t.times(t);return 0>e?C.div(o):o},w.round=function(e,n){return e=null==e||((f=0>e||e>l)||v(e)!=e)&&!i(e,"decimal places","round")?0:0|e,n=null==n||((f=0>n||n>8)||v(n)!=n&&0!==n)&&!i(n,"mode","round")?h:0|n,c(this,e,n)},w.squareRoot=w.sqrt=function(){var e,n,t,i,o=this,a=o.c,s=o.s,c=o.e,f=p,l=h,m=new r("0.5");if(1!==s||!a||!a[0])return new r(!s||0>s&&(!a||a[0])?0/0:a?o:1/0);for(s=Math.sqrt(o.toS()),h=1,0==s||s==1/0?(e=a.join(""),e.length+c&1||(e+="0"),n=new r(Math.sqrt(e)+""),n.c||(n.c=[1]),n.e=((c+1)/2|0)-(0>c||1&c)):n=new r(e=s.toString()),t=n.e,s=t+(p+=4),3>s&&(s=0),c=s;;)if(i=n,n=m.times(i.plus(o.div(i))),i.c.slice(0,s).join("")===n.c.slice(0,s).join("")){if(a=n.c,s-=e&&n.e<t,9!=a[s]||9!=a[s-1]||9!=a[s-2]||!(9==a[s-3]||e&&4==a[s-3])){if(!(a[c]||a[c-1]||a[c-2]||a[c-3]&&5!=a[c-3]||(a.length>c-2&&(a.length=c-2),n.times(n).eq(o)))){for(;a.length<c-3;)a.push(0);a[c-3]++}return h=l,u(n,p=f,10),n}if(e&&9==a[s-3]&&(i=n.round(f,0),i.times(i).eq(o)))return h=l,p=f,i;p+=4,s+=4,e=""}},w.times=function(e,n){var t,i=this,o=i.c,a=(N=11,e=new r(e,n)).c,s=i.e,u=e.e,c=i.s;if(e.s=c==(n=e.s)?1:-1,!((s||o&&o[0])&&(u||a&&a[0])))return new r(!c||!n||o&&!o[0]&&!a||a&&!a[0]&&!o?0/0:o&&a?0*e.s:e.s/0);for(e.e=s+u,(c=o.length)<(n=a.length)&&(t=o,o=a,a=t,u=c,c=n,n=u),u=c+n,t=[];u--;t.push(0));for(s=n-1;s>-1;s--){for(n=0,u=c+s;u>s;n=t[u]+a[s]*o[u-s-1]+n,t[u--]=n%10|0,n=n/10|0);n&&(t[u]=(t[u]+n)%10)}for(n&&++e.e,!t[0]&&t.shift(),u=t.length;!t[--u];t.pop());return e.c=e.e>y?e.e=null:e.e<d?[e.e=0]:t,e},w.toExponential=w.toE=function(e){return s(this,(null==e||((f=0>e||e>l)||v(e)!=e&&0!==e)&&!i(e,"decimal places","toE"))&&this.c?this.c.length-1:0|e,1)},w.toFixed=w.toF=function(e){var n,t,r,o=this;return null==e||((f=0>e||e>l)||v(e)!=e&&0!==e)&&!i(e,"decimal places","toF")||(r=o.e+(0|e)),n=g,e=x,g=-(x=1/0),r==t?t=o.toS():(t=s(o,r),o.s<0&&o.c&&(o.c[0]?t.indexOf("-")<0&&(t="-"+t):t=t.replace(/^-/,""))),g=n,x=e,t},w.toFraction=w.toFr=function(e){var n,t,o,a,s,u,c,l=a=new r(C),m=o=new r("0"),g=this,x=g.c,d=y,v=p,w=h,E=new r(C);if(!x)return g.toS();for(c=E.e=x.length-g.e-1,(null==e||(!(N=12,u=new r(e)).s||(f=u.cmp(l)<0||!u.c)||b&&u.e<u.c.length-1)&&!i(e,"max denominator","toFr")||(e=u).cmp(E)>0)&&(e=c>0?E:l),y=1/0,u=new r(x.join("")),p=0,h=1;n=u.div(E),s=a.plus(n.times(m)),1!=s.cmp(e);)a=m,m=s,l=o.plus(n.times(s=l)),o=s,E=u.minus(n.times(s=E)),u=s;return s=e.minus(a).div(m),o=o.plus(s.times(l)),a=a.plus(s.times(m)),o.s=l.s=g.s,p=2*c,h=w,t=l.div(m).minus(g).abs().cmp(o.div(a).minus(g).abs())<1?[l.toS(),m.toS()]:[o.toS(),a.toS()],y=d,p=v,t},w.toPrecision=w.toP=function(e){return null==e||((f=1>e||e>l)||v(e)!=e)&&!i(e,"precision","toP")?this.toS():s(this,0|--e,2)},w.toString=w.toS=function(e){var n,t,r,a=this,u=a.e;if(null===u)t=a.s?"Infinity":"NaN";else{if(e===n&&(g>=u||u>=x))return s(a,a.c.length-1,1);if(t=a.c.join(""),0>u){for(;++u;t="0"+t);t="0."+t}else if(r=t.length,u>0)if(++u>r)for(u-=r;u--;t+="0");else r>u&&(t=t.slice(0,u)+"."+t.slice(u));else if(n=t.charAt(0),r>1)t=n+"."+t.slice(1);else if("0"==n)return n;if(null!=e)if((f=!(e>=2&&65>e))||e!=(0|e)&&b)i(e,"base","toS");else if(t=o(t,0|e,10,a.s),"0"==t)return t}return a.s<0?"-"+t:t},w.valueOf=function(){return this.toS()},"undefined"!=typeof t&&t.exports?t.exports=r:"function"==typeof e&&e.amd?e(function(){return r}):n.BigNumber=r}(this)},{}]},{},[1])(1)}),Array.prototype.indexOf||(Array.prototype.indexOf=function(e){for(var n=0;n<this.length;n++)if(this[n]==e)return n;return-1}),Array.prototype.forEach||(Array.prototype.forEach=function(e,n){for(var t=0,r=this.length;r>t;++t)e.call(n||this,this[t],t,this)}),Array.isArray||(Array.isArray=function(e){return"[object Array]"===Object.prototype.toString.call(e)}),Array.prototype.map||(Array.prototype.map=function(e,n){var t,r,i;if(null==this)throw new TypeError(" this is null or not defined");var o=Object(this),a=o.length>>>0;if("function"!=typeof e)throw new TypeError(e+" is not a function");for(n&&(t=n),r=new Array(a),i=0;a>i;){var s,u;i in o&&(s=o[i],u=e.call(t,s,i,o),r[i]=u),i++}return r}),Array.prototype.every||(Array.prototype.every=function(e){"use strict";if(null==this)throw new TypeError;var n=Object(this),t=n.length>>>0;if("function"!=typeof e)throw new TypeError;for(var r=arguments[1],i=0;t>i;i++)if(i in n&&!e.call(r,n[i],i,n))return!1;return!0}),Array.prototype.some||(Array.prototype.some=function(e){"use strict";if(null==this)throw new TypeError;var n=Object(this),t=n.length>>>0;if("function"!=typeof e)throw new TypeError;for(var r=arguments[1],i=0;t>i;i++)if(i in n&&e.call(r,n[i],i,n))return!0;return!1}),Function.prototype.bind||(Function.prototype.bind=function(e){if("function"!=typeof this)throw new TypeError("Function.prototype.bind - what is trying to be bound is not callable");var n=Array.prototype.slice.call(arguments,1),t=this,r=function(){},i=function(){return t.apply(this instanceof r&&e?this:e,n.concat(Array.prototype.slice.call(arguments)))};return r.prototype=this.prototype,i.prototype=new r,i});
\ No newline at end of file
diff --git a/ajax/libs/mathjs/package.json b/ajax/libs/mathjs/package.json
index 7ec371945..c98e623b2 100644
--- a/ajax/libs/mathjs/package.json
+++ b/ajax/libs/mathjs/package.json
@@ -1,15 +1,18 @@
 {
   "name": "mathjs",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "filename": "math.min.js",
   "homepage": "http://mathjs.org",
-  "description": "Math.js is an extensive math library for JavaScript and Node.js. It features real and complex numbers, units, matrices, a large set of mathematical functions, and a flexible expression parser.",
-  "author": "Jos de Jong <wjosdejong@gmail.com>",
+  "description": "Math.js is an extensive math library for JavaScript and Node.js. It features a flexible expression parser and offers an integrated solution to work with numbers, big numbers, complex numbers, units, and matrices.",
+  "author": "Jos de Jong <wjosdejong@gmail.com> (https://github.com/josdejong)",
   "contributors": [
-    {
-      "name": "Jos de Jong",
-      "email": "wjosdejong@gmail.com"
-    }
+    "Sebastien Piquemal (https://github.com/sebpiq)",
+    "Guillermo Indalecio Fernández (https://github.com/guillermobox)",
+    "Huseyn Guliyev (https://github.com/husayt)",
+    "Jim Garrison (https://github.com/garrison)",
+    "Bart Kiers (https://github.com/bkiers)",
+    "Zak Zibrat (https://github.com/palimpsests)",
+    "Bryan Cuccioli (https://github.com/bcuccioli)"
   ],
   "repository": {
     "type": "git",