Merge lp:~gang65/ubuntu-calculator-app/ubuntu-calculator-app-mathjs-2-upgrade into lp:ubuntu-calculator-app

[Bartosz Kosiorek]

Upgrade math.js to 2.1.1 to improve performance (LP: #1484851)

Upgrade math.js to 2.1.1 to improve performance (LP: #1484851)

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:221
http://91.189.93.70:8080/job/ubuntu-calculator-app-ci/361/
Executed test runs:
    UNSTABLE: http://91.189.93.70:8080/job/generic-mediumtests-utopic/3161
        deb: http://91.189.93.70:8080/job/generic-mediumtests-utopic/3161/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-calculator-app-utopic-amd64-ci/140
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-calculator-app-vivid-amd64-ci/83

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-calculator-app-ci/361/rebuild

review: Needs Fixing (continuous-integration)

[Riccardo Padovani (rpadovani)]

lgtm, thanks!

review: Approve

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Autolanding.
More details in the following jenkins job:
http://91.189.93.70:8080/job/ubuntu-calculator-app-autolanding/162/
Executed test runs:
    UNSTABLE: http://91.189.93.70:8080/job/generic-mediumtests-utopic/3191
        deb: http://91.189.93.70:8080/job/generic-mediumtests-utopic/3191/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-calculator-app-utopic-amd64-autolanding/62
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-calculator-app-vivid-amd64-autolanding/52

review: Needs Fixing (continuous-integration)

[lp:~gang65/ubuntu-calculator-app/ubuntu-calculator-app-mathjs-2-upgrade]

222. By Bartosz Kosiorek on 2015-08-30

Upgrade math.js to 2.2

223. By Bartosz Kosiorek on 2015-08-30

Upgrade math.js to 2.2.0

224. By Bartosz Kosiorek on 2015-08-30

Tune math.js for calculator purposes

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:224
http://91.189.93.70:8080/job/ubuntu-calculator-app-ci/362/
Executed test runs:
    UNSTABLE: http://91.189.93.70:8080/job/generic-mediumtests-utopic/3192
        deb: http://91.189.93.70:8080/job/generic-mediumtests-utopic/3192/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-calculator-app-utopic-amd64-ci/141
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-calculator-app-vivid-amd64-ci/84

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-calculator-app-ci/362/rebuild

review: Needs Fixing (continuous-integration)

[Nicholas Skaggs (nskaggs)]

Rebuilding with jenkins fixed :-)

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

PASSED: Continuous integration, rev:224
http://91.189.93.70:8080/job/ubuntu-calculator-app-ci/363/
Executed test runs:
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-calculator-app-vivid-amd64-ci/85

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-calculator-app-ci/363/rebuild

review: Approve (continuous-integration)

=== modified file 'app/engine/math.js'
--- app/engine/math.js	2015-04-29 19:37:47 +0000
+++ app/engine/math.js	2015-08-30 23:10:49 +0000
@@ -14,8 +14,8 @@
  * It features real and complex numbers, units, matrices, a large set of
  * mathematical functions, and a flexible expression parser.
  *
- * @version 1.5.2
- * @date    2015-04-09
+ * @version 2.2.0
+ * @date    2015-08-30
  *
  * @license
  * Copyright (C) 2013-2015 Jos de Jong <[e-mail]>
@@ -35,7 +35,8 @@
 
 (function webpackUniversalModuleDefinition(root, factory) {
     // UCA: we delete all exports, we don't need them, and we keep only our var
-    mathJs = factory();})(this, function() {
+    mathJs = factory();
+})(this, function() {
 return /******/ (function(modules) { // webpackBootstrap
 /******/ 	// The module cache
 /******/ 	var installedModules = {};
@@ -82,42 +83,117 @@
 /* 0 */
 /***/ function(module, exports, __webpack_require__) {
 
-	module.exports = __webpack_require__(1);
-
-
-/***/ },
-/* 1 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	var object = __webpack_require__(2);
-	var digits = __webpack_require__(3).digits;
+	var core = __webpack_require__(1);
 
 	/**
-	 * math.js factory function.
+	 * math.js factory function. Creates a new instance of math.js
 	 *
 	 * @param {Object} [config] Available configuration options:
-	 *                            {String} matrix
+	 *                            {number} epsilon
+	 *                              Minimum relative difference between two
+	 *                              compared values, used by all comparison functions.
+	 *                            {string} matrix
 	 *                              A string 'matrix' (default) or 'array'.
-	 *                            {String} number
-	 *                              A string 'number' (default) or 'bignumber'
-	 *                            {Number} precision
+	 *                            {string} number
+	 *                              A string 'number' (default), 'bignumber', or
+	 *                              'fraction'
+	 *                            {number} precision
 	 *                              The number of significant digits for BigNumbers.
 	 *                              Not applicable for Numbers.
+	 *                            {boolean} predictable
+	 *                              Predictable output type of functions. When true,
+	 *                              output type depends only on the input types. When
+	 *                              false (default), output type can vary depending
+	 *                              on input values. For example `math.sqrt(-2)`
+	 *                              returns `NaN` when predictable is false, and
+	 *                              returns `complex('2i')` when true.
 	 */
 	function create (config) {
+	  // create a new math.js instance
+	  var math = core.create(config);
+	  math.create = create;
+
+	  // import data types, functions, constants, expression parser, etc.
+	  math.import(__webpack_require__(13));
+
+	  return math;
+	}
+
+	// return a new instance of math.js
+	module.exports = create();
+
+
+/***/ },
+/* 1 */
+/***/ function(module, exports, __webpack_require__) {
+
+	module.exports = __webpack_require__(2);
+
+/***/ },
+/* 2 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var isFactory = __webpack_require__(5).isFactory;
+	var deepExtend = __webpack_require__(5).deepExtend;
+	var typedFactory = __webpack_require__(6);
+	var emitter = __webpack_require__(3);
+
+	var importFactory = __webpack_require__(10);
+	var configFactory = __webpack_require__(12);
+
+	/**
+	 * Math.js core. Creates a new, empty math.js instance
+	 * @param {Object} [options] Available options:
+	 *                            {number} epsilon
+	 *                              Minimum relative difference between two
+	 *                              compared values, used by all comparison functions.
+	 *                            {string} matrix
+	 *                              A string 'matrix' (default) or 'array'.
+	 *                            {string} number
+	 *                              A string 'number' (default), 'bignumber', or 'fraction'
+	 *                            {number} precision
+	 *                              The number of significant digits for BigNumbers.
+	 *                              Not applicable for Numbers.
+	 *                            {boolean} predictable
+	 *                              Predictable output type of functions. When true,
+	 *                              output type depends only on the input types. When
+	 *                              false (default), output type can vary depending
+	 *                              on input values. For example `math.sqrt(-2)`
+	 *                              returns `NaN` when predictable is false, and
+	 *                              returns `complex('2i')` when true.
+	 * @returns {Object} Returns a bare-bone math.js instance containing
+	 *                   functions:
+	 *                   - `import` to add new functions
+	 *                   - `config` to change configuration
+	 *                   - `on`, `off`, `once`, `emit` for events
+	 */
+	exports.create = function create (options) {
 	  // simple test for ES5 support
 	  if (typeof Object.create !== 'function') {
 	    throw new Error('ES5 not supported by this JavaScript engine. ' +
-	        'Please load the es5-shim and es5-sham library for compatibility.');
+	    'Please load the es5-shim and es5-sham library for compatibility.');
 	  }
 
-	  // create namespace
-	  var math = {};
+	  // cached factories and instances
+	  var factories = [];
+	  var instances = [];
+
+	  // create a namespace for the mathjs instance, and attach emitter functions
+	  var math = emitter.mixin({});
+	  math.type = {};
+	  math.expression = {
+	    transform: Object.create(math)
+	  };
+
+	  // create a new typed instance
+	  math.typed = typedFactory.create(math.type);
 
 	  // create configuration options. These are private
 	  var _config = {
+	    // minimum relative difference between two compared values,
+	    // used by all comparison functions
+	    epsilon: 1e-14,
+
 	    // type of default matrix output. Choose 'matrix' (default) or 'array'
 	    matrix: 'matrix',
 
@@ -127,391 +203,161 @@
 	    // number of significant digits in BigNumbers
 	    precision: 64,
 
-	    // minimum relative difference between two compared values,
-	    // used by all comparison functions
-	    epsilon: 1e-14
+	    // predictable output type of functions. When true, output type depends only
+	    // on the input types. When false (default), output type can vary depending
+	    // on input values. For example `math.sqrt(-2)` returns `NaN` when
+	    // predictable is false, and returns `complex('2i')` when true.
+	    predictable: false
 	  };
 
+	  if (options) {
+	    // merge options
+	    deepExtend(_config, options);
+	  }
+
 	  /**
-	   * Set configuration options for math.js, and get current options
-	   * @param {Object} [options] Available options:
-	   *                            {String} matrix
-	   *                              A string 'matrix' (default) or 'array'.
-	   *                            {String} number
-	   *                              A string 'number' (default) or 'bignumber'
-	   *                            {Number} precision
-	   *                              The number of significant digits for BigNumbers.
-	   *                              Not applicable for Numbers.
-	   * @return {Object} Returns the current configuration
+	   * Load a function or data type from a factory.
+	   * If the function or data type already exists, the existing instance is
+	   * returned.
+	   * @param {{type: string, name: string, factory: Function}} factory
+	   * @returns {*}
 	   */
-	  math.config = function(options) {
-	    if (options) {
-	      // merge options
-	      object.deepExtend(_config, options);
-
-	      if (options.precision) {
-	        math.type.BigNumber.config({
-	          precision: options.precision
-	        });
-	      }
-
-	      // reload the constants (they depend on option number and precision)
-	      // this must be done after math.type.BigNumber.config is applied
-	      __webpack_require__(4)(math, _config);
-
-	      // TODO: remove deprecated setting some day (deprecated since version 0.17.0)
-	      if (options.number && options.number.defaultType) {
-	        throw new Error('setting `number.defaultType` is deprecated. Use `number` instead.');
-	      }
-
-	      // TODO: remove deprecated setting some day (deprecated since version 0.17.0)
-	      if (options.number && options.number.precision) {
-	        throw new Error('setting `number.precision` is deprecated. Use `precision` instead.');
-	      }
-
-	      // TODO: remove deprecated setting some day (deprecated since version 0.17.0)
-	      if (options.matrix && options.matrix.defaultType) {
-	        throw new Error('setting `matrix.defaultType` is deprecated. Use `matrix` instead.');
-	      }
-
-	      // TODO: remove deprecated setting some day (deprecated since version 0.15.0)
-	      if (options.matrix && options.matrix['default']) {
-	        throw new Error('setting `matrix.default` is deprecated. Use `matrix` instead.');
-	      }
-
-	      // TODO: remove deprecated setting some day (deprecated since version 0.20.0)
-	      if (options.decimals) {
-	        throw new Error('setting `decimals` is deprecated. Use `precision` instead.');
-	      }
+	  function load (factory) {
+	    if (!isFactory(factory)) {
+	      throw new Error('Factory object with properties `type`, `name`, and `factory` expected');
 	    }
 
-	    // return a clone of the settings
-	    return object.clone(_config);
-	  };
-
-	  /**
-	   * math.js factory function. Creates a new instance of math.js
-	   *
-	   * @param {Object} [config] Available configuration options:
-	   *                            {String} matrix
-	   *                              A string 'matrix' (default) or 'array'.
-	   *                            {String} number
-	   *                              A string 'number' (default) or 'bignumber'
-	   *                            {Number} precision
-	   *                              The number of significant digits for BigNumbers.
-	   *                              Not applicable for Numbers.
-	   */
-	  math.create = create;
-
-	  // create a new BigNumber factory for this instance of math.js
-	  var BigNumber = __webpack_require__(5).constructor();
-
-	  /**
-	   * Get a JSON representation of a BigNumber containing
-	   * type information
-	   * @returns {Object} Returns a JSON object structured as:
-	   *                   `{"mathjs": "BigNumber", "value": "0.2"}`
-	   */
-	  BigNumber.prototype.toJSON = function () {
-	    return {
-	      mathjs: 'BigNumber',
-	      value: this.toString()
-	    };
-	  };
-
-	  /**
-	   * Instantiate a BigNumber from a JSON object
-	   * @param {Object} json  a JSON object structured as:
-	   *                       `{"mathjs": "BigNumber", "value": "0.2"}`
-	   * @return {BigNumber}
-	   */
-	  BigNumber.fromJSON = function (json) {
-	    return new BigNumber(json.value);
-	  };
-
-	  // extend BigNumber with a function clone
-	  if (typeof BigNumber.prototype.clone !== 'function') {
-	    /**
-	     * Clone a bignumber
-	     * @return {BigNumber} clone
-	     */
-	    BigNumber.prototype.clone = function() {
-	      return this; // just return itself (a BigNumber is immutable)
-	    };
-	  }
-
-	  // extend BigNumber with a function convert
-	  if (typeof BigNumber.convert !== 'function') {
-	    /**
-	     * Try to 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
-	     */
-	    BigNumber.convert = function(number) {
-	      if (digits(number) > 15) {
-	        return number;
+	    var index = factories.indexOf(factory);
+	    var instance;
+	    if (index === -1) {
+	      // doesn't yet exist
+	      if (factory.math === true) {
+	        // pass with math namespace
+	        instance = factory.factory(math.type, _config, load, math.typed, math);
 	      }
 	      else {
-	        return new BigNumber(number);
+	        instance = factory.factory(math.type, _config, load, math.typed);
 	      }
-	    };
-	  }
-	  else {
-	    throw new Error('Cannot add function convert to BigNumber: function already exists');
-	  }
-
-	  // errors
-	  math.error = __webpack_require__(6);
-
-	  // types (Matrix, Complex, Unit, ...)
-	  math.type = {};
-	  math.type.Complex = __webpack_require__(7);
-	  math.type.Range = __webpack_require__(8);
-	  math.type.Index = __webpack_require__(9);
-	  math.type.Matrix = __webpack_require__(10)(_config);
-	  math.type.Unit = __webpack_require__(11);
-	  math.type.Help = __webpack_require__(12);
-	  math.type.ResultSet = __webpack_require__(13);
-	  math.type.BigNumber = BigNumber;
-
-	  math.collection = __webpack_require__(14)(math, _config);
-
-	  // matrix storage formats
-	  math.type.CcsMatrix = __webpack_require__(15)(math, _config);
-	  math.type.CrsMatrix = __webpack_require__(16)(math, _config);
-	  math.type.DenseMatrix = __webpack_require__(17)(math, _config);
-
-	  // matrix storage format registry
-	  math.type.Matrix._storage.ccs = math.type.CcsMatrix;
-	  math.type.Matrix._storage.crs = math.type.CrsMatrix;
-	  math.type.Matrix._storage.dense = math.type.DenseMatrix;
-	  math.type.Matrix._storage['default'] = math.type.DenseMatrix;
-
-	  // expression (parse, Parser, nodes, docs)
-	  math.expression = {};
-	  math.expression.node = __webpack_require__(18);
-	  math.expression.parse = __webpack_require__(19)(math, _config);
-	  math.expression.Parser = __webpack_require__(20)(math, _config);
-	  math.expression.docs = __webpack_require__(21);
-
-	  // serialization utilities
-	  math.json = {
-	    reviver: __webpack_require__(22)(math, _config)
-	  };
-	  
-	  // functions - construction (must be defined before the rest of functions)
-	  __webpack_require__(34)(math, _config);
-	  __webpack_require__(35)(math, _config);
-	  __webpack_require__(36)(math, _config);
-	  __webpack_require__(37)(math, _config);
-	  __webpack_require__(38)(math, _config);
-	  __webpack_require__(39)(math, _config);
-	  __webpack_require__(40)(math, _config);
-	  __webpack_require__(41)(math, _config);
-	  __webpack_require__(42)(math, _config);
-	  __webpack_require__(43)(math, _config);
-
-	  // expression parser
-	  __webpack_require__(44)(math, _config);
-	  __webpack_require__(45)(math, _config);
-	  __webpack_require__(46)(math, _config);
-	  __webpack_require__(47)(math, _config);
-
-	  // functions - arithmetic
-	  __webpack_require__(48)(math, _config);
-	  __webpack_require__(49)(math, _config);
-	  __webpack_require__(50)(math, _config);
-	  __webpack_require__(51)(math, _config);
-	  __webpack_require__(52)(math, _config);
-	  __webpack_require__(53)(math, _config);
-	  __webpack_require__(54)(math, _config);
-	  __webpack_require__(55)(math, _config);
-	  __webpack_require__(56)(math, _config);
-	  __webpack_require__(57)(math, _config);
-	  __webpack_require__(58)(math, _config);
-	  __webpack_require__(59)(math, _config);
-	  __webpack_require__(60)(math, _config);
-	  __webpack_require__(61)(math, _config);
-	  __webpack_require__(62)(math, _config);
-	  __webpack_require__(63)(math, _config);
-	  __webpack_require__(64)(math, _config);
-	  __webpack_require__(65)(math, _config);
-	  __webpack_require__(66)(math, _config);
-	  __webpack_require__(67)(math, _config);
-	  __webpack_require__(68)(math, _config);
-	  __webpack_require__(69)(math, _config);
-	  __webpack_require__(70)(math, _config);
-	  __webpack_require__(71)(math, _config);
-	  __webpack_require__(72)(math, _config);
-	  __webpack_require__(73)(math, _config);
-	  __webpack_require__(74)(math, _config);
-	  __webpack_require__(75)(math, _config);
-	  __webpack_require__(76)(math, _config);
-
-	  // functions - bitwise
-	  __webpack_require__(77)(math, _config);
-	  __webpack_require__(78)(math, _config);
-	  __webpack_require__(79)(math, _config);
-	  __webpack_require__(80)(math, _config);
-	  __webpack_require__(81)(math, _config);
-	  __webpack_require__(82)(math, _config);
-	  __webpack_require__(83)(math, _config);
-
-	  // functions - complex
-	  __webpack_require__(84)(math, _config);
-	  __webpack_require__(85)(math, _config);
-	  __webpack_require__(86)(math, _config);
-	  __webpack_require__(87)(math, _config);
-
-	  // functions - logical
-	  __webpack_require__(88)(math, _config);
-	  __webpack_require__(89)(math, _config);
-	  __webpack_require__(90)(math, _config);
-	  __webpack_require__(91)(math, _config);
-
-	  // functions - matrix
-	  __webpack_require__(92)(math, _config);
-	  __webpack_require__(93)(math, _config);
-	  __webpack_require__(94)(math, _config);
-	  __webpack_require__(95)(math, _config);
-	  __webpack_require__(96)(math, _config);
-	  __webpack_require__(97)(math, _config);
-	  __webpack_require__(98)(math, _config);
-	  __webpack_require__(99)(math, _config);
-	  __webpack_require__(100)(math, _config);
-	  __webpack_require__(101)(math, _config);
-	  __webpack_require__(102)(math, _config);
-	  __webpack_require__(103)(math, _config);
-	  __webpack_require__(104)(math, _config);
-	  __webpack_require__(105)(math, _config);
-	  __webpack_require__(106)(math, _config);
-	  __webpack_require__(107)(math, _config);
-	  __webpack_require__(108)(math, _config);
-
-	  // functions - probability
-	  //require('./function/probability/distribution')(math, _config); // TODO: rethink math.distribution
-	  __webpack_require__(109)(math, _config);
-	  __webpack_require__(110)(math, _config);
-	  __webpack_require__(111)(math, _config);
-	  __webpack_require__(112)(math, _config);
-	  __webpack_require__(113)(math, _config);
-	  __webpack_require__(114)(math, _config);
-	  __webpack_require__(115)(math, _config);
-
-	  // functions - relational
-	  __webpack_require__(116)(math, _config);
-	  __webpack_require__(117)(math, _config);
-	  __webpack_require__(118)(math, _config);
-	  __webpack_require__(119)(math, _config);
-	  __webpack_require__(120)(math, _config);
-	  __webpack_require__(121)(math, _config);
-	  __webpack_require__(122)(math, _config);
-	  __webpack_require__(123)(math, _config);
-
-	  // functions - statistics
-	  __webpack_require__(124)(math, _config);
-	  __webpack_require__(125)(math, _config);
-	  __webpack_require__(126)(math, _config);
-	  __webpack_require__(127)(math, _config);
-	  __webpack_require__(128)(math, _config);
-	  __webpack_require__(129)(math, _config);
-	  __webpack_require__(130)(math, _config);
-	  __webpack_require__(131)(math, _config);
-
-	  // functions - trigonometry
-	  __webpack_require__(132)(math, _config);
-	  __webpack_require__(133)(math, _config);
-	  __webpack_require__(134)(math, _config);
-	  __webpack_require__(135)(math, _config);
-	  __webpack_require__(136)(math, _config);
-	  __webpack_require__(137)(math, _config);
-	  __webpack_require__(138)(math, _config);
-	  __webpack_require__(139)(math, _config);
-	  __webpack_require__(140)(math, _config);
-	  __webpack_require__(141)(math, _config);
-	  __webpack_require__(142)(math, _config);
-	  __webpack_require__(143)(math, _config);
-	  __webpack_require__(144)(math, _config);
-	  __webpack_require__(145)(math, _config);
-	  __webpack_require__(146)(math, _config);
-	  __webpack_require__(147)(math, _config);
-	  __webpack_require__(148)(math, _config);
-	  __webpack_require__(149)(math, _config);
-	  __webpack_require__(150)(math, _config);
-	  __webpack_require__(151)(math, _config);
-	  __webpack_require__(152)(math, _config);
-	  __webpack_require__(153)(math, _config);
-	  __webpack_require__(154)(math, _config);
-	  __webpack_require__(155)(math, _config);
-	  __webpack_require__(156)(math, _config);
-
-	  // functions - units
-	  __webpack_require__(157)(math, _config);
-
-	  // functions - utils
-	  __webpack_require__(158)(math, _config);
-	  __webpack_require__(159)(math, _config);
-	  __webpack_require__(160)(math, _config);
-	  __webpack_require__(161)(math, _config);
-	  __webpack_require__(162)(math, _config);
-	  __webpack_require__(163)(math, _config);
-	  __webpack_require__(164)(math, _config);
-	  __webpack_require__(165)(math, _config);
-	  __webpack_require__(166)(math, _config);
-
-	  // TODO: deprecated since version 0.25.0, remove some day.
-	  math.ifElse = function () {
-	    throw new Error('Function ifElse is deprecated. Use the conditional operator instead.');
-	  };
-
-	  // constants
-	  __webpack_require__(4)(math, _config);
-
-	  // attach transform functions (for converting one-based indices to zero-based)
-	  math.expression.transform = {
-	    concat: __webpack_require__(23)(math, _config),
-	    filter: __webpack_require__(24)(math, _config),
-	    forEach:__webpack_require__(25)(math, _config),
-	    index:  __webpack_require__(26)(math, _config),
-	    map:    __webpack_require__(27)(math, _config),
-	    max:    __webpack_require__(28)(math, _config),
-	    mean:   __webpack_require__(29)(math, _config),
-	    min:    __webpack_require__(30)(math, _config),
-	    range:  __webpack_require__(31)(math, _config),
-	    subset: __webpack_require__(32)(math, _config)
-	  };
-
-	  // selector (we initialize after all functions are loaded)
-	  math.chaining = {};
-	  math.chaining.Chain = __webpack_require__(33)(math, _config);
-	  math.chaining.Selector = math.chaining.Chain; // TODO: deprecate in v2.0
-
-	  // apply provided configuration options
-	  math.config(_config); // apply the default options
-	  math.config(config);  // apply custom options
-
-	  // return the new instance
+
+	      // append to the cache
+	      factories.push(factory);
+	      instances.push(instance);
+	    }
+	    else {
+	      // already existing function, return the cached instance
+	      instance = instances[index];
+	    }
+
+	    return instance;
+	  }
+
+	  // load the import and config functions
+	  math['import'] = load(importFactory);
+	  math['config'] = load(configFactory);
+
 	  return math;
-	}
-
-	// create a default instance of math.js
-	var math = create();
-
-	if (typeof window !== 'undefined') {
-	  window.mathjs = math; // TODO: deprecate the mathjs namespace some day (replaced with 'math' since version 0.25.0)
-	}
-
-	// export the default instance
-	module.exports = math;
-
+	};
 
 
 /***/ },
-/* 2 */
+/* 3 */
 /***/ function(module, exports, __webpack_require__) {
 
+	var Emitter = __webpack_require__(4);
+
+	/**
+	 * Extend given object with emitter functions `on`, `off`, `once`, `emit`
+	 * @param {Object} obj
+	 * @return {Object} obj
+	 */
+	exports.mixin = function (obj) {
+	  // create event emitter
+	  var emitter = new Emitter();
+
+	  // bind methods to obj (we don't want to expose the emitter.e Array...)
+	  obj.on   = emitter.on.bind(emitter);
+	  obj.off  = emitter.off.bind(emitter);
+	  obj.once = emitter.once.bind(emitter);
+	  obj.emit = emitter.emit.bind(emitter);
+
+	  return obj;
+	};
+
+
+/***/ },
+/* 4 */
+/***/ function(module, exports) {
+
+	function E () {
+		// Keep this empty so it's easier to inherit from
+	  // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3)
+	}
+
+	E.prototype = {
+		on: function (name, callback, ctx) {
+	    var e = this.e || (this.e = {});
+	    
+	    (e[name] || (e[name] = [])).push({
+	      fn: callback,
+	      ctx: ctx
+	    });
+	    
+	    return this;
+	  },
+
+	  once: function (name, callback, ctx) {
+	    var self = this;
+	    var fn = function () {
+	      self.off(name, fn);
+	      callback.apply(ctx, arguments);
+	    };
+	    
+	    return this.on(name, fn, ctx);
+	  },
+
+	  emit: function (name) {
+	    var data = [].slice.call(arguments, 1);
+	    var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
+	    var i = 0;
+	    var len = evtArr.length;
+	    
+	    for (i; i < len; i++) {
+	      evtArr[i].fn.apply(evtArr[i].ctx, data);
+	    }
+	    
+	    return this;
+	  },
+
+	  off: function (name, callback) {
+	    var e = this.e || (this.e = {});
+	    var evts = e[name];
+	    var liveEvents = [];
+	    
+	    if (evts && callback) {
+	      for (var i = 0, len = evts.length; i < len; i++) {
+	        if (evts[i].fn !== callback) liveEvents.push(evts[i]);
+	      }
+	    }
+	    
+	    // Remove event from queue to prevent memory leak
+	    // Suggested by https://github.com/lazd
+	    // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910
+
+	    (liveEvents.length) 
+	      ? e[name] = liveEvents
+	      : delete e[name];
+	    
+	    return this;
+	  }
+	};
+
+	module.exports = E;
+
+
+/***/ },
+/* 5 */
+/***/ function(module, exports) {
+
 	'use strict';
 
 	/**
@@ -546,10 +392,11 @@
 	    });
 	  }
 
-	  if (x instanceof Number)  return new Number(x.valueOf());
-	  if (x instanceof String)  return new String(x.valueOf());
-	  if (x instanceof Boolean) return new Boolean(x.valueOf());
-	  if (x instanceof Date)    return new Date(x.valueOf());
+	  if (x instanceof Number)    return new Number(x.valueOf());
+	  if (x instanceof String)    return new String(x.valueOf());
+	  if (x instanceof Boolean)   return new Boolean(x.valueOf());
+	  if (x instanceof Date)      return new Date(x.valueOf());
+	  if (x && x.isBigNumber === true) return x; // bignumbers are immutable
 	  if (x instanceof RegExp)  throw new TypeError('Cannot clone ' + x);  // TODO: clone a RegExp
 
 	  // object
@@ -667,7 +514,7 @@
 	  // test needed for broken IE8 implementation
 	  try {
 	    if (Object.defineProperty) {
-	      Object.defineProperty({}, 'x', {});
+	      Object.defineProperty({}, 'x', { get: function () {} });
 	      return true;
 	    }
 	  } catch (e) {}
@@ -682,7 +529,7 @@
 	 * of the properties value.
 	 * @param {Object} object   Object where to add the property
 	 * @param {string} prop     Property name
-	 * @param {function} fn     Function returning the property value. Called
+	 * @param {Function} fn     Function returning the property value. Called
 	 *                          without arguments.
 	 */
 	exports.lazy = function (object, prop, fn) {
@@ -701,7 +548,10 @@
 	      set: function (value) {
 	        _value = value;
 	        _uninitialized = false;
-	      }
+	      },
+
+	      configurable: true,
+	      enumerable: true
 	    });
 	  }
 	  else {
@@ -710,37 +560,1553 @@
 	  }
 	};
 
-
-/***/ },
-/* 3 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	var NumberFormatter = __webpack_require__(167);
-
-	/**
-	 * Test whether value is a Number
+	/**
+	 * Traverse a path into an object.
+	 * When a namespace is missing, it will be created
+	 * @param {Object} object
+	 * @param {string} path   A dot separated string like 'name.space'
+	 * @return {Object} Returns the object at the end of the path
+	 */
+	exports.traverse = function(object, path) {
+	  var obj = object;
+
+	  if (path) {
+	    var names = path.split('.');
+	    for (var i = 0; i < names.length; i++) {
+	      var name = names[i];
+	      if (!(name in obj)) {
+	        obj[name] = {};
+	      }
+	      obj = obj[name];
+	    }
+	  }
+
+	  return obj;
+	};
+
+	/**
+	 * Test whether an object is a factory. a factory has fields:
+	 *
+	 * - factory: function (type: Object, config: Object, load: function, typed: function [, math: Object])   (required)
+	 * - name: string (optional)
+	 * - path: string    A dot separated path (optional)
+	 * - math: boolean   If true (false by default), the math namespace is passed
+	 *                   as fifth argument of the factory function
+	 *
+	 * @param {*} object
+	 * @returns {boolean}
+	 */
+	exports.isFactory = function (object) {
+	  return object && typeof object.factory === 'function';
+	};
+
+
+/***/ },
+/* 6 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var typedFunction = __webpack_require__(7);
+	var digits = __webpack_require__(8).digits;
+
+	// returns a new instance of typed-function
+	var createTyped = function () {
+	  // initially, return the original instance of typed-function
+	  // consecutively, return a new instance from typed.create.
+	  createTyped = typedFunction.create;
+	  return typedFunction;
+	};
+
+	/**
+	 * Factory function for creating a new typed instance
+	 * @param {Object} type   Object with data types like Complex and BigNumber
+	 * @returns {Function}
+	 */
+	exports.create = function create(type) {
+	  // TODO: typed-function must be able to silently ignore signatures with unknown data types
+
+	  // get a new instance of typed-function
+	  var typed = createTyped();
+
+	  // define all types. The order of the types determines in which order function
+	  // arguments are type-checked (so for performance it's important to put the
+	  // most used types first).
+	  typed.types = [
+	    { name: 'number',               test: function (x) { return typeof x === 'number'; } },
+	    { name: 'Complex',              test: function (x) { return x && x.isComplex; } },
+	    { name: 'BigNumber',            test: function (x) { return x && x.isBigNumber; } },
+	    { name: 'Fraction',             test: function (x) { return x && x.isFraction; } },
+	    { name: 'Unit',                 test: function (x) { return x && x.isUnit; } },
+	    { name: 'string',               test: function (x) { return typeof x === 'string'; } },
+	    { name: 'Array',                test: Array.isArray },
+	    { name: 'Matrix',               test: function (x) { return x && x.isMatrix; } },
+	    { name: 'DenseMatrix',          test: function (x) { return x && x.isDenseMatrix; } },
+	    { name: 'SparseMatrix',         test: function (x) { return x && x.isSparseMatrix; } },
+	    { name: 'ImmutableDenseMatrix', test: function (x) { return x && x.isImmutableDenseMatrix; } },
+	    { name: 'Range',                test: function (x) { return x && x.isRange; } },
+	    { name: 'Index',                test: function (x) { return x && x.isIndex; } },
+	    { name: 'boolean',              test: function (x) { return typeof x === 'boolean'; } },
+	    { name: 'ResultSet',            test: function (x) { return x && x.isResultSet; } },
+	    { name: 'Help',                 test: function (x) { return x && x.isHelp; } },
+	    { name: 'function',             test: function (x) { return typeof x === 'function';} },
+	    { name: 'Date',                 test: function (x) { return x instanceof Date; } },
+	    { name: 'RegExp',               test: function (x) { return x instanceof RegExp; } },
+	    { name: 'Object',               test: function (x) { return typeof x === 'object'; } },
+	    { name: 'null',                 test: function (x) { return x === null; } },
+	    { name: 'undefined',            test: function (x) { return x === undefined; } }
+	  ];
+
+	  // TODO: add conversion from BigNumber to number?
+	  typed.conversions = [
+	    {
+	      from: 'number',
+	      to: 'BigNumber',
+	      convert: function (x) {
+	        // note: conversion from number to BigNumber can fail if x has >15 digits
+	        if (digits(x) > 15) {
+	          throw new TypeError('Cannot implicitly convert a number with >15 significant digits to BigNumber ' +
+	          '(value: ' + x + '). ' +
+	          'Use function bignumber(x) to convert to BigNumber.');
+	        }
+	        return new type.BigNumber(x);
+	      }
+	    }, {
+	      from: 'number',
+	      to: 'Complex',
+	      convert: function (x) {
+	        return new type.Complex(x, 0);
+	      }
+	    }, {
+	      from: 'number',
+	      to: 'string',
+	      convert: function (x) {
+	        return x + '';
+	      }
+	    }, {
+	      from: 'BigNumber',
+	      to: 'Complex',
+	      convert: function (x) {
+	        return new type.Complex(x.toNumber(), 0);
+	      }
+	    }, {
+	      from: 'number',
+	      to: 'Fraction',
+	      convert: function (x) {
+	        if (digits(x) > 15) {
+	          throw new TypeError('Cannot implicitly convert a number with >15 significant digits to Fraction ' +
+	              '(value: ' + x + '). ' +
+	              'Use function fraction(x) to convert to Fraction.');
+	        }
+	        return new type.Fraction(x);
+	      }
+	    }, {
+	      from: 'string',
+	      to: 'number',
+	      convert: function (x) {
+	        var n = Number(x);
+	        if (isNaN(n)) {
+	          throw new Error('Cannot convert "' + x + '" to a number');
+	        }
+	        return n;
+	      }
+	    }, {
+	      from: 'boolean',
+	      to: 'number',
+	      convert: function (x) {
+	        return +x;
+	      }
+	    }, {
+	      from: 'boolean',
+	      to: 'BigNumber',
+	      convert: function (x) {
+	        return new type.BigNumber(+x);
+	      }
+	    }, {
+	      from: 'boolean',
+	      to: 'string',
+	      convert: function (x) {
+	        return +x;
+	      }
+	    }, {
+	      from: 'null',
+	      to: 'number',
+	      convert: function () {
+	        return 0;
+	      }
+	    }, {
+	      from: 'null',
+	      to: 'string',
+	      convert: function () {
+	        return 'null';
+	      }
+	    }, {
+	      from: 'null',
+	      to: 'BigNumber',
+	      convert: function () {
+	        return new type.BigNumber(0);
+	      }
+	    }, {
+	      from: 'Array',
+	      to: 'Matrix',
+	      convert: function (array) {
+	        // TODO: how to decide on the right type of matrix to create?
+	        return new type.DenseMatrix(array);
+	      }
+	    }, {
+	      from: 'Matrix',
+	      to: 'Array',
+	      convert: function (matrix) {
+	        return matrix.valueOf();
+	      }
+	    }
+	  ];
+
+	  return typed;
+	};
+
+
+/***/ },
+/* 7 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/**
+	 * typed-function
+	 *
+	 * Type checking for JavaScript functions
+	 *
+	 * https://github.com/josdejong/typed-function
+	 */
+	'use strict';
+
+	(function (factory) {
+	  if (true) {
+	    // AMD. Register as an anonymous module.
+	    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+	  } else if (typeof exports === 'object') {
+	    // OldNode. Does not work with strict CommonJS, but
+	    // only CommonJS-like environments that support module.exports,
+	    // like OldNode.
+	    module.exports = factory();
+	  } else {
+	    // Browser globals (root is window)
+	    window.typed = factory();
+	  }
+	}(function () {
+	  // factory function to create a new instance of typed-function
+	  // TODO: allow passing configuration, types, tests via the factory function
+	  function create() {
+	    /**
+	     * Get a type test function for a specific data type
+	     * @param {string} name                   Name of a data type like 'number' or 'string'
+	     * @returns {Function(obj: *) : boolean}  Returns a type testing function.
+	     *                                        Throws an error for an unknown type.
+	     */
+	    function getTypeTest(name) {
+	      var test;
+	      for (var i = 0; i < typed.types.length; i++) {
+	        var entry = typed.types[i];
+	        if (entry.name === name) {
+	          test = entry.test;
+	          break;
+	        }
+	      }
+
+	      if (!test) {
+	        var hint;
+	        for (i = 0; i < typed.types.length; i++) {
+	          entry = typed.types[i];
+	          if (entry.name.toLowerCase() == name.toLowerCase()) {
+	            hint = entry.name;
+	            break;
+	          }
+	        }
+
+	        throw new Error('Unknown type "' + name + '"' +
+	            (hint ? ('. Did you mean "' + hint + '"?') : ''));
+	      }
+	      return test;
+	    }
+
+	    /**
+	     * Retrieve the function name from a set of functions, and check
+	     * whether the name of all functions match (if given)
+	     * @param {Array.<function>} fns
+	     */
+	    function getName (fns) {
+	      var name = '';
+
+	      for (var i = 0; i < fns.length; i++) {
+	        var fn = fns[i];
+
+	        // merge function name
+	        if (fn.name != '') {
+	          if (name == '') {
+	            name = fn.name;
+	          }
+	          else if (name != fn.name) {
+	            var err = new Error('Function names do not match (expected: ' + name + ', actual: ' + fn.name + ')');
+	            err.data = {
+	              actual: fn.name,
+	              expected: name
+	            };
+	            throw err;
+	          }
+	        }
+	      }
+
+	      return name;
+	    }
+
+	    /**
+	     * Create an ArgumentsError. Creates messages like:
+	     *
+	     *   Unexpected type of argument (expected: ..., actual: ..., index: ...)
+	     *   Too few arguments (expected: ..., index: ...)
+	     *   Too many arguments (expected: ..., actual: ...)
+	     *
+	     * @param {String} fn         Function name
+	     * @param {number} argCount   Number of arguments
+	     * @param {Number} index      Current argument index
+	     * @param {*} actual          Current argument
+	     * @param {string} [expected] An optional, comma separated string with
+	     *                            expected types on given index
+	     * @extends Error
+	     */
+	    function createError(fn, argCount, index, actual, expected) {
+	      var actualType = getTypeOf(actual);
+	      var _expected = expected ? expected.split(',') : null;
+	      var _fn = (fn || 'unnamed');
+	      var anyType = _expected && contains(_expected, 'any');
+	      var message;
+	      var data = {
+	        fn: fn,
+	        index: index,
+	        actual: actual,
+	        expected: _expected
+	      };
+
+	      if (_expected) {
+	        if (argCount > index && !anyType) {
+	          // unexpected type
+	          message = 'Unexpected type of argument in function ' + _fn +
+	              ' (expected: ' + _expected.join(' or ') + ', actual: ' + actualType + ', index: ' + index + ')';
+	        }
+	        else {
+	          // too few arguments
+	          message = 'Too few arguments in function ' + _fn +
+	              ' (expected: ' + _expected.join(' or ') + ', index: ' + index + ')';
+	        }
+	      }
+	      else {
+	        // too many arguments
+	        message = 'Too many arguments in function ' + _fn +
+	            ' (expected: ' + index + ', actual: ' + argCount + ')'
+	      }
+
+	      var err = new TypeError(message);
+	      err.data = data;
+	      return err;
+	    }
+
+	    /**
+	     * Collection with function references (local shortcuts to functions)
+	     * @constructor
+	     * @param {string} [name='refs']  Optional name for the refs, used to generate
+	     *                                JavaScript code
+	     */
+	    function Refs(name) {
+	      this.name = name || 'refs';
+	      this.categories = {};
+	    }
+
+	    /**
+	     * Add a function reference.
+	     * @param {Function} fn
+	     * @param {string} [category='fn']    A function category, like 'fn' or 'signature'
+	     * @returns {string} Returns the function name, for example 'fn0' or 'signature2'
+	     */
+	    Refs.prototype.add = function (fn, category) {
+	      var cat = category || 'fn';
+	      if (!this.categories[cat]) this.categories[cat] = [];
+
+	      var index = this.categories[cat].indexOf(fn);
+	      if (index == -1) {
+	        index = this.categories[cat].length;
+	        this.categories[cat].push(fn);
+	      }
+
+	      return cat + index;
+	    };
+
+	    /**
+	     * Create code lines for all function references
+	     * @returns {string} Returns the code containing all function references
+	     */
+	    Refs.prototype.toCode = function () {
+	      var code = [];
+	      var path = this.name + '.categories';
+	      var categories = this.categories;
+
+	      for (var cat in categories) {
+	        if (categories.hasOwnProperty(cat)) {
+	          var category = categories[cat];
+
+	          for (var i = 0; i < category.length; i++) {
+	            code.push('var ' + cat + i + ' = ' + path + '[\'' + cat + '\'][' + i + '];');
+	          }
+	        }
+	      }
+
+	      return code.join('\n');
+	    };
+
+	    /**
+	     * A function parameter
+	     * @param {string | string[] | Param} types    A parameter type like 'string',
+	     *                                             'number | boolean'
+	     * @param {boolean} [varArgs=false]            Variable arguments if true
+	     * @constructor
+	     */
+	    function Param(types, varArgs) {
+	      // parse the types, can be a string with types separated by pipe characters |
+	      if (typeof types === 'string') {
+	        // parse variable arguments operator (ellipses '...number')
+	        var _types = types.trim();
+	        var _varArgs = _types.substr(0, 3) === '...';
+	        if (_varArgs) {
+	          _types = _types.substr(3);
+	        }
+	        if (_types === '') {
+	          this.types = ['any'];
+	        }
+	        else {
+	          this.types = _types.split('|');
+	          for (var i = 0; i < this.types.length; i++) {
+	            this.types[i] = this.types[i].trim();
+	          }
+	        }
+	      }
+	      else if (Array.isArray(types)) {
+	        this.types = types;
+	      }
+	      else if (types instanceof Param) {
+	        return types.clone();
+	      }
+	      else {
+	        throw new Error('String or Array expected');
+	      }
+
+	      // can hold a type to which to convert when handling this parameter
+	      this.conversions = [];
+	      // TODO: implement better API for conversions, be able to add conversions via constructor (support a new type Object?)
+
+	      // variable arguments
+	      this.varArgs = _varArgs || varArgs || false;
+
+	      // check for any type arguments
+	      this.anyType = this.types.indexOf('any') !== -1;
+	    }
+
+	    /**
+	     * Order Params
+	     * any type ('any') will be ordered last, and object as second last (as other
+	     * types may be an object as well, like Array).
+	     *
+	     * @param {Param} a
+	     * @param {Param} b
+	     * @returns {number} Returns 1 if a > b, -1 if a < b, and else 0.
+	     */
+	    Param.compare = function (a, b) {
+	      // TODO: simplify parameter comparison, it's a mess
+	      if (a.anyType) return 1;
+	      if (b.anyType) return -1;
+
+	      if (contains(a.types, 'Object')) return 1;
+	      if (contains(b.types, 'Object')) return -1;
+
+	      if (a.hasConversions()) {
+	        if (b.hasConversions()) {
+	          var i, ac, bc;
+
+	          for (i = 0; i < a.conversions.length; i++) {
+	            if (a.conversions[i] !== undefined) {
+	              ac = a.conversions[i];
+	              break;
+	            }
+	          }
+
+	          for (i = 0; i < b.conversions.length; i++) {
+	            if (b.conversions[i] !== undefined) {
+	              bc = b.conversions[i];
+	              break;
+	            }
+	          }
+
+	          return typed.conversions.indexOf(ac) - typed.conversions.indexOf(bc);
+	        }
+	        else {
+	          return 1;
+	        }
+	      }
+	      else {
+	        if (b.hasConversions()) {
+	          return -1;
+	        }
+	        else {
+	          // both params have no conversions
+	          var ai, bi;
+
+	          for (i = 0; i < typed.types.length; i++) {
+	            if (typed.types[i].name === a.types[0]) {
+	              ai = i;
+	              break;
+	            }
+	          }
+
+	          for (i = 0; i < typed.types.length; i++) {
+	            if (typed.types[i].name === b.types[0]) {
+	              bi = i;
+	              break;
+	            }
+	          }
+
+	          return ai - bi;
+	        }
+	      }
+	    };
+
+	    /**
+	     * Test whether this parameters types overlap an other parameters types.
+	     * @param {Param} other
+	     * @return {boolean} Returns true when there are conflicting types
+	     */
+	    Param.prototype.overlapping = function (other) {
+	      for (var i = 0; i < this.types.length; i++) {
+	        if (contains(other.types, this.types[i])) {
+	          return true;
+	        }
+	      }
+	      return false;
+	    };
+
+	    /**
+	     * Create a clone of this param
+	     * @returns {Param} Returns a cloned version of this param
+	     */
+	    Param.prototype.clone = function () {
+	      var param = new Param(this.types.slice(), this.varArgs);
+	      param.conversions = this.conversions.slice();
+	      return param;
+	    };
+
+	    /**
+	     * Test whether this parameter contains conversions
+	     * @returns {boolean} Returns true if the parameter contains one or
+	     *                    multiple conversions.
+	     */
+	    Param.prototype.hasConversions = function () {
+	      return this.conversions.length > 0;
+	    };
+
+	    /**
+	     * Tests whether this parameters contains any of the provided types
+	     * @param {Object} types  A Map with types, like {'number': true}
+	     * @returns {boolean}     Returns true when the parameter contains any
+	     *                        of the provided types
+	     */
+	    Param.prototype.contains = function (types) {
+	      for (var i = 0; i < this.types.length; i++) {
+	        if (types[this.types[i]]) {
+	          return true;
+	        }
+	      }
+	      return false;
+	    };
+
+	    /**
+	     * Return a string representation of this params types, like 'string' or
+	     * 'number | boolean' or '...number'
+	     * @param {boolean} [toConversion]   If true, the returned types string
+	     *                                   contains the types where the parameter
+	     *                                   will convert to. If false (default)
+	     *                                   the "from" types are returned
+	     * @returns {string}
+	     */
+	    Param.prototype.toString = function (toConversion) {
+	      var types = [];
+	      var keys = {};
+
+	      for (var i = 0; i < this.types.length; i++) {
+	        var conversion = this.conversions[i];
+	        var type = toConversion && conversion ? conversion.to : this.types[i];
+	        if (!(type in keys)) {
+	          keys[type] = true;
+	          types.push(type);
+	        }
+	      }
+
+	      return (this.varArgs ? '...' : '') + types.join('|');
+	    };
+
+	    /**
+	     * A function signature
+	     * @param {string | string[] | Param[]} params
+	     *                         Array with the type(s) of each parameter,
+	     *                         or a comma separated string with types
+	     * @param {Function} fn    The actual function
+	     * @constructor
+	     */
+	    function Signature(params, fn) {
+	      var _params;
+	      if (typeof params === 'string') {
+	        _params = (params !== '') ? params.split(',') : [];
+	      }
+	      else if (Array.isArray(params)) {
+	        _params = params;
+	      }
+	      else {
+	        throw new Error('string or Array expected');
+	      }
+
+	      this.params = new Array(_params.length);
+	      for (var i = 0; i < _params.length; i++) {
+	        var param = new Param(_params[i]);
+	        this.params[i] = param;
+	        if (i === _params.length - 1) {
+	          // the last argument
+	          this.varArgs = param.varArgs;
+	        }
+	        else {
+	          // non-last argument
+	          if (param.varArgs) {
+	            throw new SyntaxError('Unexpected variable arguments operator "..."');
+	          }
+	        }
+	      }
+
+	      this.fn = fn;
+	    }
+
+	    /**
+	     * Create a clone of this signature
+	     * @returns {Signature} Returns a cloned version of this signature
+	     */
+	    Signature.prototype.clone = function () {
+	      return new Signature(this.params.slice(), this.fn);
+	    };
+
+	    /**
+	     * Expand a signature: split params with union types in separate signatures
+	     * For example split a Signature "string | number" into two signatures.
+	     * @return {Signature[]} Returns an array with signatures (at least one)
+	     */
+	    Signature.prototype.expand = function () {
+	      var signatures = [];
+
+	      function recurse(signature, path) {
+	        if (path.length < signature.params.length) {
+	          var i, newParam, conversion;
+
+	          var param = signature.params[path.length];
+	          if (param.varArgs) {
+	            // a variable argument. do not split the types in the parameter
+	            newParam = param.clone();
+
+	            // add conversions to the parameter
+	            // recurse for all conversions
+	            for (i = 0; i < typed.conversions.length; i++) {
+	              conversion = typed.conversions[i];
+	              if (!contains(param.types, conversion.from) && contains(param.types, conversion.to)) {
+	                var j = newParam.types.length;
+	                newParam.types[j] = conversion.from;
+	                newParam.conversions[j] = conversion;
+	              }
+	            }
+
+	            recurse(signature, path.concat(newParam));
+	          }
+	          else {
+	            // split each type in the parameter
+	            for (i = 0; i < param.types.length; i++) {
+	              recurse(signature, path.concat(new Param(param.types[i])));
+	            }
+
+	            // recurse for all conversions
+	            for (i = 0; i < typed.conversions.length; i++) {
+	              conversion = typed.conversions[i];
+	              if (!contains(param.types, conversion.from) && contains(param.types, conversion.to)) {
+	                newParam = new Param(conversion.from);
+	                newParam.conversions[0] = conversion;
+	                recurse(signature, path.concat(newParam));
+	              }
+	            }
+	          }
+	        }
+	        else {
+	          signatures.push(new Signature(path, signature.fn));
+	        }
+	      }
+
+	      recurse(this, []);
+
+	      return signatures;
+	    };
+
+	    /**
+	     * Compare two signatures.
+	     *
+	     * When two params are equal and contain conversions, they will be sorted
+	     * by lowest index of the first conversions.
+	     *
+	     * @param {Signature} a
+	     * @param {Signature} b
+	     * @returns {number} Returns 1 if a > b, -1 if a < b, and else 0.
+	     */
+	    Signature.compare = function (a, b) {
+	      if (a.params.length > b.params.length) return 1;
+	      if (a.params.length < b.params.length) return -1;
+
+	      // count the number of conversions
+	      var i;
+	      var len = a.params.length; // a and b have equal amount of params
+	      var ac = 0;
+	      var bc = 0;
+	      for (i = 0; i < len; i++) {
+	        if (a.params[i].hasConversions()) ac++;
+	        if (b.params[i].hasConversions()) bc++;
+	      }
+
+	      if (ac > bc) return 1;
+	      if (ac < bc) return -1;
+
+	      // compare the order per parameter
+	      for (i = 0; i < a.params.length; i++) {
+	        var cmp = Param.compare(a.params[i], b.params[i]);
+	        if (cmp !== 0) {
+	          return cmp;
+	        }
+	      }
+
+	      return 0;
+	    };
+
+	    /**
+	     * Test whether any of the signatures parameters has conversions
+	     * @return {boolean} Returns true when any of the parameters contains
+	     *                   conversions.
+	     */
+	    Signature.prototype.hasConversions = function () {
+	      for (var i = 0; i < this.params.length; i++) {
+	        if (this.params[i].hasConversions()) {
+	          return true;
+	        }
+	      }
+	      return false;
+	    };
+
+	    /**
+	     * Test whether this signature should be ignored.
+	     * Checks whether any of the parameters contains a type listed in
+	     * typed.ignore
+	     * @return {boolean} Returns true when the signature should be ignored
+	     */
+	    Signature.prototype.ignore = function () {
+	      // create a map with ignored types
+	      var types = {};
+	      for (var i = 0; i < typed.ignore.length; i++) {
+	        types[typed.ignore[i]] = true;
+	      }
+
+	      // test whether any of the parameters contains this type
+	      for (i = 0; i < this.params.length; i++) {
+	        if (this.params[i].contains(types)) {
+	          return true;
+	        }
+	      }
+
+	      return false;
+	    };
+
+	    /**
+	     * Generate the code to invoke this signature
+	     * @param {Refs} refs
+	     * @param {string} prefix
+	     * @returns {string} Returns code
+	     */
+	    Signature.prototype.toCode = function (refs, prefix) {
+	      var code = [];
+
+	      var args = new Array(this.params.length);
+	      for (var i = 0; i < this.params.length; i++) {
+	        var param = this.params[i];
+	        var conversion = param.conversions[0];
+	        if (param.varArgs) {
+	          args[i] = 'varArgs';
+	        }
+	        else if (conversion) {
+	          args[i] = refs.add(conversion.convert, 'convert') + '(arg' + i + ')';
+	        }
+	        else {
+	          args[i] = 'arg' + i;
+	        }
+	      }
+
+	      var ref = this.fn ? refs.add(this.fn, 'signature') : undefined;
+	      if (ref) {
+	        return prefix + 'return ' + ref + '(' + args.join(', ') + '); // signature: ' + this.params.join(', ');
+	      }
+
+	      return code.join('\n');
+	    };
+
+	    /**
+	     * Return a string representation of the signature
+	     * @returns {string}
+	     */
+	    Signature.prototype.toString = function () {
+	      return this.params.join(', ');
+	    };
+
+	    /**
+	     * A group of signatures with the same parameter on given index
+	     * @param {Param[]} path
+	     * @param {Signature} [signature]
+	     * @param {Node[]} childs
+	     * @constructor
+	     */
+	    function Node(path, signature, childs) {
+	      this.path = path || [];
+	      this.param = path[path.length - 1] || null;
+	      this.signature = signature || null;
+	      this.childs = childs || [];
+	    }
+
+	    /**
+	     * Generate code for this group of signatures
+	     * @param {Refs} refs
+	     * @param {string} prefix
+	     * @param {Node | undefined} [anyType]  Sibling of this node with any type parameter
+	     * @returns {string} Returns the code as string
+	     */
+	    Node.prototype.toCode = function (refs, prefix, anyType) {
+	      // TODO: split this function in multiple functions, it's too large
+	      var code = [];
+
+	      if (this.param) {
+	        var index = this.path.length - 1;
+	        var conversion = this.param.conversions[0];
+	        var comment = '// type: ' + (conversion ?
+	                (conversion.from + ' (convert to ' + conversion.to + ')') :
+	                this.param);
+
+	        // non-root node (path is non-empty)
+	        if (this.param.varArgs) {
+	          if (this.param.anyType) {
+	            // variable arguments with any type
+	            code.push(prefix + 'if (arguments.length > ' + index + ') {');
+	            code.push(prefix + '  var varArgs = [];');
+	            code.push(prefix + '  for (var i = ' + index + '; i < arguments.length; i++) {');
+	            code.push(prefix + '    varArgs.push(arguments[i]);');
+	            code.push(prefix + '  }');
+	            code.push(this.signature.toCode(refs, prefix + '  '));
+	            code.push(prefix + '}');
+	          }
+	          else {
+	            // variable arguments with a fixed type
+	            var getTests = function (types, arg) {
+	              var tests = [];
+	              for (var i = 0; i < types.length; i++) {
+	                tests[i] = refs.add(getTypeTest(types[i]), 'test') + '(' + arg + ')';
+	              }
+	              return tests.join(' || ');
+	            }.bind(this);
+
+	            var allTypes = this.param.types;
+	            var exactTypes = [];
+	            for (var i = 0; i < allTypes.length; i++) {
+	              if (this.param.conversions[i] === undefined) {
+	                exactTypes.push(allTypes[i]);
+	              }
+	            }
+
+	            code.push(prefix + 'if (' + getTests(allTypes, 'arg' + index) + ') { ' + comment);
+	            code.push(prefix + '  var varArgs = [arg' + index + '];');
+	            code.push(prefix + '  for (var i = ' + (index + 1) + '; i < arguments.length; i++) {');
+	            code.push(prefix + '    if (' + getTests(exactTypes, 'arguments[i]') + ') {');
+	            code.push(prefix + '      varArgs.push(arguments[i]);');
+
+	            for (var i = 0; i < allTypes.length; i++) {
+	              var conversion_i = this.param.conversions[i];
+	              if (conversion_i) {
+	                var test = refs.add(getTypeTest(allTypes[i]), 'test');
+	                var convert = refs.add(conversion_i.convert, 'convert');
+	                code.push(prefix + '    }');
+	                code.push(prefix + '    else if (' + test + '(arguments[i])) {');
+	                code.push(prefix + '      varArgs.push(' + convert + '(arguments[i]));');
+	              }
+	            }
+	            code.push(prefix + '    } else {');
+	            code.push(prefix + '      throw createError(name, arguments.length, i, arguments[i], \'' + exactTypes.join(',') + '\');');
+	            code.push(prefix + '    }');
+	            code.push(prefix + '  }');
+	            code.push(this.signature.toCode(refs, prefix + '  '));
+	            code.push(prefix + '}');
+	          }
+	        }
+	        else {
+	          if (this.param.anyType) {
+	            // any type
+	            code.push(prefix + '// type: any');
+	            code.push(this._innerCode(refs, prefix, anyType));
+	          }
+	          else {
+	            // regular type
+	            var type = this.param.types[0];
+	            var test = type !== 'any' ? refs.add(getTypeTest(type), 'test') : null;
+
+	            code.push(prefix + 'if (' + test + '(arg' + index + ')) { ' + comment);
+	            code.push(this._innerCode(refs, prefix + '  ', anyType));
+	            code.push(prefix + '}');
+	          }
+	        }
+	      }
+	      else {
+	        // root node (path is empty)
+	        code.push(this._innerCode(refs, prefix, anyType));
+	      }
+
+	      return code.join('\n');
+	    };
+
+	    /**
+	     * Generate inner code for this group of signatures.
+	     * This is a helper function of Node.prototype.toCode
+	     * @param {Refs} refs
+	     * @param {string} prefix
+	     * @param {Node | undefined} [anyType]  Sibling of this node with any type parameter
+	     * @returns {string} Returns the inner code as string
+	     * @private
+	     */
+	    Node.prototype._innerCode = function (refs, prefix, anyType) {
+	      var code = [];
+	      var i;
+
+	      if (this.signature) {
+	        code.push(prefix + 'if (arguments.length === ' + this.path.length + ') {');
+	        code.push(this.signature.toCode(refs, prefix + '  '));
+	        code.push(prefix + '}');
+	      }
+
+	      var nextAnyType;
+	      for (i = 0; i < this.childs.length; i++) {
+	        if (this.childs[i].param.anyType) {
+	          nextAnyType = this.childs[i];
+	          break;
+	        }
+	      }
+
+	      for (i = 0; i < this.childs.length; i++) {
+	        code.push(this.childs[i].toCode(refs, prefix, nextAnyType));
+	      }
+
+	      if (anyType && !this.param.anyType) {
+	        code.push(anyType.toCode(refs, prefix, nextAnyType));
+	      }
+
+	      var exceptions = this._exceptions(refs, prefix);
+	      if (exceptions) {
+	        code.push(exceptions);
+	      }
+
+	      return code.join('\n');
+	    };
+
+	    /**
+	     * Generate code to throw exceptions
+	     * @param {Refs} refs
+	     * @param {string} prefix
+	     * @returns {string} Returns the inner code as string
+	     * @private
+	     */
+	    Node.prototype._exceptions = function (refs, prefix) {
+	      var index = this.path.length;
+
+	      if (this.childs.length === 0) {
+	        // TODO: can this condition be simplified? (we have a fall-through here)
+	        return [
+	          prefix + 'if (arguments.length > ' + index + ') {',
+	          prefix + '  throw createError(name, arguments.length, ' + index + ', arguments[' + index + ']);',
+	          prefix + '}'
+	        ].join('\n');
+	      }
+	      else {
+	        var keys = {};
+	        var types = [];
+
+	        for (var i = 0; i < this.childs.length; i++) {
+	          var node = this.childs[i];
+	          if (node.param) {
+	            for (var j = 0; j < node.param.types.length; j++) {
+	              var type = node.param.types[j];
+	              if (!(type in keys) && !node.param.conversions[j]) {
+	                keys[type] = true;
+	                types.push(type);
+	              }
+	            }
+	          }
+	        }
+
+	        return prefix + 'throw createError(name, arguments.length, ' + index + ', arguments[' + index + '], \'' + types.join(',') + '\');';
+	      }
+	    };
+
+	    /**
+	     * Split all raw signatures into an array with expanded Signatures
+	     * @param {Object.<string, Function>} rawSignatures
+	     * @return {Signature[]} Returns an array with expanded signatures
+	     */
+	    function parseSignatures(rawSignatures) {
+	      // FIXME: need to have deterministic ordering of signatures, do not create via object
+	      var signature;
+	      var keys = {};
+	      var signatures = [];
+	      var i;
+
+	      for (var types in rawSignatures) {
+	        if (rawSignatures.hasOwnProperty(types)) {
+	          var fn = rawSignatures[types];
+	          signature = new Signature(types, fn);
+
+	          if (signature.ignore()) {
+	            continue;
+	          }
+
+	          var expanded = signature.expand();
+
+	          for (i = 0; i < expanded.length; i++) {
+	            var signature_i = expanded[i];
+	            var key = signature_i.toString();
+	            var existing = keys[key];
+	            if (!existing) {
+	              keys[key] = signature_i;
+	            }
+	            else {
+	              var cmp = Signature.compare(signature_i, existing);
+	              if (cmp < 0) {
+	                // override if sorted first
+	                keys[key] = signature_i;
+	              }
+	              else if (cmp === 0) {
+	                throw new Error('Signature "' + key + '" is defined twice');
+	              }
+	              // else: just ignore
+	            }
+	          }
+	        }
+	      }
+
+	      // convert from map to array
+	      for (key in keys) {
+	        if (keys.hasOwnProperty(key)) {
+	          signatures.push(keys[key]);
+	        }
+	      }
+
+	      // order the signatures
+	      signatures.sort(function (a, b) {
+	        return Signature.compare(a, b);
+	      });
+
+	      // filter redundant conversions from signatures with varArgs
+	      // TODO: simplify this loop or move it to a separate function
+	      for (i = 0; i < signatures.length; i++) {
+	        signature = signatures[i];
+
+	        if (signature.varArgs) {
+	          var index = signature.params.length - 1;
+	          var param = signature.params[index];
+
+	          var t = 0;
+	          while (t < param.types.length) {
+	            if (param.conversions[t]) {
+	              var type = param.types[t];
+
+	              for (var j = 0; j < signatures.length; j++) {
+	                var other = signatures[j];
+	                var p = other.params[index];
+
+	                if (other !== signature &&
+	                    p &&
+	                    contains(p.types, type) && !p.conversions[index]) {
+	                  // this (conversion) type already exists, remove it
+	                  param.types.splice(t, 1);
+	                  param.conversions.splice(t, 1);
+	                  t--;
+	                  break;
+	                }
+	              }
+	            }
+	            t++;
+	          }
+	        }
+	      }
+
+	      return signatures;
+	    }
+
+	    /**
+	     * create a map with normalized signatures as key and the function as value
+	     * @param {Signature[]} signatures   An array with split signatures
+	     * @return {Object.<string, Function>} Returns a map with normalized
+	     *                                     signatures as key, and the function
+	     *                                     as value.
+	     */
+	    function mapSignatures(signatures) {
+	      var normalized = {};
+
+	      for (var i = 0; i < signatures.length; i++) {
+	        var signature = signatures[i];
+	        if (signature.fn && !signature.hasConversions()) {
+	          var params = signature.params.join(',');
+	          normalized[params] = signature.fn;
+	        }
+	      }
+
+	      return normalized;
+	    }
+
+	    /**
+	     * Parse signatures recursively in a node tree.
+	     * @param {Signature[]} signatures  Array with expanded signatures
+	     * @param {Param[]} path            Traversed path of parameter types
+	     * @return {Node}                   Returns a node tree
+	     */
+	    function parseTree(signatures, path) {
+	      var i, signature;
+	      var index = path.length;
+	      var nodeSignature;
+
+	      var filtered = [];
+	      for (i = 0; i < signatures.length; i++) {
+	        signature = signatures[i];
+
+	        // filter the first signature with the correct number of params
+	        if (signature.params.length === index && !nodeSignature) {
+	          nodeSignature = signature;
+	        }
+
+	        if (signature.params[index] != undefined) {
+	          filtered.push(signature);
+	        }
+	      }
+
+	      // sort the filtered signatures by param
+	      filtered.sort(function (a, b) {
+	        return Param.compare(a.params[index], b.params[index]);
+	      });
+
+	      // recurse over the signatures
+	      var entries = [];
+	      for (i = 0; i < filtered.length; i++) {
+	        signature = filtered[i];
+	        // group signatures with the same param at current index
+	        var param = signature.params[index];
+
+	        // TODO: replace the next filter loop
+	        var existing = entries.filter(function (entry) {
+	          return entry.param.overlapping(param);
+	        })[0];
+
+	        //var existing;
+	        //for (var j = 0; j < entries.length; j++) {
+	        //  if (entries[j].param.overlapping(param)) {
+	        //    existing = entries[j];
+	        //    break;
+	        //  }
+	        //}
+
+	        if (existing) {
+	          if (existing.param.varArgs) {
+	            throw new Error('Conflicting types "' + existing.param + '" and "' + param + '"');
+	          }
+	          existing.signatures.push(signature);
+	        }
+	        else {
+	          entries.push({
+	            param: param,
+	            signatures: [signature]
+	          });
+	        }
+	      }
+
+	      // parse the childs
+	      var childs = new Array(entries.length);
+	      for (i = 0; i < entries.length; i++) {
+	        var entry = entries[i];
+	        childs[i] = parseTree(entry.signatures, path.concat(entry.param))
+	      }
+
+	      return new Node(path, nodeSignature, childs);
+	    }
+
+	    /**
+	     * Generate an array like ['arg0', 'arg1', 'arg2']
+	     * @param {number} count Number of arguments to generate
+	     * @returns {Array} Returns an array with argument names
+	     */
+	    function getArgs(count) {
+	      // create an array with all argument names
+	      var args = [];
+	      for (var i = 0; i < count; i++) {
+	        args[i] = 'arg' + i;
+	      }
+
+	      return args;
+	    }
+
+	    /**
+	     * Compose a function from sub-functions each handling a single type signature.
+	     * Signatures:
+	     *   typed(signature: string, fn: function)
+	     *   typed(name: string, signature: string, fn: function)
+	     *   typed(signatures: Object.<string, function>)
+	     *   typed(name: string, signatures: Object.<string, function>)
+	     *
+	     * @param {string | null} name
+	     * @param {Object.<string, Function>} signatures
+	     * @return {Function} Returns the typed function
+	     * @private
+	     */
+	    function _typed(name, signatures) {
+	      var refs = new Refs();
+
+	      // parse signatures, expand them
+	      var _signatures = parseSignatures(signatures);
+	      if (_signatures.length == 0) {
+	        throw new Error('No signatures provided');
+	      }
+
+	      // parse signatures into a node tree
+	      var node = parseTree(_signatures, []);
+
+	      //var util = require('util');
+	      //console.log('ROOT');
+	      //console.log(util.inspect(node, { depth: null }));
+
+	      // generate code for the typed function
+	      var code = [];
+	      var _name = name || '';
+	      var _args = getArgs(maxParams(_signatures));
+	      code.push('function ' + _name + '(' + _args.join(', ') + ') {');
+	      code.push('  "use strict";');
+	      code.push('  var name = \'' + _name + '\';');
+	      code.push(node.toCode(refs, '  '));
+	      code.push('}');
+
+	      // generate body for the factory function
+	      var body = [
+	        refs.toCode(),
+	        'return ' + code.join('\n')
+	      ].join('\n');
+
+	      // evaluate the JavaScript code and attach function references
+	      var factory = (new Function(refs.name, 'createError', body));
+	      var fn = factory(refs, createError);
+
+	      //console.log('FN\n' + fn.toString()); // TODO: cleanup
+
+	      // attach the signatures with sub-functions to the constructed function
+	      fn.signatures = mapSignatures(_signatures);
+
+	      return fn;
+	    }
+
+	    /**
+	     * Calculate the maximum number of parameters in givens signatures
+	     * @param {Signature[]} signatures
+	     * @returns {number} The maximum number of parameters
+	     */
+	    function maxParams(signatures) {
+	      var max = 0;
+
+	      for (var i = 0; i < signatures.length; i++) {
+	        var len = signatures[i].params.length;
+	        if (len > max) {
+	          max = len;
+	        }
+	      }
+
+	      return max;
+	    }
+
+	    /**
+	     * Get the type of a value
+	     * @param {*} x
+	     * @returns {string} Returns a string with the type of value
+	     */
+	    function getTypeOf(x) {
+	      var obj;
+
+	      for (var i = 0; i < typed.types.length; i++) {
+	        var entry = typed.types[i];
+
+	        if (entry.name === 'Object') {
+	          // Array and Date are also Object, so test for Object afterwards
+	          obj = entry;
+	        }
+	        else {
+	          if (entry.test(x)) return entry.name;
+	        }
+	      }
+
+	      // at last, test whether an object
+	      if (obj && obj.test(x)) return obj.name;
+
+	      return 'unknown';
+	    }
+
+	    /**
+	     * Test whether an array contains some entry
+	     * @param {Array} array
+	     * @param {*} entry
+	     * @return {boolean} Returns true if array contains entry, false if not.
+	     */
+	    function contains(array, entry) {
+	      return array.indexOf(entry) !== -1;
+	    }
+
+	    // data type tests
+	    var types = [
+	      { name: 'number',    test: function (x) { return typeof x === 'number' } },
+	      { name: 'string',    test: function (x) { return typeof x === 'string' } },
+	      { name: 'boolean',   test: function (x) { return typeof x === 'boolean' } },
+	      { name: 'Function',  test: function (x) { return typeof x === 'function'} },
+	      { name: 'Array',     test: Array.isArray },
+	      { name: 'Date',      test: function (x) { return x instanceof Date } },
+	      { name: 'RegExp',    test: function (x) { return x instanceof RegExp } },
+	      { name: 'Object',    test: function (x) { return typeof x === 'object' } },
+	      { name: 'null',      test: function (x) { return x === null } },
+	      { name: 'undefined', test: function (x) { return x === undefined } }
+	    ];
+
+	    // configuration
+	    var config = {};
+
+	    // type conversions. Order is important
+	    var conversions = [];
+
+	    // types to be ignored
+	    var ignore = [];
+
+	    // temporary object for holding types and conversions, for constructing
+	    // the `typed` function itself
+	    // TODO: find a more elegant solution for this
+	    var typed = {
+	      config: config,
+	      types: types,
+	      conversions: conversions,
+	      ignore: ignore
+	    };
+
+	    /**
+	     * Construct the typed function itself with various signatures
+	     *
+	     * Signatures:
+	     *
+	     *   typed(signatures: Object.<string, function>)
+	     *   typed(name: string, signatures: Object.<string, function>)
+	     */
+	    typed = _typed('typed', {
+	      'Object': function (signatures) {
+	        var fns = [];
+	        for (var signature in signatures) {
+	          if (signatures.hasOwnProperty(signature)) {
+	            fns.push(signatures[signature]);
+	          }
+	        }
+	        var name = getName(fns);
+
+	        return _typed(name, signatures);
+	      },
+	      'string, Object': _typed,
+	      // TODO: add a signature 'Array.<function>'
+	      '...Function': function (fns) {
+	        var err;
+	        var name = getName(fns);
+	        var signatures = {};
+
+	        for (var i = 0; i < fns.length; i++) {
+	          var fn = fns[i];
+
+	          // test whether this is a typed-function
+	          if (!(typeof fn.signatures === 'object')) {
+	            err = new TypeError('Function is no typed-function (index: ' + i + ')');
+	            err.data = {index: i};
+	            throw err;
+	          }
+
+	          // merge the signatures
+	          for (var signature in fn.signatures) {
+	            if (fn.signatures.hasOwnProperty(signature)) {
+	              if (signatures.hasOwnProperty(signature)) {
+	                if (fn.signatures[signature] !== signatures[signature]) {
+	                  err = new Error('Signature "' + signature + '" is defined twice');
+	                  err.data = {signature: signature};
+	                  throw err;
+	                }
+	                // else: both signatures point to the same function, that's fine
+	              }
+	              else {
+	                signatures[signature] = fn.signatures[signature];
+	              }
+	            }
+	          }
+	        }
+
+	        return _typed(name, signatures);
+	      }
+	    });
+
+	    /**
+	     * Find a specific signature from a (composed) typed function, for
+	     * example:
+	     *
+	     *   typed.find(fn, ['number', 'string'])
+	     *   typed.find(fn, 'number, string')
+	     *
+	     * Function find only only works for exact matches.
+	     *
+	     * @param {Function} fn                   A typed-function
+	     * @param {string | string[]} signature   Signature to be found, can be
+	     *                                        an array or a comma separated string.
+	     * @return {Function}                     Returns the matching signature, or
+	     *                                        throws an errror when no signature
+	     *                                        is found.
+	     */
+	    function find (fn, signature) {
+	      if (!fn.signatures) {
+	        throw new TypeError('Function is no typed-function');
+	      }
+
+	      // normalize input
+	      var arr;
+	      if (typeof signature === 'string') {
+	        arr = signature.split(',');
+	        for (var i = 0; i < arr.length; i++) {
+	          arr[i] = arr[i].trim();
+	        }
+	      }
+	      else if (Array.isArray(signature)) {
+	        arr = signature;
+	      }
+	      else {
+	        throw new TypeError('String array or a comma separated string expected');
+	      }
+
+	      var str = arr.join(',');
+
+	      // find an exact match
+	      var match = fn.signatures[str];
+	      if (match) {
+	        return match;
+	      }
+
+	      // TODO: extend find to match non-exact signatures
+
+	      throw new TypeError('Signature not found (signature: ' + (fn.name || 'unnamed') + '(' + arr.join(', ') + '))');
+	    }
+
+	    /**
+	     * Convert a given value to another data type.
+	     * @param {*} value
+	     * @param {string} type
+	     */
+	    function convert (value, type) {
+	      var from = getTypeOf(value);
+	      
+	      // check conversion is needed
+	      if (type === from) {
+	        return value;
+	      }
+
+	      for (var i = 0; i < typed.conversions.length; i++) {
+	        var conversion = typed.conversions[i];
+	        if (conversion.from === from && conversion.to === type) {
+	          return conversion.convert(value);
+	        }
+	      }
+
+	      throw new Error('Cannot convert from ' + from + ' to ' + type);
+	    }
+
+	    // attach types and conversions to the final `typed` function
+	    typed.config = config;
+	    typed.types = types;
+	    typed.conversions = conversions;
+	    typed.ignore = ignore;
+	    typed.create = create;
+	    typed.find = find;
+	    typed.convert = convert;
+
+	    // add a type
+	    typed.addType = function (type) {
+	      if (!type || typeof type.name !== 'string' || typeof type.test !== 'function') {
+	        throw new TypeError('Object with properties {name: string, test: function} expected');
+	      }
+
+	      typed.types.push(type);
+	    };
+
+	    // add a conversion
+	    typed.addConversion = function (conversion) {
+	      if (!conversion
+	          || typeof conversion.from !== 'string'
+	          || typeof conversion.to !== 'string'
+	          || typeof conversion.convert !== 'function') {
+	        throw new TypeError('Object with properties {from: string, to: string, convert: function} expected');
+	      }
+
+	      typed.conversions.push(conversion);
+	    };
+
+	    return typed;
+	  }
+
+	  return create();
+	}));
+
+
+/***/ },
+/* 8 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var NumberFormatter = __webpack_require__(9);
+
+	/**
+	 * Test whether value is a number
 	 * @param {*} value
-	 * @return {Boolean} isNumber
+	 * @return {boolean} isNumber
 	 */
 	exports.isNumber = function(value) {
-	  return (value instanceof Number) || (typeof value == 'number');
+	  return typeof value === 'number';
 	};
 
 	/**
 	 * Check if a number is integer
-	 * @param {Number | Boolean} value
-	 * @return {Boolean} isInteger
+	 * @param {number | boolean} value
+	 * @return {boolean} isInteger
 	 */
 	exports.isInteger = function(value) {
-	  return (value == Math.round(value));
+	  return isFinite(value)
+	      ? (value == Math.round(value))
+	      : false;
 	  // Note: we use ==, not ===, as we can have Booleans as well
 	};
 
 	/**
 	 * Calculate the sign of a number
-	 * @param {Number} x
+	 * @param {number} x
 	 * @returns {*}
 	 */
 	exports.sign = function(x) {
@@ -767,9 +2133,9 @@
 	 *
 	 * Where:
 	 *
-	 *    {Number} value   The value to be formatted
+	 *    {number} value   The value to be formatted
 	 *    {Object} options An object with formatting options. Available options:
-	 *                     {String} notation
+	 *                     {string} notation
 	 *                         Number notation. Choose from:
 	 *                         'fixed'          Always use regular number notation.
 	 *                                          For example '123.40' and '14000000'
@@ -782,7 +2148,7 @@
 	 *                                          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
+	 *                     {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
@@ -793,7 +2159,7 @@
 	 *                                          significant digits after the decimal
 	 *                                          point, and is 0 by default.
 	 *                     {Object} exponential An object containing two parameters,
-	 *                                          {Number} lower and {Number} upper,
+	 *                                          {number} lower and {number} upper,
 	 *                                          used by notation 'auto' to determine
 	 *                                          when to return exponential notation.
 	 *                                          Default values are `lower=1e-3` and
@@ -815,9 +2181,9 @@
 	 *    format(2.3,    {notation: 'fixed', precision: 2});  // '2.30'
 	 *    format(52.8,   {notation: 'exponential'});          // '5.28e+1'
 	 *
-	 * @param {Number} value
-	 * @param {Object | Function | Number} [options]
-	 * @return {String} str The formatted value
+	 * @param {number} value
+	 * @param {Object | Function | number} [options]
+	 * @return {string} str The formatted value
 	 */
 	exports.format = function(value, options) {
 	  if (typeof options === 'function') {
@@ -882,8 +2248,8 @@
 
 	/**
 	 * Format a number in exponential notation. Like '1.23e+5', '2.3e+0', '3.500e-3'
-	 * @param {Number} value
-	 * @param {Number} [precision]  Number of digits in formatted output.
+	 * @param {number} value
+	 * @param {number} [precision]  Number of digits in formatted output.
 	 *                              If not provided, the maximum available digits
 	 *                              is used.
 	 * @returns {string} str
@@ -894,8 +2260,8 @@
 
 	/**
 	 * Format a number with fixed notation.
-	 * @param {Number} value
-	 * @param {Number} [precision=0]        Optional number of decimals after the
+	 * @param {number} value
+	 * @param {number} [precision=0]        Optional number of decimals after the
 	 *                                      decimal point. Zero by default.
 	 */
 	exports.toFixed = function(value, precision) {
@@ -904,8 +2270,8 @@
 
 	/**
 	 * Format a number with a certain precision
-	 * @param {Number} value
-	 * @param {Number} [precision=undefined] Optional number of digits.
+	 * @param {number} value
+	 * @param {number} [precision=undefined] Optional number of digits.
 	 * @param {{lower: number, upper: number}} [options]  By default:
 	 *                                                    lower = 1e-3 (excl)
 	 *                                                    upper = 1e+5 (incl)
@@ -923,8 +2289,8 @@
 	 *   0.0034 returns 2
 	 *   120.5e+30 returns 4
 	 *
-	 * @param {Number} value
-	 * @return {Number} digits   Number of significant digits
+	 * @param {number} value
+	 * @return {number} digits   Number of significant digits
 	 */
 	exports.digits = function(value) {
 	  return value
@@ -941,9 +2307,9 @@
 
 	/**
 	 * Compares two floating point numbers.
-	 * @param {Number} x          First value to compare
-	 * @param {Number} y          Second value to compare
-	 * @param {Number} [epsilon]  The maximum relative difference between x and y
+	 * @param {number} x          First value to compare
+	 * @param {number} y          Second value to compare
+	 * @param {number} [epsilon]  The maximum relative difference between x and y
 	 *                            If epsilon is undefined or null, the function will
 	 *                            test whether x and y are exactly equal.
 	 * @return {boolean} whether the two numbers are equal
@@ -977,1167 +2343,216 @@
 
 
 /***/ },
-/* 4 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	module.exports = function (math, config) {
-	  var object = __webpack_require__(2);
-	  var bignumber = __webpack_require__(168);
-	  var Complex = __webpack_require__(7);
-	  var BigNumber = math.type.BigNumber;
-
-	  math['true']     = true;
-	  math['false']    = false;
-	  math['null']     = null;
-	  math['uninitialized'] = __webpack_require__(169).UNINITIALIZED;
-
-	  if (config.number === 'bignumber') {
-	    math['Infinity'] = new BigNumber(Infinity);
-	    math['NaN']      = new BigNumber(NaN);
-
-	    object.lazy(math, 'pi',  function () {return bignumber.pi(config.precision)});
-	    object.lazy(math, 'tau', function () {return bignumber.tau(config.precision)});
-	    object.lazy(math, 'e',   function () {return bignumber.e(config.precision)});
-	    object.lazy(math, 'phi', function () {return bignumber.phi(config.precision)}); // golden ratio, (1+sqrt(5))/2
-
-	    // uppercase constants (for compatibility with built-in Math)
-	    object.lazy(math, 'E',       function () {return math.e;});
-	    object.lazy(math, 'LN2',     function () {return new BigNumber(2).ln();});
-	    object.lazy(math, 'LN10',    function () {return new BigNumber(10).ln()});
-	    object.lazy(math, 'LOG2E',   function () {return new BigNumber(1).div(new BigNumber(2).ln());});
-	    object.lazy(math, 'LOG10E',  function () {return new BigNumber(1).div(new BigNumber(10).ln())});
-	    object.lazy(math, 'PI',      function () {return math.pi});
-	    object.lazy(math, 'SQRT1_2', function () {return new BigNumber('0.5').sqrt()});
-	    object.lazy(math, 'SQRT2',   function () {return new BigNumber(2).sqrt()});
-	  }
-	  else {
-	    math['Infinity'] = Infinity;
-	    math['NaN']      = NaN;
-
-	    math.pi  = Math.PI;
-	    math.tau = Math.PI * 2;
-	    math.e   = Math.E;
-	    math.phi = 1.61803398874989484820458683436563811772030917980576286213545; // golden ratio, (1+sqrt(5))/2
-
-	    // 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;
-	  }
-
-	  // complex i
-	  math.i = new Complex(0, 1);
-
-	  // meta information
-	  math.version = __webpack_require__(170);
-	};
-
-
-/***/ },
-/* 5 */
-/***/ function(module, exports, __webpack_require__) {
-
-	var BigNumber = __webpack_require__(340);
-
-	// FIXME: replace all require('decimal.js') with require('./BigNumber').
-
-	module.exports = BigNumber;
-
-
-/***/ },
-/* 6 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	exports.ArgumentsError = __webpack_require__(171);
-	exports.DimensionError = __webpack_require__(172);
-	exports.IndexError = __webpack_require__(173);
-	exports.UnsupportedTypeError = __webpack_require__(174);
-
-	// TODO: implement an InvalidValueError?
-
-
-/***/ },
-/* 7 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	var util = __webpack_require__(175),
-	    Unit = __webpack_require__(11),
-	    number = util.number,
-
-	    isNumber = util.number.isNumber,
-	    isUnit = Unit.isUnit,
-	    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('Constructor must be called with the new operator');
-	  }
-
-	  switch (arguments.length) {
-	    case 0:
-	      this.re = 0;
-	      this.im = 0;
-	      break;
-
-	    case 1:
-	      var arg = arguments[0];
-	      if (typeof arg === 'object') {
-	        if('re' in arg && 'im' in arg) {
-	          var construct = new Complex(arg.re, arg.im); // pass on input validation
-	          this.re = construct.re;
-	          this.im = construct.im;
-	          break;
-	        } else if ('r' in arg && 'phi' in arg) {
-	          var construct = Complex.fromPolar(arg.r, arg.phi);
-	          this.re = construct.re;
-	          this.im = construct.im;
-	          break;
-	        }
-	      }
-	      throw new SyntaxError('Object with the re and im or r and phi properties expected.');
-
-	    case 2:
-	      if (!isNumber(re) || !isNumber(im)) {
-	        throw new TypeError('Two numbers expected in Complex constructor');
-	      }
-	      this.re = re;
-	      this.im = im;
-	      break;
-
-	    default:
-	      throw new SyntaxError('One, two or three arguments expected in Complex constructor');
-	  }
-	}
-
-	/**
-	 * Test whether value is a Complex value
-	 * @param {*} value
-	 * @return {Boolean} isComplex
-	 */
-	Complex.isComplex = function (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 (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 complex number from polar coordinates
-	 *
-	 * Usage:
-	 *
-	 *     Complex.fromPolar(r: Number, phi: Number) : Complex
-	 *     Complex.fromPolar({r: Number, phi: Number}) : Complex
-	 *
-	 * @param {*} args...
-	 * @return {Complex}
-	 */
-	Complex.fromPolar = function (args) {
-	  switch (arguments.length) {
-	    case 1:
-	      var arg = arguments[0];
-	      if(typeof arg === 'object') {
-	        return Complex.fromPolar(arg.r, arg.phi);
-	      }
-	      throw new TypeError('Input has to be an object with r and phi keys.');
-
-	    case 2:
-	      var r = arguments[0],
-	        phi = arguments[1];
-	      if(isNumber(r)) {
-	        if (isUnit(phi) && phi.hasBase(Unit.BASE_UNITS.ANGLE)) {
-	          // convert unit to a number in radians
-	          phi = phi.toNumber('rad');
-	        }
-
-	        if(isNumber(phi)) {
-	          return new Complex(r * Math.cos(phi), r * Math.sin(phi));
-	        }
-
-	        throw new TypeError('Phi is not a number nor an angle unit.');
-	      } else {
-	        throw new TypeError('Radius r is not a number.');
-	      }
-
-	    default:
-	      throw new SyntaxError('Wrong number of arguments in function fromPolar');
-	  }
-	};
-
-	/*
-	 * Return the value of the complex number in polar notation
-	 * The angle phi will be set in the interval of [-pi, pi].
-	 * @return {{r: number, phi: number}} Returns and object with properties r and phi.
-	 */
-	Complex.prototype.toPolar = function() {
-	  return {
-	    r: Math.sqrt(this.re * this.re + this.im * this.im),
-	    phi: Math.atan2(this.im, this.re)
-	  };
-	};
-
-	/**
-	 * Create a copy of the complex value
-	 * @return {Complex} clone
-	 */
-	Complex.prototype.clone = function () {
-	  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 (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 (options) {
-	  var str = '';
-	  var im = this.im;
-	  var re = this.re;
-	  var strRe = number.format(this.re, options);
-	  var strIm = number.format(this.im, options);
-
-	  // round either re or im when smaller than the configured precision
-	  var precision = isNumber(options) ? options : options ? options.precision : null;
-	  if (precision !== null) {
-	    var epsilon = Math.pow(10, -precision);
-	    if (Math.abs(re / im) < epsilon) {re = 0;}
-	    if (Math.abs(im / re) < epsilon) {im = 0;}
-	  }
-
-	  if (im == 0) {
-	    // real value
-	    str = strRe;
-	  }
-	  else if (re == 0) {
-	    // purely complex value
-	    if (im == 1) {
-	      str = 'i';
-	    }
-	    else if (im == -1) {
-	      str = '-i';
-	    }
-	    else {
-	      str = strIm + 'i';
-	    }
-	  }
-	  else {
-	    // complex value
-	    if (im > 0) {
-	      if (im == 1) {
-	        str = strRe + ' + i';
-	      }
-	      else {
-	        str = strRe + ' + ' + strIm + 'i';
-	      }
-	    }
-	    else {
-	      if (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 () {
-	  return this.format();
-	};
-
-	/**
-	 * Get a JSON representation of the complex number
-	 * @returns {Object} Returns a JSON object structured as:
-	 *                   `{"mathjs": "Complex", "re": 2, "im": 3}`
-	 */
-	Complex.prototype.toJSON = function () {
-	  return {
-	    mathjs: 'Complex',
-	    re: this.re,
-	    im: this.im
-	  };
-	};
-
-	/**
-	 * Create a Complex number from a JSON object
-	 * @param {Object} json  A JSON Object structured as
-	 *                       {"mathjs": "Complex", "re": 2, "im": 3}
-	 *                       All properties are optional, default values
-	 *                       for `re` and `im` are 0.
-	 * @return {Complex} Returns a new Complex number
-	 */
-	Complex.fromJSON = function (json) {
-	  return new Complex(json);
-	};
-
-	/**
-	 * Returns a string representation of the complex number.
-	 * @return {String} str
-	 */
-	Complex.prototype.valueOf = Complex.prototype.toString;
-
-	// exports
-	module.exports = Complex;
-
-
-/***/ },
-/* 8 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	var util = __webpack_require__(175);
-
-	var number = util.number;
-	var string = util.string;
-	var 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('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 (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 () {
-	  return new Range(this.start, this.end, this.step);
-	};
-
-	/**
-	 * Test whether an object is a Range
-	 * @param {*} object
-	 * @return {Boolean} isRange
-	 */
-	Range.isRange = function (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 () {
-	  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 () {
-	  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 () {
-	  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 (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 (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 () {
-	  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 () {
-	  // 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 (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 () {
-	  return this.format();
-	};
-
-	/**
-	 * Get a JSON representation of the range
-	 * @returns {Object} Returns a JSON object structured as:
-	 *                   `{"mathjs": "Range", "start": 2, "end": 4, "step": 1}`
-	 */
-	Range.prototype.toJSON = function () {
-	  return {
-	    mathjs: 'Range',
-	    start: this.start,
-	    end: this.end,
-	    step: this.step
-	  };
-	};
-
-	/**
-	 * Instantiate a Range from a JSON object
-	 * @param {Object} json A JSON object structured as:
-	 *                      `{"mathjs": "Range", "start": 2, "end": 4, "step": 1}`
-	 * @return {Range}
-	 */
-	Range.fromJSON = function (json) {
-	  return new Range(json.start, json.end, json.step);
-	};
-
-	// exports
-	module.exports = Range;
-
-
-/***/ },
 /* 9 */
-/***/ function(module, exports, __webpack_require__) {
+/***/ function(module, exports) {
 
 	'use strict';
 
-	var util = __webpack_require__(175),
-
-	    Range = __webpack_require__(8),
-
-	    number = util.number,
-
-	    isNumber = number.isNumber,
-	    isInteger = number.isInteger,
-	    isArray = Array.isArray;
-
-	/**
-	 * @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('Constructor must be called with the new operator');
-	  }
-
-	  this._ranges = [];
-	  this._isScalar = true;
-
-	  for (var i = 0, ii = arguments.length; i < ii; i++) {
-	    var arg = arguments[i];
-
-	    if (arg instanceof Range) {
-	      this._ranges.push(arg);
-	      this._isScalar = false;
-	    }
-	    else if (isArray(arg)) {
-	      this._ranges.push(_createRange(arg));
-	      this._isScalar = false;
-	    }
-	    else if (isNumber(arg)) {
-	      this._ranges.push(_createRange([arg, arg + 1]));
-	    }
-	    // TODO: implement support for wildcard '*'
-	    else {
-	      var primitive = arg.valueOf(); // for example turn a Matrix into an Array
-	      if (isArray(primitive)) {
-	        this._ranges.push(_createRange(primitive));
-	        this._isScalar = false;
-	      }
-	      else {
-	        throw new TypeError('Ranges must be an Array, Number, or Range');
-	      }
-	    }
-	  }
-	}
-
-	/**
-	 * 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 () {
-	  var index = new Index();
-	  index._ranges = util.object.clone(this._ranges);
-	  index._isScalar = this._isScalar;
-	  return index;
-	};
-
-	/**
-	 * Test whether an object is an Index
-	 * @param {*} object
-	 * @return {Boolean} isIndex
-	 */
-	Index.isIndex = function (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 (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 () {
-	  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 () {
-	  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 () {
-	  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 (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 | null} range
-	 */
-	Index.prototype.range = function(dim) {
-	  return this._ranges[dim] || null;
-	};
-
-	/**
-	 * Test whether this index contains only a single value.
-	 *
-	 * This is the case when the index is created with only scalar values as ranges,
-	 * not for ranges resolving into a single value.
-	 * @return {boolean} isScalar
-	 */
-	Index.prototype.isScalar = function () {
-	  return this._isScalar;
-	};
-
-	/**
-	 * 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 () {
-	  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(', ') + ']';
-	};
-
-	/**
-	 * Get a JSON representation of the Index
-	 * @returns {Object} Returns a JSON object structured as:
-	 *                   `{"mathjs": "Index", "ranges": [{"mathjs": "Range", start: 0, end: 10, step:1}, ...]}`
-	 */
-	Index.prototype.toJSON = function () {
-	  return {
-	    mathjs: 'Index',
-	    ranges: this._ranges
-	  };
-	};
-
-	/**
-	 * Instantiate an Index from a JSON object
-	 * @param {Object} json A JSON object structured as:
-	 *                     `{"mathjs": "Index", "ranges": [{"mathjs": "Range", start: 0, end: 10, step:1}, ...]}`
-	 * @return {Index}
-	 */
-	Index.fromJSON = function (json) {
-	  return Index.create(json.ranges);
-	};
-
-	// exports
-	module.exports = Index;
+	/**
+	 * Format a number using methods toPrecision, toFixed, toExponential.
+	 * @param {number | string} value
+	 * @constructor
+	 */
+	function NumberFormatter (value) {
+	  // parse the input value
+	  var match = String(value).toLowerCase().match(/^0*?(-?)(\d+\.?\d*)(e([+-]?\d+))?$/);
+	  if (!match) {
+	    throw new SyntaxError('Invalid number');
+	  }
+
+	  var sign         = match[1];
+	  var coefficients = match[2];
+	  var exponent     = parseFloat(match[4] || '0');
+
+	  var dot = coefficients.indexOf('.');
+	  exponent += (dot !== -1) ? (dot - 1) : (coefficients.length - 1);
+
+	  this.sign = sign;
+	  this.coefficients = coefficients
+	      .replace('.', '')  // remove the dot (must be removed before removing leading zeros)
+	      .replace(/^0*/, function (zeros) {
+	        // remove leading zeros, add their count to the exponent
+	        exponent -= zeros.length;
+	        return '';
+	      })
+	      .replace(/0*$/, '') // remove trailing zeros
+	      .split('')
+	      .map(function (d) {
+	        return parseInt(d);
+	      });
+
+	  if (this.coefficients.length === 0) {
+	    this.coefficients.push(0);
+	    exponent++;
+	  }
+
+	  this.exponent = exponent;
+	}
+
+	/**
+	 * Format a number with fixed notation.
+	 * @param {number} [precision=0]        Optional number of decimals after the
+	 *                                      decimal point. Zero by default.
+	 */
+	NumberFormatter.prototype.toFixed = function (precision) {
+	  var rounded = this.roundDigits(this.exponent + 1 + (precision || 0));
+	  var c = rounded.coefficients;
+	  var p = rounded.exponent + 1; // exponent may have changed
+
+	  // append zeros if needed
+	  var pp = p + (precision || 0);
+	  if (c.length < pp) {
+	    c = c.concat(zeros(pp - c.length));
+	  }
+
+	  // prepend zeros if needed
+	  if (p < 0) {
+	    c = zeros(-p + 1).concat(c);
+	    p = 1;
+	  }
+
+	  // insert a dot if needed
+	  if (precision) {
+	    c.splice(p, 0, (p === 0) ? '0.' : '.');
+	  }
+
+	  return this.sign + c.join('');
+	};
+
+	/**
+	 * Format a number in exponential notation. Like '1.23e+5', '2.3e+0', '3.500e-3'
+	 * @param {number} [precision]  Number of digits in formatted output.
+	 *                              If not provided, the maximum available digits
+	 *                              is used.
+	 */
+	NumberFormatter.prototype.toExponential = function (precision) {
+	  // round if needed, else create a clone
+	  var rounded = precision ? this.roundDigits(precision) : this.clone();
+	  var c = rounded.coefficients;
+	  var e = rounded.exponent;
+
+	  // append zeros if needed
+	  if (c.length < precision) {
+	    c = c.concat(zeros(precision - c.length));
+	  }
+
+	  // format as `C.CCCe+EEE` or `C.CCCe-EEE`
+	  var first = c.shift();
+	  return this.sign + first + (c.length > 0 ? ('.' + c.join('')) : '') +
+	      'e' + (e >= 0 ? '+' : '') + e;
+	};
+
+	/**
+	 * Format a number with a certain precision
+	 * @param {number} [precision=undefined] Optional number of digits.
+	 * @param {{lower: number | undefined, upper: number | undefined}} [options]
+	 *                                       By default:
+	 *                                         lower = 1e-3 (excl)
+	 *                                         upper = 1e+5 (incl)
+	 * @return {string}
+	 */
+	NumberFormatter.prototype.toPrecision = function(precision, options) {
+	  // determine lower and upper bound for exponential notation.
+	  var lower = (options && options.lower !== undefined) ? options.lower : 1e-3;
+	  var upper = (options && options.upper !== undefined) ? options.upper : 1e+5;
+
+	  var abs = Math.abs(Math.pow(10, this.exponent));
+	  if (abs < lower || abs >= upper) {
+	    // exponential notation
+	    return this.toExponential(precision);
+	  }
+	  else {
+	    var rounded = precision ? this.roundDigits(precision) : this.clone();
+	    var c = rounded.coefficients;
+	    var e = rounded.exponent;
+
+	    // append trailing zeros
+	    if (c.length < precision) {
+	      c = c.concat(zeros(precision - c.length));
+	    }
+
+	    // append trailing zeros
+	    // TODO: simplify the next statement
+	    c = c.concat(zeros(e - c.length + 1 +
+	        (c.length < precision ? precision - c.length : 0)));
+
+	    // prepend zeros
+	    c = zeros(-e).concat(c);
+
+	    var dot = e > 0 ? e : 0;
+	    if (dot < c.length - 1) {
+	      c.splice(dot + 1, 0, '.');
+	    }
+
+	    return this.sign + c.join('');
+	  }
+	};
+
+	/**
+	 * Crete a clone of the NumberFormatter
+	 * @return {NumberFormatter} Returns a clone of the NumberFormatter
+	 */
+	NumberFormatter.prototype.clone = function () {
+	  var clone = new NumberFormatter('0');
+	  clone.sign = this.sign;
+	  clone.coefficients = this.coefficients.slice(0);
+	  clone.exponent = this.exponent;
+	  return clone;
+	};
+
+	/**
+	 * Round the number of digits of a number *
+	 * @param {number} precision  A positive integer
+	 * @return {NumberFormatter}  Returns a new NumberFormatter with the rounded
+	 *                            digits
+	 */
+	NumberFormatter.prototype.roundDigits = function (precision) {
+	  var rounded = this.clone();
+	  var c = rounded.coefficients;
+
+	  // prepend zeros if needed
+	  while (precision <= 0) {
+	    c.unshift(0);
+	    rounded.exponent++;
+	    precision++;
+	  }
+
+	  if (c.length > precision) {
+	    var removed = c.splice(precision);
+
+	    if (removed[0] >= 5) {
+	      var i = precision - 1;
+	      c[i]++;
+	      while (c[i] === 10) {
+	        c.pop();
+	        if (i === 0) {
+	          c.unshift(0);
+	          rounded.exponent++;
+	          i++;
+	        }
+	        i--;
+	        c[i]++;
+	      }
+	    }
+	  }
+
+	  return rounded;
+	};
+
+	/**
+	 * Create an array filled with zeros.
+	 * @param {number} length
+	 * @return {Array}
+	 */
+	function zeros(length) {
+	  var arr = [];
+	  for (var i = 0; i < length; i++) {
+	    arr.push(0);
+	  }
+	  return arr;
+	}
+
+	module.exports = NumberFormatter;
 
 
 /***/ },
@@ -2146,1166 +2561,300 @@
 
 	'use strict';
 
-	var string = __webpack_require__(176),
-
-	    isString = string.isString;
-
-	module.exports = function (config) {
-
+	var lazy = __webpack_require__(5).lazy;
+	var isFactory = __webpack_require__(5).isFactory;
+	var traverse = __webpack_require__(5).traverse;
+	var extend = __webpack_require__(5).extend;
+	var ArgumentsError = __webpack_require__(11);
+
+	function factory (type, config, load, typed, math) {
 	  /**
-	   * @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 = math.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 = math.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)
-	   *
+	   * Import functions from an object or a module
+	   *
+	   * Syntax:
+	   *
+	   *    math.import(object)
+	   *    math.import(object, options)
+	   *
+	   * Where:
+	   *
+	   * - `object: Object`
+	   *   An object with functions to be imported.
+	   * - `options: Object` An object with import options. Available options:
+	   *   - `override: boolean`
+	   *     If true, existing functions will be overwritten. False by default.
+	   *   - `silent: boolean`
+	   *     If true, the function will not throw errors on duplicates or invalid
+	   *     types. False by default.
+	   *   - `wrap: boolean`
+	   *     If true, the functions will be wrapped in a wrapper function
+	   *     which converts data types like Matrix to primitive data types like Array.
+	   *     The wrapper is needed when extending math.js with libraries which do not
+	   *     support these data type. False by default.
+	   *
+	   * Examples:
+	   *
+	   *    // define new functions and variables
+	   *    math.import({
+	   *      myvalue: 42,
+	   *      hello: function (name) {
+	   *        return 'hello, ' + name + '!';
+	   *      }
+	   *    });
+	   *
+	   *    // use the imported function and variable
+	   *    math.myvalue * 2;               // 84
+	   *    math.hello('user');             // 'hello, user!'
+	   *
+	   *    // import the npm module 'numbers'
+	   *    // (must be installed first with `npm install numbers`)
+	   *    math.import(require('numbers'), {wrap: true});
+	   *
+	   *    math.fibonacci(7); // returns 13
+	   *
+	   * @param {Object | Array} object   Object with functions to be imported.
+	   * @param {Object} [options]        Import options.
 	   */
-	  function Matrix() {
-	    if (!(this instanceof Matrix)) {
-	      throw new SyntaxError('Constructor must be called with the new operator');
+	  function math_import(object, options) {
+	    var num = arguments.length;
+	    if (num != 1 && num != 2) {
+	      throw new ArgumentsError('import', num, 1, 2);
+	    }
+
+	    if (!options) {
+	      options = {};
+	    }
+
+	    if (isFactory(object)) {
+	      _importFactory(object, options);
+	    }
+	    else if (Array.isArray(object)) {
+	      object.forEach(function (entry) {
+	        math_import(entry, options);
+	      });
+	    }
+	    else if (typeof object === 'object') {
+	      // a map with functions
+	      for (var name in object) {
+	        if (object.hasOwnProperty(name)) {
+	          var value = object[name];
+	          if (isSupportedType(value)) {
+	            _import(name, value, options);
+	          }
+	          else if (isFactory(object)) {
+	            _importFactory(object, options);
+	          }
+	          else {
+	            math_import(value, options);
+	          }
+	        }
+	      }
+	    }
+	    else {
+	      if (!options.silent) {
+	        throw new TypeError('Factory, Object, or Array expected');
+	      }
 	    }
 	  }
 
 	  /**
-	   * Test whether an object is a Matrix
-	   * @param {*} object
-	   * @return {Boolean} isMatrix
-	   */
-	  Matrix.isMatrix = function (object) {
-	    return (object instanceof Matrix);
-	  };
-
-	  /**
-	   * Get the Matrix storage constructor for the given format.
-	   *
-	   * @param {string} format       The Matrix storage format.
-	   *
-	   * @return {Function}           The Matrix storage constructor.
-	   */
-	  Matrix.storage = function (format) {
-	    // check storage format is a string
-	    if (!isString(format)) {
-	      throw new TypeError('format must be a string value');
-	    }
-
-	    // get storage format constructor
-	    var constructor = Matrix._storage[format];
-	    if (!constructor) {
-	      throw new SyntaxError('Unsupported matrix storage format: ' + format);
-	    }
-
-	    // return storage constructor
-	    return constructor;
-	  };
-
-	  // a map with all constructors for all storage types
-	  Matrix._storage = {};
-
-	  /**
-	   * Get the storage format used by the matrix.
-	   *
-	   * Usage:
-	   *     var format = matrix.storage()                   // retrieve storage format
-	   *
-	   * @return {string}           The storage format.
-	   */
-	  Matrix.prototype.storage = function () {
-	    // must be implemented by each of the Matrix implementations
-	    throw new Error('Cannot invoke storage on a Matrix interface');
-	  };
-	  
-	  /**
-	   * 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=0]      Default value, filled in on new entries when
-	   *                                  the matrix is resized. If not provided,
-	   *                                  new matrix elements will be filled with zeros.
-	   */
-	  Matrix.prototype.subset = function (index, replacement, defaultValue) {
-	    // must be implemented by each of the Matrix implementations
-	    throw new Error('Cannot invoke subset on a Matrix interface');
-	  };
-
-	  /**
-	   * Get a single element from the matrix.
-	   * @param {Number[]} index   Zero-based index
-	   * @return {*} value
-	   */
-	  Matrix.prototype.get = function (index) {
-	    // must be implemented by each of the Matrix implementations
-	    throw new Error('Cannot invoke get on a Matrix interface');
-	  };
-
-	  /**
-	   * Replace a single element in the matrix.
-	   * @param {Number[]} index   Zero-based index
+	   * Add a property to the math namespace and create a chain proxy for it.
+	   * @param {string} name
 	   * @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 (index, value, defaultValue) {
-	    // must be implemented by each of the Matrix implementations
-	    throw new Error('Cannot invoke set on a Matrix interface');
-	  };
-
-	  /**
-	   * Resize the matrix to the given size. Returns a copy of the matrix when 
-	   * `copy=true`, otherwise return the matrix itself (resize in place).
-	   *
-	   * @param {Number[]} size           The new size the matrix should have.
-	   * @param {*} [defaultValue=0]      Default value, filled in on new entries.
-	   *                                  If not provided, the matrix elements will
-	   *                                  be filled with zeros.
-	   * @param {boolean} [copy]          Return a resized copy of the matrix
-	   *
-	   * @return {Matrix}                 The resized matrix
-	   */
-	  Matrix.prototype.resize = function (size, defaultValue) {
-	    // must be implemented by each of the Matrix implementations
-	    throw new Error('Cannot invoke resize on a Matrix interface');
-	  };
-
-	  /**
-	   * Create a clone of the matrix
-	   * @return {Matrix} clone
-	   */
-	  Matrix.prototype.clone = function () {
-	    // must be implemented by each of the Matrix implementations
-	    throw new Error('Cannot invoke clone on a Matrix interface');
-	  };
-
-	  /**
-	   * Retrieve the size of the matrix.
-	   * @returns {Number[]} size
-	   */
-	  Matrix.prototype.size = function() {
-	    // must be implemented by each of the Matrix implementations
-	    throw new Error('Cannot invoke size on a Matrix interface');
-	  };
-
-	  /**
-	   * 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.
-	   * @param {boolean} [skipZeros] Invoke callback function for non-zero values only.
-	   *
-	   * @return {Matrix} matrix
-	   */
-	  Matrix.prototype.map = function (callback, skipZeros) {
-	    // must be implemented by each of the Matrix implementations
-	    throw new Error('Cannot invoke map on a Matrix interface');
-	  };
-
-	  /**
-	   * 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 (callback) {
-	    // must be implemented by each of the Matrix implementations
-	    throw new Error('Cannot invoke forEach on a Matrix interface');
-	  };
-
-	  /**
-	   * Create an Array with a copy of the data of the Matrix
-	   * @returns {Array} array
-	   */
-	  Matrix.prototype.toArray = function () {
-	    // must be implemented by each of the Matrix implementations
-	    throw new Error('Cannot invoke toArray on a Matrix interface');
-	  };
-
-	  /**
-	   * Get the primitive value of the Matrix: a multidimensional array
-	   * @returns {Array} array
-	   */
-	  Matrix.prototype.valueOf = function () {
-	    // must be implemented by each of the Matrix implementations
-	    throw new Error('Cannot invoke valueOf on a Matrix interface');
-	  };
-
-	  /**
-	   * 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 (options) {
-	    // must be implemented by each of the Matrix implementations
-	    throw new Error('Cannot invoke format on a Matrix interface');
-	  };
-
-	  /**
-	   * Get a string representation of the matrix
-	   * @returns {String} str
-	   */
-	  Matrix.prototype.toString = function () {
-	    // must be implemented by each of the Matrix implementations
-	    throw new Error('Cannot invoke toString on a Matrix interface');
-	  };
-
-	  /**
-	   * Calculates the transpose of the matrix
-	   * @returns {Matrix}
-	   */
-	  Matrix.prototype.transpose = function () {
-	    // must be implemented by each of the Matrix implementations
-	    throw new Error('Cannot invoke transpose on a Matrix interface');
-	  };
-
-	  /**
-	   * Calculate the trace of a matrix: the sum of the elements on the main
-	   * diagonal of a square matrix.
-	   *
-	   * See also:
-	   *
-	   *    diagonal
-	   *
-	   * @returns {Number}       The matrix trace
-	   */
-	  Matrix.prototype.trace = function () {
-	    // must be implemented by each of the Matrix implementations
-	    throw new Error('Cannot invoke transpose on a Matrix interface');
-	  };
-
-	  /**
-	   * Multiply the matrix values times the argument.
-	   *
-	   * @param  {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix | null} Value to multiply.
-	   *
-	   * @return {Number | BigNumber | Complex | Unit | Matrix}
-	   */
-	  Matrix.prototype.multiply = function (value) {
-	    // must be implemented by each of the Matrix implementations
-	    throw new Error('Cannot invoke multiply on a Matrix interface');
-	  };
-	  
-	  // exports
-	  return Matrix;
-	};
+	   * @param {Object} options  See import for a description of the options
+	   * @private
+	   */
+	  function _import(name, value, options) {
+	    if (options.wrap && typeof value === 'function') {
+	      // create a wrapper around the function
+	      value = _wrap(value);
+	    }
+
+	    if (isTypedFunction(math[name]) && isTypedFunction(value)) {
+	      // merge two typed functions
+	      if (options.override) {
+	        value = typed(extend({}, math[name].signatures, value.signatures));
+	      }
+	      else {
+	        value = typed(math[name], value);
+	      }
+
+	      math[name] = value;
+	      _importTransform(name, value);
+	      math.emit('import', name, function resolver() {
+	        return value;
+	      });
+	      return;
+	    }
+
+	    if (math[name] === undefined || options.override) {
+	      math[name] = value;
+	      _importTransform(name, value);
+	      math.emit('import', name, function resolver() {
+	        return value;
+	      });
+	      return;
+	    }
+
+	    if (!options.silent) {
+	      throw new Error('Cannot import "' + name + '": already exists');
+	    }
+	  }
+
+	  function _importTransform (name, value) {
+	    if (value && typeof value.transform === 'function') {
+	      math.expression.transform[name] = value.transform;
+	    }
+	  }
+
+	  /**
+	   * Create a wrapper a round an function which converts the arguments
+	   * to their primitive values (like convert a Matrix to Array)
+	   * @param {Function} fn
+	   * @return {Function} Returns the wrapped function
+	   * @private
+	   */
+	  function _wrap (fn) {
+	    var wrapper = function wrapper () {
+	      var args = [];
+	      for (var i = 0, len = arguments.length; i < len; i++) {
+	        var arg = arguments[i];
+	        args[i] = arg && arg.valueOf();
+	      }
+	      return fn.apply(math, args);
+	    };
+
+	    if (fn.transform) {
+	      wrapper.transform = fn.transform;
+	    }
+
+	    return wrapper;
+	  }
+
+	  /**
+	   * Import an instance of a factory into math.js
+	   * @param {{factory: Function, name: string, path: string, math: boolean}} factory
+	   * @param {Object} options  See import for a description of the options
+	   * @private
+	   */
+	  function _importFactory(factory, options) {
+	    if (typeof factory.name === 'string') {
+	      var name = factory.name;
+	      var namespace = factory.path ? traverse(math, factory.path) : math;
+	      var existing = namespace.hasOwnProperty(name) ? namespace[name] : undefined;
+
+	      var resolver = function () {
+	        var instance = load(factory);
+
+	        if (isTypedFunction(existing) && isTypedFunction(instance)) {
+	          // merge two typed functions
+	          if (options.override) {
+	            instance = typed(extend({}, existing.signatures, instance.signatures));
+	          }
+	          else {
+	            instance = typed(existing, instance);
+	          }
+
+	          return instance;
+	        }
+
+	        if (existing === undefined || options.override) {
+	          return instance;
+	        }
+
+	        if (!options.silent) {
+	          throw new Error('Cannot import "' + name + '": already exists');
+	        }
+	      };
+
+	      if (factory.lazy !== false) {
+	        lazy(namespace, name, resolver);
+	      }
+	      else {
+	        namespace[name] = resolver();
+	      }
+
+	      math.emit('import', name, resolver, factory.path);
+	    }
+	    else {
+	      // unnamed factory.
+	      // no lazy loading
+	      load(factory);
+	    }
+	  }
+
+	  /**
+	   * Check whether given object is a type which can be imported
+	   * @param {Function | number | string | boolean | null | Unit | Complex} object
+	   * @return {boolean}
+	   * @private
+	   */
+	  function isSupportedType(object) {
+	    return typeof object == 'function'
+	        || typeof object === 'number'
+	        || typeof object === 'string'
+	        || typeof object === 'boolean'
+	        || object === null
+	        || (object && object.isUnit === true)
+	        || (object && object.isComplex === true)
+	  }
+
+	  /**
+	   * Test whether a given thing is a typed-function
+	   * @param {*} fn
+	   * @return {boolean} Returns true when `fn` is a typed-function
+	   */
+	  function isTypedFunction (fn) {
+	    return typeof fn === 'function' && typeof fn.signatures === 'object';
+	  }
+
+	  return math_import;
+	}
+
+	exports.math = true; // request access to the math namespace as 5th argument of the factory function
+	exports.name = 'import';
+	exports.factory = factory;
+	exports.lazy = true;
+
 
 /***/ },
 /* 11 */
-/***/ function(module, exports, __webpack_require__) {
+/***/ function(module, exports) {
 
 	'use strict';
 
-	var util = __webpack_require__(175),
-
-	    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, name);
-	 *     var b = new Unit(null, name);
-	 *     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} [name]   A unit name like "cm" or "inch". Can include a prefix
-	 */
-	function Unit(value, name) {
-	  if (!(this instanceof Unit)) {
-	    throw new Error('Constructor must be called with the new operator');
-	  }
-
-	  if (value != undefined && !isNumber(value)) {
-	    throw new TypeError('First parameter in Unit constructor must be a number');
-	  }
-	  if (name != undefined && (!isString(name) || name == '')) {
-	    throw new TypeError('Second parameter in Unit constructor must be a string');
-	  }
-
-	  if (name != undefined) {
-	    // find the unit and prefix from the string
-	    var res = _findUnit(name);
-	    if (!res) {
-	      throw new SyntaxError('Unknown unit "' + name + '"');
-	    }
-	    this.unit = res.unit;
-	    this.prefix = res.prefix;
-	  }
-	  else {
-	    this.unit = UNIT_NONE;
-	    this.prefix = PREFIX_NONE;  // link to a list with supported prefixes
-	  }
-
-	  this.value = (value != undefined) ? this._normalize(value) : null;
-	  this.fixPrefix = false; // if true, function format will not search for the
-	                          // best prefix but leave it as initially provided.
-	                          // fixPrefix is set true by the method Unit.to
-	}
-
-	// 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 unitName = '';
-
-	  skipWhitespace();
-	  while (c && c != ' ' && c != '\t') {
-	    unitName += c;
-	    next();
-	  }
-
-	  return unitName || 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(str) {
-	  text = str;
-	  index = -1;
-	  c = '';
-
-	  if (!isString(text)) {
-	    return null;
-	  }
-
-	  next();
-	  skipWhitespace();
-	  var value = parseNumber();
-	  var name;
-	  if (value) {
-	    name = parseUnit();
-
-	    next();
-	    skipWhitespace();
-	    if (c) {
-	      // garbage at the end. not good.
-	      return null;
-	    }
-
-	    if (value && name) {
-	      try {
-	        // constructor will throw an error when unit is not found
-	        return new Unit(Number(value), name);
-	      }
-	      catch (err) {}
-	    }
-	  }
-	  else {
-	    name = parseUnit();
-
-	    next();
-	    skipWhitespace();
-	    if (c) {
-	      // garbage at the end. not good.
-	      return null;
-	    }
-
-	    if (name) {
-	      try {
-	        // constructor will throw an error when unit is not found
-	        return new Unit(null, name);
-	      }
-	      catch (err) {}
-	    }
-	  }
-
-	  return null;
-	};
-
-	/**
-	 * Test whether value is of type Unit
-	 * @param {*} value
-	 * @return {Boolean} isUnit
-	 */
-	Unit.isUnit = function(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;
-	};
-
-	/**
-	 * Denormalize a value, based on its currently set unit
-	 * @param {Number} value
-	 * @param {Number} [prefixValue]    Optional prefix value to be used
-	 * @return {Number} denormalized value
-	 * @private
-	 */
-	Unit.prototype._denormalize = 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 name in UNITS) {
-	    if (UNITS.hasOwnProperty(name)) {
-	      if (string.endsWith(str, name) ) {
-	        var unit = UNITS[name];
-	        var prefixLen = (str.length - 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} name   A string to be tested whether it is a value less unit.
-	 *                        The unit can have prefix, like "cm"
-	 * @return {Boolean}      true if the given string is a unit
-	 */
-	Unit.isValuelessUnit = function (name) {
-	  return (_findUnit(name) != null);
-	};
-
-	/**
-	 * check if this unit has given base unit
-	 * @param {BASE_UNITS | undefined} base
-	 */
-	Unit.prototype.hasBase = function(base) {
-	  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} valuelessUnit   A unit without value. Can have prefix, like "cm"
-	 * @returns {Unit} unit having fixed, specified unit
-	 */
-	Unit.prototype.to = function (valuelessUnit) {
-	  var other;
-	  var value = this.value == null ? this._normalize(1) : this.value;
-	  if (isString(valuelessUnit)) {
-	    other = new Unit(null, valuelessUnit);
-
-	    if (!this.equalBase(other)) {
-	      throw new Error('Units do not match');
-	    }
-
-	    other.value = value;
-	    other.fixPrefix = true;
-	    return other;
-	  }
-	  else if (valuelessUnit instanceof Unit) {
-	    if (!this.equalBase(valuelessUnit)) {
-	      throw new Error('Units do not match');
-	    }
-	    if (valuelessUnit.value !== null) {
-	      throw new Error('Cannot convert to a unit with a value');
-	    }
-
-	    other = valuelessUnit.clone();
-	    other.value = 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 valueless unit
-	 * @param {String | Unit} valuelessUnit    For example 'cm' or 'inch'
-	 * @return {Number} value
-	 */
-	Unit.prototype.toNumber = function (valuelessUnit) {
-	  var other = this.to(valuelessUnit);
-	  return other._denormalize(other.value, other.prefix.value);
-	};
-
-
-	/**
-	 * Get a string representation of the unit.
-	 * @return {String}
-	 */
-	Unit.prototype.toString = function() {
-	  return this.format();
-	};
-
-	/**
-	 * Get a JSON representation of the unit
-	 * @returns {Object} Returns a JSON object structured as:
-	 *                   `{"mathjs": "Unit", "value": 2, "unit": "cm", "fixPrefix": false}`
-	 */
-	Unit.prototype.toJSON = function () {
-	  return {
-	    mathjs: 'Unit',
-	    value: this._denormalize(this.value),
-	    unit: this.prefix.name + this.unit.name,
-	    fixPrefix: this.fixPrefix
-	  };
-	};
-
-	/**
-	 * Instantiate a Unit from a JSON object
-	 * @param {Object} json  A JSON object structured as:
-	 *                       `{"mathjs": "Unit", "value": 2, "unit": "cm", "fixPrefix": false}`
-	 * @return {Unit}
-	 */
-	Unit.fromJSON = function (json) {
-	  var unit = new Unit(json.value, json.unit);
-	  unit.fixPrefix = json.fixPrefix || false;
-	  return unit;
-	};
-
-	/**
-	 * Returns the string representation of the unit.
-	 * @return {String}
-	 */
-	Unit.prototype.valueOf = Unit.prototype.toString;
-
-	/**
-	 * 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(options) {
-	  var value,
-	      str;
-
-	  if (this.value !== null && !this.fixPrefix) {
-	    var bestPrefix = this._bestPrefix();
-	    value = this._denormalize(this.value, bestPrefix.value);
-	    str = number.format(value, options) + ' ';
-	    str += bestPrefix.name + this.unit.name;
-	  }
-	  else {
-	    value = this._denormalize(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},
-	    '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}
-	  },
-	  SQUARED: {
-	    '': {name: '', value: 1, scientific: true},
-
-	    'da': {name: 'da', value: 1e2, scientific: false},
-	    'h': {name: 'h', value: 1e4, scientific: false},
-	    'k': {name: 'k', value: 1e6, scientific: true},
-	    'M': {name: 'M', value: 1e12, scientific: true},
-	    'G': {name: 'G', value: 1e18, scientific: true},
-	    'T': {name: 'T', value: 1e24, scientific: true},
-	    'P': {name: 'P', value: 1e30, scientific: true},
-	    'E': {name: 'E', value: 1e36, scientific: true},
-	    'Z': {name: 'Z', value: 1e42, scientific: true},
-	    'Y': {name: 'Y', value: 1e48, scientific: true},
-
-	    'd': {name: 'd', value: 1e-2, scientific: false},
-	    'c': {name: 'c', value: 1e-4, scientific: false},
-	    'm': {name: 'm', value: 1e-6, scientific: true},
-	    'u': {name: 'u', value: 1e-12, scientific: true},
-	    'n': {name: 'n', value: 1e-18, scientific: true},
-	    'p': {name: 'p', value: 1e-24, scientific: true},
-	    'f': {name: 'f', value: 1e-30, scientific: true},
-	    'a': {name: 'a', value: 1e-36, scientific: true},
-	    'z': {name: 'z', value: 1e-42, scientific: true},
-	    'y': {name: 'y', value: 1e-42, scientific: true}
-	  },
-	  CUBIC: {
-	    '': {name: '', value: 1, scientific: true},
-
-	    'da': {name: 'da', value: 1e3, scientific: false},
-	    'h': {name: 'h', value: 1e6, scientific: false},
-	    'k': {name: 'k', value: 1e9, scientific: true},
-	    'M': {name: 'M', value: 1e18, scientific: true},
-	    'G': {name: 'G', value: 1e27, scientific: true},
-	    'T': {name: 'T', value: 1e36, scientific: true},
-	    'P': {name: 'P', value: 1e45, scientific: true},
-	    'E': {name: 'E', value: 1e54, scientific: true},
-	    'Z': {name: 'Z', value: 1e63, scientific: true},
-	    'Y': {name: 'Y', value: 1e72, scientific: true},
-
-	    'd': {name: 'd', value: 1e-3, scientific: false},
-	    'c': {name: 'c', value: 1e-6, scientific: false},
-	    'm': {name: 'm', value: 1e-9, scientific: true},
-	    'u': {name: 'u', value: 1e-18, scientific: true},
-	    'n': {name: 'n', value: 1e-27, scientific: true},
-	    'p': {name: 'p', value: 1e-36, scientific: true},
-	    'f': {name: 'f', value: 1e-45, scientific: true},
-	    'a': {name: 'a', value: 1e-54, scientific: true},
-	    'z': {name: 'z', value: 1e-63, scientific: true},
-	    'y': {name: 'y', value: 1e-72, scientific: true}
-	  },
-	  BINARY_SHORT: {
-	    '': {name: '', value: 1, scientific: true},
-	    '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},
-
-	    '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: 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},
-
-	    '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)
-	};
-
-	var BASE_UNIT_NONE = {};
-
-	var UNIT_NONE = {name: '', base: BASE_UNIT_NONE, value: 1, offset: 0};
-
-	var UNITS = {
-	  // length
-	  meter: {name: 'meter', base: BASE_UNITS.LENGTH, prefixes: PREFIXES.LONG, value: 1, offset: 0},
-	  inch: {name: 'inch', base: BASE_UNITS.LENGTH, prefixes: PREFIXES.NONE, value: 0.0254, offset: 0},
-	  foot: {name: 'foot', base: BASE_UNITS.LENGTH, prefixes: PREFIXES.NONE, value: 0.3048, offset: 0},
-	  yard: {name: 'yard', base: BASE_UNITS.LENGTH, prefixes: PREFIXES.NONE, value: 0.9144, offset: 0},
-	  mile: {name: 'mile', base: BASE_UNITS.LENGTH, prefixes: PREFIXES.NONE, value: 1609.344, offset: 0},
-	  link: {name: 'link', base: BASE_UNITS.LENGTH, prefixes: PREFIXES.NONE, value: 0.201168, offset: 0},
-	  rod: {name: 'rod', base: BASE_UNITS.LENGTH, prefixes: PREFIXES.NONE, value: 5.029210, offset: 0},
-	  chain: {name: 'chain', base: BASE_UNITS.LENGTH, prefixes: PREFIXES.NONE, value: 20.1168, offset: 0},
-	  angstrom: {name: 'angstrom', base: BASE_UNITS.LENGTH, prefixes: PREFIXES.NONE, value: 1e-10, offset: 0},
-
-	  m: {name: 'm', base: BASE_UNITS.LENGTH, prefixes: PREFIXES.SHORT, value: 1, offset: 0},
-	  'in': {name: 'in', base: BASE_UNITS.LENGTH, prefixes: PREFIXES.NONE, value: 0.0254, offset: 0},
-	  ft: {name: 'ft', base: BASE_UNITS.LENGTH, prefixes: PREFIXES.NONE, value: 0.3048, offset: 0},
-	  yd: {name: 'yd', base: BASE_UNITS.LENGTH, prefixes: PREFIXES.NONE, value: 0.9144, offset: 0},
-	  mi: {name: 'mi', base: BASE_UNITS.LENGTH, prefixes: PREFIXES.NONE, value: 1609.344, offset: 0},
-	  li: {name: 'li', base: BASE_UNITS.LENGTH, prefixes: PREFIXES.NONE, value: 0.201168, offset: 0},
-	  rd: {name: 'rd', base: BASE_UNITS.LENGTH, prefixes: PREFIXES.NONE, value: 5.029210, offset: 0},
-	  ch: {name: 'ch', base: BASE_UNITS.LENGTH, prefixes: PREFIXES.NONE, value: 20.1168, offset: 0},
-	  mil: {name: 'mil', base: BASE_UNITS.LENGTH, prefixes: PREFIXES.NONE, value: 0.0000254, offset: 0}, // 1/1000 inch
-
-	  // Surface
-	  m2: {name: 'm2', base: BASE_UNITS.SURFACE, prefixes: PREFIXES.SQUARED, value: 1, offset: 0},
-	  sqin: {name: 'sqin', base: BASE_UNITS.SURFACE, prefixes: PREFIXES.NONE, value: 0.00064516, offset: 0}, // 645.16 mm2
-	  sqft: {name: 'sqft', base: BASE_UNITS.SURFACE, prefixes: PREFIXES.NONE, value: 0.09290304, offset: 0}, // 0.09290304 m2
-	  sqyd: {name: 'sqyd', base: BASE_UNITS.SURFACE, prefixes: PREFIXES.NONE, value: 0.83612736, offset: 0}, // 0.83612736 m2
-	  sqmi: {name: 'sqmi', base: BASE_UNITS.SURFACE, prefixes: PREFIXES.NONE, value: 2589988.110336, offset: 0}, // 2.589988110336 km2
-	  sqrd: {name: 'sqrd', base: BASE_UNITS.SURFACE, prefixes: PREFIXES.NONE, value: 25.29295, offset: 0}, // 25.29295 m2
-	  sqch: {name: 'sqch', base: BASE_UNITS.SURFACE, prefixes: PREFIXES.NONE, value: 404.6873, offset: 0}, // 404.6873 m2
-	  sqmil: {name: 'sqmil', base: BASE_UNITS.SURFACE, prefixes: PREFIXES.NONE, value: 6.4516e-10, offset: 0}, // 6.4516 * 10^-10 m2
-
-	  // Volume
-	  m3: {name: 'm3', base: BASE_UNITS.VOLUME, prefixes: PREFIXES.CUBIC, value: 1, offset: 0},
-	  L: {name: 'L', base: BASE_UNITS.VOLUME, prefixes: PREFIXES.SHORT, value: 0.001, offset: 0}, // litre