Merge lp:~rpadovani/ubuntu-calculator-app/bumpMathJs150122 into lp:ubuntu-calculator-app

[Riccardo Padovani]

Updated math.js to 1.2.0

Bumped math.js to 1.2.0 and added comments to explain diffs

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

PASSED: Continuous integration, rev:72
http://91.189.93.70:8080/job/ubuntu-calculator-app-ci/286/
Executed test runs:
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-vivid/801
        deb: http://91.189.93.70:8080/job/generic-mediumtests-vivid/801/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-calculator-app-vivid-amd64-ci/8

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

review: Approve (continuous-integration)

[Giulio Collura (gcollura)]

It looks good! Thank you!
Approved.

review: Approve

=== modified file 'app/engine/math.js'
--- app/engine/math.js	2015-01-10 18:37:05 +0000
+++ app/engine/math.js	2015-01-22 17:57:11 +0000
@@ -1,4 +1,11 @@
+// All edits done for the Ubuntu Calculator App are preceded by a comment that
+// starts with 'UCA:' and describes the edit
+
+// UCA: add a var to which we will refer to when we include the code in qml
+// in app/ubuntu-calculator-app.qml with import "engine/math.js" as MathJs and
+// then property var mathJs: MathJs.mathJs;
 var mathJs;
+
 /**
  * math.js
  * https://github.com/josdejong/mathjs
@@ -7,8 +14,8 @@
  * It features real and complex numbers, units, matrices, a large set of
  * mathematical functions, and a flexible expression parser.
  *
- * @version 1.1.0
- * @date    2014-11-15
+ * @version 1.2.0
+ * @date    2014-12-25
  *
  * @license
  * Copyright (C) 2013-2014 Jos de Jong <[e-mail]>
@@ -27,6 +34,7 @@
  */
 
 (function webpackUniversalModuleDefinition(root, factory) {
+	// UCA: we delete all exports, we don't need them, and we keep only our var
 	mathJs = factory();
 })(this, function() {
 return /******/ (function(modules) { // webpackBootstrap
@@ -197,7 +205,7 @@
 	  math.create = create;
 
 	  // create a new BigNumber factory for this instance of math.js
-	  var BigNumber = __webpack_require__(142).constructor();
+	  var BigNumber = __webpack_require__(159).constructor();
 
 	  // extend BigNumber with a function clone
 	  if (typeof BigNumber.prototype.clone !== 'function') {
@@ -206,7 +214,7 @@
 	     * @return {BigNumber} clone
 	     */
 	    BigNumber.prototype.clone = function() {
-	      return new BigNumber(this);
+	      return this; // just return itself (a BigNumber is immutable)
 	    };
 	  }
 
@@ -290,9 +298,9 @@
 	  __webpack_require__(58)(math, _config);
 	  __webpack_require__(59)(math, _config);
 	  __webpack_require__(60)(math, _config);
-
-	  // functions - relational
 	  __webpack_require__(61)(math, _config);
+
+	  // functions - bitwise
 	  __webpack_require__(62)(math, _config);
 	  __webpack_require__(63)(math, _config);
 	  __webpack_require__(64)(math, _config);
@@ -319,11 +327,13 @@
 	  __webpack_require__(81)(math, _config);
 	  __webpack_require__(82)(math, _config);
 
-	  // functions - matrix
+	  // functions - logical
 	  __webpack_require__(83)(math, _config);
 	  __webpack_require__(84)(math, _config);
 	  __webpack_require__(85)(math, _config);
 	  __webpack_require__(86)(math, _config);
+
+	  // functions - matrix
 	  __webpack_require__(87)(math, _config);
 	  __webpack_require__(88)(math, _config);
 	  __webpack_require__(89)(math, _config);
@@ -336,32 +346,32 @@
 	  __webpack_require__(96)(math, _config);
 	  __webpack_require__(97)(math, _config);
 	  __webpack_require__(98)(math, _config);
-
-	  // functions - probability
-	  //require('./function/probability/distribution')(math, _config); // TODO: rethink math.distribution
 	  __webpack_require__(99)(math, _config);
 	  __webpack_require__(100)(math, _config);
 	  __webpack_require__(101)(math, _config);
 	  __webpack_require__(102)(math, _config);
+
+	  // functions - probability
+	  //require('./function/probability/distribution')(math, _config); // TODO: rethink math.distribution
 	  __webpack_require__(103)(math, _config);
 	  __webpack_require__(104)(math, _config);
-
-	  // functions - statistics
 	  __webpack_require__(105)(math, _config);
 	  __webpack_require__(106)(math, _config);
 	  __webpack_require__(107)(math, _config);
 	  __webpack_require__(108)(math, _config);
 	  __webpack_require__(109)(math, _config);
+
+	  // functions - relational
 	  __webpack_require__(110)(math, _config);
 	  __webpack_require__(111)(math, _config);
 	  __webpack_require__(112)(math, _config);
-
-	  // functions - trigonometry
 	  __webpack_require__(113)(math, _config);
 	  __webpack_require__(114)(math, _config);
 	  __webpack_require__(115)(math, _config);
 	  __webpack_require__(116)(math, _config);
 	  __webpack_require__(117)(math, _config);
+
+	  // functions - statistics
 	  __webpack_require__(118)(math, _config);
 	  __webpack_require__(119)(math, _config);
 	  __webpack_require__(120)(math, _config);
@@ -370,14 +380,12 @@
 	  __webpack_require__(123)(math, _config);
 	  __webpack_require__(124)(math, _config);
 	  __webpack_require__(125)(math, _config);
+
+	  // functions - trigonometry
 	  __webpack_require__(126)(math, _config);
 	  __webpack_require__(127)(math, _config);
 	  __webpack_require__(128)(math, _config);
-
-	  // functions - units
 	  __webpack_require__(129)(math, _config);
-
-	  // functions - utils
 	  __webpack_require__(130)(math, _config);
 	  __webpack_require__(131)(math, _config);
 	  __webpack_require__(132)(math, _config);
@@ -387,6 +395,23 @@
 	  __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);
+
+	  // functions - units
+	  __webpack_require__(142)(math, _config);
+
+	  // functions - utils
+	  __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);
 
 	  // TODO: deprecated since version 0.25.0, remove some day.
 	  math.ifElse = function () {
@@ -410,7 +435,8 @@
 
 	  // selector (we initialize after all functions are loaded)
 	  math.chaining = {};
-	  math.chaining.Selector = __webpack_require__(28)(math, _config);
+	  math.chaining.Chain = __webpack_require__(28)(math, _config);
+	  math.chaining.Selector = math.chaining.Chain; // TODO: deprecate in v2.0
 
 	  // apply provided configuration options
 	  math.config(_config); // apply the default options
@@ -439,90 +465,17 @@
 	'use strict';
 
 	module.exports = function (math, config) {
-	  var bignumber = __webpack_require__(139);
+	  var bignumber = __webpack_require__(152);
 	  var Complex = __webpack_require__(6);
 	  var BigNumber = math.type.BigNumber;
 
-	  /**
-	   * Calculate BigNumber e
-	   * @returns {BigNumber} Returns e
-	   */
-	  function bigE() {
-	    return new BigNumber(1).exp();
-	  }
-
-	  /**
-	   * Calculate BigNumber golden ratio, phi = (1+sqrt(5))/2
-	   * @returns {BigNumber} Returns phi
-	   */
-	  function bigPhi() {
-	    return new BigNumber(1).plus(new BigNumber(5).sqrt()).div(2);
-	  }
-
-	  /**
-	   * arctan(x) = x - x^3/3 + x^5/5 - x^7/7 + x^9/9 - ...
-	   *           = x - x^2*x^1/3 + x^2*x^3/5 - x^2*x^5/7 + x^2*x^7/9 - ...
-	   * @param {BigNumber} x
-	   * @returns {BigNumber} arc tangent of x
-	   */
-	  function arctan(x) {
-	    var y = x;
-	    var yPrev = NaN;
-	    var x2 = x.times(x);
-	    var num = x;
-	    var sign = -1;
-
-	    for (var k = 3; !y.equals(yPrev); k += 2) {
-	      num = num.times(x2);
-
-	      yPrev = y;
-	      y = (sign > 0) ? y.plus(num.div(k)) : y.minus(num.div(k));
-	      sign = -sign;
-	    }
-
-	    return y;
-	  }
-
-	  /**
-	   * Calculate BigNumber pi.
-	   *
-	   * Uses Machin's formula: pi / 4 = 4 * arctan(1 / 5) - arctan(1 / 239)
-	   * http://milan.milanovic.org/math/english/pi/machin.html
-	   * @returns {BigNumber} Returns pi
-	   */
-	  function bigPi() {
-	    // we calculate pi with a few decimal places extra to prevent round off issues
-	    var Big = BigNumber.constructor({precision: BigNumber.precision + 4});
-	    var pi4th = new Big(4).times(arctan(new Big(1).div(5)))
-	        .minus(arctan(new Big(1).div(239)));
-
-	    // the final pi has the requested number of decimals
-	    return new BigNumber(4).times(pi4th);
-	  }
-
-	  /**
-	   * Calculate BigNumber tau, tau = 2 * pi
-	   * @returns {BigNumber} Returns tau
-	   */
-	  function bigTau() {
-	    // we calculate pi at a slightly higher precision than configured to prevent round off errors
-	    // when multiplying by two in the end
-	    BigNumber.config({precision: config.precision + 2});
-
-	    var pi = bigPi();
-
-	    BigNumber.config({precision: config.precision});
-
-	    return new BigNumber(2).times(pi);
-	  }
-
 	  var big = config.number === 'bignumber';
 
 	  // TODO: in case of support for defineProperty, we can lazy evaluate the BigNumber constants by creating them as properties (calculation of PI is slow for example)
-	  math.pi          = big ? bigPi()  : Math.PI;
-	  math.tau         = big ? bigTau() : Math.PI * 2;
-	  math.e           = big ? bigE()   : Math.E;
-	  math.phi         = big ? bigPhi() : 1.61803398874989484820458683436563811772030917980576286213545; // golden ratio, (1+sqrt(5))/2
+	  math.pi          = big ? bignumber.pi(config.precision)  : Math.PI;
+	  math.tau         = big ? bignumber.tau(config.precision) : Math.PI * 2;
+	  math.e           = big ? bignumber.e(config.precision)   : Math.E;
+	  math.phi         = big ? bignumber.phi(config.precision) : 1.61803398874989484820458683436563811772030917980576286213545; // golden ratio, (1+sqrt(5))/2
 
 	  math.i           = new Complex(0, 1);
 
@@ -531,7 +484,7 @@
 	  math['true']     = true;
 	  math['false']    = false;
 	  math['null']     = null;
-	  math['uninitialized'] = __webpack_require__(140).UNINITIALIZED;
+	  math['uninitialized'] = __webpack_require__(153).UNINITIALIZED;
 
 	  // uppercase constants (for compatibility with built-in Math)
 	  math.E           = math.e;
@@ -544,7 +497,7 @@
 	  math.SQRT2       = big ? new BigNumber(2).sqrt()                      : Math.SQRT2;
 
 	  // meta information
-	  math.version = __webpack_require__(141);
+	  math.version = __webpack_require__(154);
 	};
 
 
@@ -990,10 +943,10 @@
 
 	'use strict';
 
-	exports.ArgumentsError = __webpack_require__(143);
-	exports.DimensionError = __webpack_require__(144);
-	exports.IndexError = __webpack_require__(145);
-	exports.UnsupportedTypeError = __webpack_require__(146);
+	exports.ArgumentsError = __webpack_require__(155);
+	exports.DimensionError = __webpack_require__(156);
+	exports.IndexError = __webpack_require__(157);
+	exports.UnsupportedTypeError = __webpack_require__(158);
 
 	// TODO: implement an InvalidValueError?
 
@@ -1004,7 +957,7 @@
 
 	'use strict';
 
-	var util = __webpack_require__(147),
+	var util = __webpack_require__(160),
 	    Unit = __webpack_require__(10),
 	    number = util.number,
 
@@ -1448,7 +1401,7 @@
 
 	'use strict';
 
-	var util = __webpack_require__(147);
+	var util = __webpack_require__(160);
 
 	var number = util.number;
 	var string = util.string;
@@ -1723,7 +1676,7 @@
 
 	'use strict';
 
-	var util = __webpack_require__(147),
+	var util = __webpack_require__(160),
 
 	    Range = __webpack_require__(7),
 
@@ -1998,8 +1951,8 @@
 
 	'use strict';
 
-	var util = __webpack_require__(147),
-	    DimensionError = __webpack_require__(144),
+	var util = __webpack_require__(160),
+	    DimensionError = __webpack_require__(156),
 
 	    Index = __webpack_require__(8),
 
@@ -2519,7 +2472,7 @@
 
 	'use strict';
 
-	var util = __webpack_require__(147),
+	var util = __webpack_require__(160),
 
 	    number = util.number,
 	    string = util.string,
@@ -2866,6 +2819,7 @@
 	 */
 	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);
 
@@ -2873,7 +2827,7 @@
 	      throw new Error('Units do not match');
 	    }
 
-	    other.value = this.value;
+	    other.value = value;
 	    other.fixPrefix = true;
 	    return other;
 	  }
@@ -2886,7 +2840,7 @@
 	    }
 
 	    other = valuelessUnit.clone();
-	    other.value = this.value;
+	    other.value = value;
 	    other.fixPrefix = true;
 	    return other;
 	  }
@@ -3390,7 +3344,7 @@
 
 	'use strict';
 
-	var util = __webpack_require__(147),
+	var util = __webpack_require__(160),
 	    object = util.object,
 	    string = util.string;
 
@@ -3459,7 +3413,7 @@
 	        res = e;
 	      }
 	      desc += '    ' + expr + '\n';
-	      if (res && !(res instanceof Help)) {
+	      if (res !== undefined && !(res instanceof Help)) {
 	        desc += '        ' + string.format(res, {precision: 14}) + '\n';
 	      }
 	    }
@@ -3535,10 +3489,10 @@
 	// utility methods for arrays and matrices
 	'use strict';
 
-	var util = __webpack_require__(147),
+	var util = __webpack_require__(160),
 
-	    IndexError = __webpack_require__(145),
-	    DimensionError = __webpack_require__(144),
+	    IndexError = __webpack_require__(157),
+	    DimensionError = __webpack_require__(156),
 
 	    Matrix = __webpack_require__(9),
 
@@ -3801,9 +3755,9 @@
 
 	'use strict';
 
-	var util = __webpack_require__(147),
+	var util = __webpack_require__(160),
 
-	    ArgumentsError = __webpack_require__(143),
+	    ArgumentsError = __webpack_require__(155),
 
 	    isString = util.string.isString,
 	    isArray = Array.isArray,
@@ -3816,18 +3770,18 @@
 	    collection = __webpack_require__(13),
 
 	    // scope and nodes
-	    ArrayNode = __webpack_require__(148),
-	    AssignmentNode = __webpack_require__(149),
-	    BlockNode = __webpack_require__(150),
-	    ConditionalNode = __webpack_require__(151),
-	    ConstantNode = __webpack_require__(152),
-	    FunctionAssignmentNode = __webpack_require__(153),
-	    IndexNode = __webpack_require__(154),
-	    OperatorNode = __webpack_require__(155),
-	    FunctionNode = __webpack_require__(156),
-	    RangeNode = __webpack_require__(157),
-	    SymbolNode = __webpack_require__(158),
-	    UpdateNode = __webpack_require__(159);
+	    ArrayNode = __webpack_require__(161),
+	    AssignmentNode = __webpack_require__(162),
+	    BlockNode = __webpack_require__(163),
+	    ConditionalNode = __webpack_require__(164),
+	    ConstantNode = __webpack_require__(165),
+	    FunctionAssignmentNode = __webpack_require__(166),
+	    IndexNode = __webpack_require__(167),
+	    OperatorNode = __webpack_require__(168),
+	    FunctionNode = __webpack_require__(169),
+	    RangeNode = __webpack_require__(170),
+	    SymbolNode = __webpack_require__(171),
+	    UpdateNode = __webpack_require__(172);
 
 	/**
 	 * Parse an expression. Returns a node tree, which can be evaluated by
@@ -3917,7 +3871,11 @@
 	  '%': true,
 	  '^': true,
 	  '.^': true,
+	  '~': true,
 	  '!': true,
+	  '&': true,
+	  '|': true,
+	  '^|': true,
 	  '\'': true,
 	  '=': true,
 	  ':': true,
@@ -3928,14 +3886,22 @@
 	  '<': true,
 	  '>': true,
 	  '<=': true,
-	  '>=': true
+	  '>=': true,
+
+	  '<<': true,
+	  '>>': true,
+	  '>>>': true
 	};
 
 	// map with all named delimiters
 	var NAMED_DELIMITERS = {
 	  'mod': true,
 	  'to': true,
-	  'in': true
+	  'in': true,
+	  'and': true,
+	  'xor': true,
+	  'or': true,
+	  'not': true
 	};
 
 	var extra_nodes = {};             // current extra nodes
@@ -3981,6 +3947,15 @@
 	}
 
 	/**
+	 * Preview the second next character from the expression.
+	 * @return {String} cNext
+	 * @private
+	 */
+	function nextNextPreview() {
+	  return expression.charAt(index + 2);
+	}
+
+	/**
 	 * Get next token in the current string expr.
 	 * The token and token type are available as token and token_type
 	 * @private
@@ -4018,8 +3993,19 @@
 	    return;
 	  }
 
+	  // check for delimiters consisting of 3 characters
+	  var c2 = c + nextPreview();
+	  var c3 = c2 + nextNextPreview();
+	  if (c3.length == 3 && DELIMITERS[c3]) {
+	    token_type = TOKENTYPE.DELIMITER;
+	    token = c3;
+	    next();
+	    next();
+	    next();
+	    return;
+	  }
+
 	  // check for delimiters consisting of 2 characters
-	  var c2 = c + nextPreview();
 	  if (c2.length == 2 && DELIMITERS[c2]) {
 	    token_type = TOKENTYPE.DELIMITER;
 	    token = c2;
@@ -4337,7 +4323,7 @@
 	 * @private
 	 */
 	function parseConditional () {
-	  var node = parseRelational();
+	  var node = parseLogicalOr();
 
 	  while (token == '?') {
 	    // set a conditional level, the range operator will be ignored as long
@@ -4347,14 +4333,14 @@
 	    getTokenSkipNewline();
 
 	    var condition = node;
-	    var trueExpr = parseRelational();
+	    var trueExpr = parseLogicalOr();
 
 	    if (token != ':') throw createSyntaxError('False part of conditional expression expected');
 
 	    conditional_level = null;
 	    getTokenSkipNewline();
 
-	    var falseExpr = parseConditional(); // Note: we don't do parseRelational() here
+	    var falseExpr = parseConditional(); // Note: check for conditional operator again, right associativity
 
 	    node = new ConditionalNode(condition, trueExpr, falseExpr);
 
@@ -4366,66 +4352,100 @@
 	}
 
 	/**
-	 * conditional operators and bitshift
-	 * @return {Node} node
-	 * @private
-	 */
-	/* TODO: implement bitwise conditions. put on right place for precedence
-	function parseBitwiseConditions () {
-	  var node = parseRange();
-
-	   var operators = {
-	   '&' : 'bitwiseand',
-	   '|' : 'bitwiseor',
-	   // todo: bitwise xor?
-	   '<<': 'bitshiftleft',
-	   '>>': 'bitshiftright'
-	   };
-	   while (token in operators) {
-	   var name = token;
-
-	   getTokenSkipNewline();
-	   var params = [node, parseRelational()];
-	   node = new OperatorNode(name, fn, params);
-	   }
-
-	  return node;
-	}
-	*/
-
-	/**
-	 * conditions like and, or, in
-	 * @return {Node} node
-	 * @private
-	 */
-	/* TODO: conditional and, or, in, etc.
-	function parseConditions () {
-	  var node, operators, name, fn, params;
-
-	  node = parseRelational();
-
-	  // TODO: precedence of And above Or?
-	  // TODO: implement a method for unit to number conversion
-	  operators = {
-	     'and' : 'and',
-	     '&&' : 'and',
-	     'or': 'or',
-	     '||': 'or',
-	     'xor': 'xor'
-	  };
-
-	  while (token in operators) {
-	    name = token;
-	    fn = operators[name];
-
-	    getTokenSkipNewline();
-	    params = [node, parseRelational()];
-	    node = new OperatorNode(name, fn, params);
-	  }
-
-	  return node;
-	}
-	*/
+	 * logical or, 'x or y'
+	 * @return {Node} node
+	 * @private
+	 */
+	function parseLogicalOr() {
+	  var node = parseLogicalXor();
+
+	  while (token == 'or') {
+	    getTokenSkipNewline();
+	    node = new OperatorNode('or', 'or', [node, parseLogicalXor()]);
+	  }
+
+	  return node;
+	}
+
+	/**
+	 * logical exclusive or, 'x xor y'
+	 * @return {Node} node
+	 * @private
+	 */
+	function parseLogicalXor() {
+	  var node = parseLogicalAnd();
+
+	  while (token == 'xor') {
+	    getTokenSkipNewline();
+	    node = new OperatorNode('xor', 'xor', [node, parseLogicalAnd()]);
+	  }
+
+	  return node;
+	}
+
+	/**
+	 * logical and, 'x and y'
+	 * @return {Node} node
+	 * @private
+	 */
+	function parseLogicalAnd() {
+	  var node = parseBitwiseOr();
+
+	  while (token == 'and') {
+	    getTokenSkipNewline();
+	    node = new OperatorNode('and', 'and', [node, parseBitwiseOr()]);
+	  }
+
+	  return node;
+	}
+
+	/**
+	 * bitwise or, 'x | y'
+	 * @return {Node} node
+	 * @private
+	 */
+	function parseBitwiseOr() {
+	  var node = parseBitwiseXor();
+
+	  while (token == '|') {
+	    getTokenSkipNewline();
+	    node = new OperatorNode('|', 'bitOr', [node, parseBitwiseXor()]);
+	  }
+
+	  return node;
+	}
+
+	/**
+	 * bitwise exclusive or (xor), 'x ^| y'
+	 * @return {Node} node
+	 * @private
+	 */
+	function parseBitwiseXor() {
+	  var node = parseBitwiseAnd();
+
+	  while (token == '^|') {
+	    getTokenSkipNewline();
+	    node = new OperatorNode('^|', 'bitXor', [node, parseBitwiseAnd()]);
+	  }
+
+	  return node;
+	}
+
+	/**
+	 * bitwise and, 'x & y'
+	 * @return {Node} node
+	 * @private
+	 */
+	function parseBitwiseAnd () {
+	  var node = parseRelational();
+
+	  while (token == '&') {
+	    getTokenSkipNewline();
+	    node = new OperatorNode('&', 'bitAnd', [node, parseRelational()]);
+	  }
+
+	  return node;
+	}
 
 	/**
 	 * relational operators
@@ -4435,7 +4455,7 @@
 	function parseRelational () {
 	  var node, operators, name, fn, params;
 
-	  node = parseConversion();
+	  node = parseShift();
 
 	  operators = {
 	    '==': 'equal',
@@ -4450,6 +4470,34 @@
 	    fn = operators[name];
 
 	    getTokenSkipNewline();
+	    params = [node, parseShift()];
+	    node = new OperatorNode(name, fn, params);
+	  }
+
+	  return node;
+	}
+
+	/**
+	 * Bitwise left shift, bitwise right arithmetic shift, bitwise right logical shift
+	 * @return {Node} node
+	 * @private
+	 */
+	function parseShift () {
+	  var node, operators, name, fn, params;
+
+	  node = parseConversion();
+
+	  operators = {
+	    '<<' : 'leftShift',
+	    '>>' : 'rightArithShift',
+	    '>>>' : 'rightLogShift'
+	  };
+
+	  while (token in operators) {
+	    name = token;
+	    fn = operators[name];
+
+	    getTokenSkipNewline();
 	    params = [node, parseConversion()];
 	    node = new OperatorNode(name, fn, params);
 	  }
@@ -4605,16 +4653,21 @@
 	}
 
 	/**
-	 * Unary plus and minus
+	 * Unary plus and minus, and logical and bitwise not
 	 * @return {Node} node
 	 * @private
 	 */
 	function parseUnary () {
-	  var name, fn, params;
+	  var name, params;
+	  var fn = {
+	    '-': 'unaryMinus',
+	    '+': 'unaryPlus',
+	    '~': 'bitNot',
+	    'not': 'not'
+	  }[token];
 
-	  if (token == '-' || token == '+') {
+	  if (fn) {
 	    name = token;
-	    fn = name == '+' ? 'unaryPlus' : 'unaryMinus';
 
 	    getTokenSkipNewline();
 	    params = [parseUnary()];
@@ -5239,19 +5292,19 @@
 
 	'use strict';
 
-	exports.ArrayNode = __webpack_require__(148);
-	exports.AssignmentNode = __webpack_require__(149);
-	exports.BlockNode = __webpack_require__(150);
-	exports.ConditionalNode = __webpack_require__(151);
-	exports.ConstantNode = __webpack_require__(152);
-	exports.IndexNode = __webpack_require__(154);
-	exports.FunctionAssignmentNode = __webpack_require__(153);
-	exports.FunctionNode = __webpack_require__(156);
-	exports.Node = __webpack_require__(160);
-	exports.OperatorNode = __webpack_require__(155);
-	exports.RangeNode = __webpack_require__(157);
-	exports.SymbolNode = __webpack_require__(158);
-	exports.UpdateNode = __webpack_require__(159);
+	exports.ArrayNode = __webpack_require__(161);
+	exports.AssignmentNode = __webpack_require__(162);
+	exports.BlockNode = __webpack_require__(163);
+	exports.ConditionalNode = __webpack_require__(164);
+	exports.ConstantNode = __webpack_require__(165);
+	exports.IndexNode = __webpack_require__(167);
+	exports.FunctionAssignmentNode = __webpack_require__(166);
+	exports.FunctionNode = __webpack_require__(169);
+	exports.Node = __webpack_require__(173);
+	exports.OperatorNode = __webpack_require__(168);
+	exports.RangeNode = __webpack_require__(170);
+	exports.SymbolNode = __webpack_require__(171);
+	exports.UpdateNode = __webpack_require__(172);
 
 
 /***/ },
@@ -5259,154 +5312,170 @@
 /***/ function(module, exports, __webpack_require__) {
 
 	// constants
-	exports.e = __webpack_require__(164);
-	exports.E = __webpack_require__(164);
-	exports['false'] = __webpack_require__(165);
-	exports.i = __webpack_require__(166);
-	exports['Infinity'] = __webpack_require__(167);
-	exports.LN2 = __webpack_require__(168);
-	exports.LN10 = __webpack_require__(169);
-	exports.LOG2E = __webpack_require__(170);
-	exports.LOG10E = __webpack_require__(171);
-	exports.NaN = __webpack_require__(172);
-	exports['null'] = __webpack_require__(173);
-	exports.pi = __webpack_require__(174);
-	exports.PI = __webpack_require__(174);
-	exports.phi = __webpack_require__(175);
-	exports.SQRT1_2 = __webpack_require__(176);
-	exports.SQRT2 = __webpack_require__(177);
-	exports.tau = __webpack_require__(178);
-	exports['true'] = __webpack_require__(179);
-	exports.version = __webpack_require__(180);
+	exports.e = __webpack_require__(177);
+	exports.E = __webpack_require__(177);
+	exports['false'] = __webpack_require__(178);
+	exports.i = __webpack_require__(179);
+	exports['Infinity'] = __webpack_require__(180);
+	exports.LN2 = __webpack_require__(181);
+	exports.LN10 = __webpack_require__(182);
+	exports.LOG2E = __webpack_require__(183);
+	exports.LOG10E = __webpack_require__(184);
+	exports.NaN = __webpack_require__(185);
+	exports['null'] = __webpack_require__(186);
+	exports.pi = __webpack_require__(187);
+	exports.PI = __webpack_require__(187);
+	exports.phi = __webpack_require__(188);
+	exports.SQRT1_2 = __webpack_require__(189);
+	exports.SQRT2 = __webpack_require__(190);
+	exports.tau = __webpack_require__(191);
+	exports['true'] = __webpack_require__(192);
+	exports.version = __webpack_require__(193);
 
 	// functions - arithmetic
-	exports.abs = __webpack_require__(184);
-	exports.add = __webpack_require__(185);
-	exports.ceil = __webpack_require__(186);
-	exports.cube = __webpack_require__(187);
-	exports.divide = __webpack_require__(188);
-	exports.dotDivide = __webpack_require__(189);
-	exports.dotMultiply = __webpack_require__(190);
-	exports.dotPow = __webpack_require__(191);
-	exports.exp = __webpack_require__(192);
-	exports.fix = __webpack_require__(193);
-	exports.floor = __webpack_require__(194);
-	exports.gcd = __webpack_require__(195);
-	exports.lcm = __webpack_require__(196);
-	exports.log = __webpack_require__(197);
-	exports.log10 = __webpack_require__(198);
-	exports.mod = __webpack_require__(199);
-	exports.multiply = __webpack_require__(200);
-	exports.norm = __webpack_require__(201);
-	exports.nthRoot = __webpack_require__(202);
-	exports.pow = __webpack_require__(203);
-	exports.round = __webpack_require__(204);
-	exports.sign = __webpack_require__(205);
-	exports.sqrt = __webpack_require__(206);
-	exports.square = __webpack_require__(207);
-	exports.subtract = __webpack_require__(208);
-	exports.unaryMinus = __webpack_require__(209);
-	exports.unaryPlus = __webpack_require__(210);
-	exports.xgcd = __webpack_require__(211);
+	exports.abs = __webpack_require__(197);
+	exports.add = __webpack_require__(198);
+	exports.ceil = __webpack_require__(199);
+	exports.cube = __webpack_require__(200);
+	exports.divide = __webpack_require__(201);
+	exports.dotDivide = __webpack_require__(202);
+	exports.dotMultiply = __webpack_require__(203);
+	exports.dotPow = __webpack_require__(204);
+	exports.exp = __webpack_require__(205);
+	exports.fix = __webpack_require__(206);
+	exports.floor = __webpack_require__(207);
+	exports.gcd = __webpack_require__(208);
+	exports.lcm = __webpack_require__(209);
+	exports.log = __webpack_require__(210);
+	exports.log10 = __webpack_require__(211);
+	exports.mod = __webpack_require__(212);
+	exports.multiply = __webpack_require__(213);
+	exports.norm = __webpack_require__(214);
+	exports.nthRoot = __webpack_require__(215);
+	exports.pow = __webpack_require__(216);
+	exports.round = __webpack_require__(217);
+	exports.sign = __webpack_require__(218);
+	exports.sqrt = __webpack_require__(219);
+	exports.square = __webpack_require__(220);
+	exports.subtract = __webpack_require__(221);
+	exports.unaryMinus = __webpack_require__(222);
+	exports.unaryPlus = __webpack_require__(223);
+	exports.xgcd = __webpack_require__(224);
 
-	// functions - relational
-	exports.compare = __webpack_require__(212);
-	exports.deepEqual = __webpack_require__(213);
-	exports['equal'] = __webpack_require__(214);
-	exports.larger = __webpack_require__(215);
-	exports.largerEq = __webpack_require__(216);
-	exports.smaller = __webpack_require__(217);
-	exports.smallerEq = __webpack_require__(218);
-	exports.unequal = __webpack_require__(219);
+	// functions - bitwise
+	exports.bitAnd = __webpack_require__(225);
+	exports.bitNot = __webpack_require__(226);
+	exports.bitOr = __webpack_require__(227);
+	exports.bitXor = __webpack_require__(228);
+	exports.leftShift = __webpack_require__(229);
+	exports.rightArithShift = __webpack_require__(230);
+	exports.rightLogShift = __webpack_require__(231);
 
 	// functions - complex
-	exports.arg = __webpack_require__(220);
-	exports.conj = __webpack_require__(221);
-	exports.re = __webpack_require__(222);
-	exports.im = __webpack_require__(223);
+	exports.arg = __webpack_require__(232);
+	exports.conj = __webpack_require__(233);
+	exports.re = __webpack_require__(234);
+	exports.im = __webpack_require__(235);
 
 	// functions - construction
-	exports.bignumber = __webpack_require__(224);
-	exports['boolean'] = __webpack_require__(225);
-	exports.complex = __webpack_require__(226);
-	exports.index = __webpack_require__(227);
-	exports.matrix = __webpack_require__(228);
-	exports.number = __webpack_require__(229);
-	exports.string = __webpack_require__(230);
-	exports.unit = __webpack_require__(231);
+	exports.bignumber = __webpack_require__(236);
+	exports['boolean'] = __webpack_require__(237);
+	exports.complex = __webpack_require__(238);
+	exports.index = __webpack_require__(239);
+	exports.matrix = __webpack_require__(240);
+	exports.number = __webpack_require__(241);
+	exports.string = __webpack_require__(242);
+	exports.unit = __webpack_require__(243);
 
 	// functions - expression
-	exports['eval'] =  __webpack_require__(232);
-	exports.help =  __webpack_require__(233);
+	exports['eval'] =  __webpack_require__(244);
+	exports.help =  __webpack_require__(245);
+
+	// functions - logical
+	exports['and'] = __webpack_require__(246);
+	exports['not'] = __webpack_require__(247);
+	exports['or'] = __webpack_require__(248);
+	exports['xor'] = __webpack_require__(249);
 
 	// functions - matrix
-	exports['concat'] = __webpack_require__(234);
-	exports.cross = __webpack_require__(235);
-	exports.det = __webpack_require__(236);
-	exports.diag = __webpack_require__(237);
-	exports.dot = __webpack_require__(238);
-	exports.eye = __webpack_require__(239);
-	exports.flatten = __webpack_require__(240);
-	exports.inv = __webpack_require__(241);
-	exports.ones = __webpack_require__(242);
-	exports.range = __webpack_require__(243);
-	exports.resize = __webpack_require__(244);
-	exports.size = __webpack_require__(245);
-	exports.squeeze = __webpack_require__(246);
-	exports.subset = __webpack_require__(247);
-	exports.transpose = __webpack_require__(248);
-	exports.zeros = __webpack_require__(249);
+	exports['concat'] = __webpack_require__(250);
+	exports.cross = __webpack_require__(251);
+	exports.det = __webpack_require__(252);
+	exports.diag = __webpack_require__(253);
+	exports.dot = __webpack_require__(254);
+	exports.eye = __webpack_require__(255);
+	exports.flatten = __webpack_require__(256);
+	exports.inv = __webpack_require__(257);
+	exports.ones = __webpack_require__(258);
+	exports.range = __webpack_require__(259);
+	exports.resize = __webpack_require__(260);
+	exports.size = __webpack_require__(261);
+	exports.squeeze = __webpack_require__(262);
+	exports.subset = __webpack_require__(263);
+	exports.transpose = __webpack_require__(264);
+	exports.zeros = __webpack_require__(265);
 
 	// functions - probability
-	exports.combinations = __webpack_require__(250);
+	exports.combinations = __webpack_require__(266);
 	//exports.distribution = require('./function/probability/distribution');
-	exports.factorial = __webpack_require__(251);
-	exports.permutations = __webpack_require__(252);
-	exports.pickRandom = __webpack_require__(253);
-	exports.random = __webpack_require__(254);
-	exports.randomInt = __webpack_require__(255);
+	exports.factorial = __webpack_require__(267);
+	exports.gamma = __webpack_require__(268);
+	exports.permutations = __webpack_require__(269);
+	exports.pickRandom = __webpack_require__(270);
+	exports.random = __webpack_require__(271);
+	exports.randomInt = __webpack_require__(272);
+
+	// functions - relational
+	exports.compare = __webpack_require__(273);
+	exports.deepEqual = __webpack_require__(274);
+	exports['equal'] = __webpack_require__(275);
+	exports.larger = __webpack_require__(276);
+	exports.largerEq = __webpack_require__(277);
+	exports.smaller = __webpack_require__(278);
+	exports.smallerEq = __webpack_require__(279);
+	exports.unequal = __webpack_require__(280);
 
 	// functions - statistics
-	exports.max = __webpack_require__(256);
-	exports.mean = __webpack_require__(257);
-	exports.median = __webpack_require__(258);
-	exports.min = __webpack_require__(259);
-	exports.prod = __webpack_require__(260);
-	exports.std = __webpack_require__(261);
-	exports.sum = __webpack_require__(262);
-	exports['var'] = __webpack_require__(263);
+	exports.max = __webpack_require__(281);
+	exports.mean = __webpack_require__(282);
+	exports.median = __webpack_require__(283);
+	exports.min = __webpack_require__(284);
+	exports.prod = __webpack_require__(285);
+	exports.std = __webpack_require__(286);
+	exports.sum = __webpack_require__(287);
+	exports['var'] = __webpack_require__(288);
 
 	// functions - trigonometry
-	exports.acos = __webpack_require__(264);
-	exports.asin = __webpack_require__(265);
-	exports.atan = __webpack_require__(266);
-	exports.atan2 = __webpack_require__(267);
-	exports.cos = __webpack_require__(268);
-	exports.cosh = __webpack_require__(269);
-	exports.cot = __webpack_require__(270);
-	exports.coth = __webpack_require__(271);
-	exports.csc = __webpack_require__(272);
-	exports.csch = __webpack_require__(273);
-	exports.sec = __webpack_require__(274);
-	exports.sech = __webpack_require__(275);
-	exports.sin = __webpack_require__(276);
-	exports.sinh = __webpack_require__(277);
-	exports.tan = __webpack_require__(278);
-	exports.tanh = __webpack_require__(279);
+	exports.acos = __webpack_require__(289);
+	exports.asin = __webpack_require__(290);
+	exports.atan = __webpack_require__(291);
+	exports.atan2 = __webpack_require__(292);
+	exports.cos = __webpack_require__(293);
+	exports.cosh = __webpack_require__(294);
+	exports.cot = __webpack_require__(295);
+	exports.coth = __webpack_require__(296);
+	exports.csc = __webpack_require__(297);
+	exports.csch = __webpack_require__(298);
+	exports.sec = __webpack_require__(299);
+	exports.sech = __webpack_require__(300);
+	exports.sin = __webpack_require__(301);
+	exports.sinh = __webpack_require__(302);
+	exports.tan = __webpack_require__(303);
+	exports.tanh = __webpack_require__(304);
 
 	// functions - units
-	exports.to = __webpack_require__(280);
+	exports.to = __webpack_require__(305);
 
 	// functions - utils
-	exports.clone =  __webpack_require__(281);
-	exports.map =  __webpack_require__(282);
-	exports.filter =  __webpack_require__(283);
-	exports.forEach =  __webpack_require__(284);
-	exports.format =  __webpack_require__(285);
+	exports.clone =  __webpack_require__(306);
+	exports.map =  __webpack_require__(307);
+	exports.filter =  __webpack_require__(308);
+	exports.forEach =  __webpack_require__(309);
+	exports.format =  __webpack_require__(310);
 	// exports.print =  require('./function/utils/print'); // TODO: add documentation for print as soon as the parser supports objects.
-	exports['import'] =  __webpack_require__(286);
-	exports.sort =  __webpack_require__(287);
-	exports['typeof'] =  __webpack_require__(288);
+	exports['import'] =  __webpack_require__(311);
+	exports.sort =  __webpack_require__(312);
+	exports['typeof'] =  __webpack_require__(313);
 
 
 /***/ },
@@ -5415,10 +5484,10 @@
 
 	'use strict';
 
-	var BigNumber = __webpack_require__(142);
-	var errorTransform = __webpack_require__(161).transform;
+	var BigNumber = __webpack_require__(159);
+	var errorTransform = __webpack_require__(174).transform;
 	var isNumber = __webpack_require__(4).isNumber;
-	var argsToArray = __webpack_require__(140).argsToArray;
+	var argsToArray = __webpack_require__(153).argsToArray;
 
 	/**
 	 * Attach a transform function to math.range
@@ -5459,10 +5528,10 @@
 
 	'use strict';
 
-	var SymbolNode = __webpack_require__(158);
-	var isBoolean = __webpack_require__(162).isBoolean;
-	var argsToArray = __webpack_require__(140).argsToArray;
-	var ArgumentsError = __webpack_require__(143);
+	var SymbolNode = __webpack_require__(171);
+	var isBoolean = __webpack_require__(175).isBoolean;
+	var argsToArray = __webpack_require__(153).argsToArray;
+	var ArgumentsError = __webpack_require__(155);
 
 	/**
 	 * Attach a transform function to math.filter
@@ -5574,7 +5643,7 @@
 
 	'use strict';
 
-	var BigNumber = __webpack_require__(142);
+	var BigNumber = __webpack_require__(159);
 	var Range = __webpack_require__(7);
 	var Index = __webpack_require__(8);
 	var Matrix = __webpack_require__(9);
@@ -5626,7 +5695,7 @@
 	'use strict';
 
 	var Matrix = __webpack_require__(9);
-	var BigNumber = __webpack_require__(142);
+	var BigNumber = __webpack_require__(159);
 	var Range = __webpack_require__(7);
 	var Index = __webpack_require__(8);
 	var isNumber = __webpack_require__(4).isNumber;
@@ -5678,11 +5747,11 @@
 
 	'use strict';
 
-	var BigNumber = __webpack_require__(142);
-	var errorTransform = __webpack_require__(161).transform;
+	var BigNumber = __webpack_require__(159);
+	var errorTransform = __webpack_require__(174).transform;
 	var isNumber = __webpack_require__(4).isNumber;
 	var isCollection = __webpack_require__(13).isCollection;
-	var argsToArray = __webpack_require__(140).argsToArray;
+	var argsToArray = __webpack_require__(153).argsToArray;
 
 	/**
 	 * Attach a transform function to math.max
@@ -5723,11 +5792,11 @@
 
 	'use strict';
 
-	var BigNumber = __webpack_require__(142);
-	var errorTransform = __webpack_require__(161).transform;
+	var BigNumber = __webpack_require__(159);
+	var errorTransform = __webpack_require__(174).transform;
 	var isNumber = __webpack_require__(4).isNumber;
 	var isCollection = __webpack_require__(13).isCollection;
-	var argsToArray = __webpack_require__(140).argsToArray;
+	var argsToArray = __webpack_require__(153).argsToArray;
 
 	/**
 	 * Attach a transform function to math.mean
@@ -5768,11 +5837,11 @@
 
 	'use strict';
 
-	var BigNumber = __webpack_require__(142);
-	var errorTransform = __webpack_require__(161).transform;
+	var BigNumber = __webpack_require__(159);
+	var errorTransform = __webpack_require__(174).transform;
 	var isNumber = __webpack_require__(4).isNumber;
 	var isCollection = __webpack_require__(13).isCollection;
-	var argsToArray = __webpack_require__(140).argsToArray;
+	var argsToArray = __webpack_require__(153).argsToArray;
 
 	/**
 	 * Attach a transform function to math.min
@@ -5813,8 +5882,8 @@
 
 	'use strict';
 
-	var isBoolean = __webpack_require__(162).isBoolean;
-	var argsToArray = __webpack_require__(140).argsToArray;
+	var isBoolean = __webpack_require__(175).isBoolean;
+	var argsToArray = __webpack_require__(153).argsToArray;
 
 	/**
 	 * Attach a transform function to math.range
@@ -5844,9 +5913,9 @@
 
 	'use strict';
 
-	var errorTransform = __webpack_require__(161).transform;
-	var isBoolean = __webpack_require__(162).isBoolean;
-	var argsToArray = __webpack_require__(140).argsToArray;
+	var errorTransform = __webpack_require__(174).transform;
+	var isBoolean = __webpack_require__(175).isBoolean;
+	var argsToArray = __webpack_require__(153).argsToArray;
 
 	/**
 	 * Attach a transform function to math.subset
@@ -5874,32 +5943,32 @@
 	'use strict';
 
 	module.exports = function (math) {
-	  var string = __webpack_require__(163);
+	  var string = __webpack_require__(176);
 
 	  /**
-	   * @constructor Selector
-	   * Wrap any value in a Selector, allowing to perform chained operations on
+	   * @constructor Chain
+	   * Wrap any value in a chain, allowing to perform chained operations on
 	   * the value.
 	   *
-	   * All methods available in the math.js library can be called upon the selector,
+	   * All methods available in the math.js library can be called upon the chain,
 	   * and then will be evaluated with the value itself as first argument.
-	   * The selector can be closed by executing selector.done(), which will return
+	   * The chain can be closed by executing chain.done(), which will return
 	   * the final value.
 	   *
-	   * The Selector has a number of special functions:
+	   * The Chain has a number of special functions:
 	   * - done()             Finalize the chained operation and return the
-	   *                      selectors value.
+	   *                      chain's value.
 	   * - valueOf()          The same as done()
-	   * - toString()         Returns a string representation of the selectors value.
+	   * - toString()         Returns a string representation of the chain's value.
 	   *
 	   * @param {*} [value]
 	   */
-	  function Selector (value) {
-	    if (!(this instanceof Selector)) {
+	  function Chain (value) {
+	    if (!(this instanceof Chain)) {
 	      throw new SyntaxError('Constructor must be called with the new operator');
 	    }
 
-	    if (value instanceof Selector) {
+	    if (value instanceof Chain) {
 	      this.value = value.value;
 	    }
 	    else {
@@ -5908,33 +5977,33 @@
 	  }
 
 	  /**
-	   * Close the selector. Returns the final value.
+	   * Close the chain. Returns the final value.
 	   * Does the same as method valueOf()
 	   * @returns {*} value
 	   */
-	  Selector.prototype.done = function () {
+	  Chain.prototype.done = function () {
 	    return this.value;
 	  };
 
 	  /**
-	   * Close the selector. Returns the final value.
+	   * Close the chain. Returns the final value.
 	   * Does the same as method done()
 	   * @returns {*} value
 	   */
-	  Selector.prototype.valueOf = function () {
+	  Chain.prototype.valueOf = function () {
 	    return this.value;
 	  };
 
 	  /**
-	   * Get a string representation of the value in the selector
+	   * Get a string representation of the value in the chain
 	   * @returns {String}
 	   */
-	  Selector.prototype.toString = function () {
+	  Chain.prototype.toString = function () {
 	    return string.format(this.value);
 	  };
 
 	  /**
-	   * Create a proxy method for the selector
+	   * Create a proxy method for the chain
 	   * @param {String} name
 	   * @param {*} value       The value or function to be proxied
 	   */
@@ -5942,18 +6011,18 @@
 	    var slice = Array.prototype.slice;
 	    if (typeof value === 'function') {
 	      // a function
-	      Selector.prototype[name] = function () {
+	      Chain.prototype[name] = function () {
 	        var args = [this.value].concat(slice.call(arguments, 0));
-	        return new Selector(value.apply(this, args));
+	        return new Chain(value.apply(this, args));
 	      }
 	    }
 	    else {
 	      // a constant
-	      Selector.prototype[name] = new Selector(value);
+	      Chain.prototype[name] = new Chain(value);
 	    }
 	  }
 
-	  Selector.createProxy = createProxy;
+	  Chain.createProxy = createProxy;
 
 	  /**
 	   * initialise the Chain prototype with all functions and constants in math
@@ -5964,7 +6033,7 @@
 	    }
 	  }
 
-	  return Selector;
+	  return Chain;
 	};
 
 
@@ -5975,7 +6044,7 @@
 	'use strict';
 
 	module.exports = function (math, config) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 	      _parse = __webpack_require__(14),
 
 	      collection = __webpack_require__(13),
@@ -6047,7 +6116,7 @@
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 	      _parse = __webpack_require__(14),
 
 	      collection = __webpack_require__(13),
@@ -6176,7 +6245,9 @@
 	    }
 
 	    var doc = math.expression.docs[text];
-	    if (!text || !doc) {
+	    if (!text) {
+	      throw new Error('Cannot find "' + search + '" in math.js');
+	    } else if (!doc) {
 	      throw new Error('No documentation found on "' + text + '"');
 	    }
 	    return new Help(math, doc);
@@ -6239,7 +6310,7 @@
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Complex = __webpack_require__(6),
@@ -6312,7 +6383,7 @@
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Complex = __webpack_require__(6),
@@ -6474,7 +6545,7 @@
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Complex = __webpack_require__(6),
@@ -6553,7 +6624,7 @@
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Complex = __webpack_require__(6),
@@ -6625,19 +6696,141 @@
 	'use strict';
 
 	module.exports = function(math) {
-	  var util = __webpack_require__(147),
-
-	      BigNumber = math.type.BigNumber,
-	      Complex = __webpack_require__(6),
-	      Matrix = __webpack_require__(9),
-	      Unit = __webpack_require__(10),
-	      collection = __webpack_require__(13),
-
-	      isNumber = util.number.isNumber,
-	      isBoolean = util['boolean'].isBoolean,
-	      isComplex = Complex.isComplex,
-	      isUnit = Unit.isUnit,
-	      isCollection = collection.isCollection;
+	  var util = __webpack_require__(160);
+
+	  var BigNumber = math.type.BigNumber;
+	  var Complex = __webpack_require__(6);
+	  var Matrix = __webpack_require__(9);
+	  var Unit = __webpack_require__(10);
+
+	  var isNumber = util.number.isNumber;
+	  var isBoolean = util['boolean'].isBoolean;
+	  var isComplex = Complex.isComplex;
+	  var isUnit = Unit.isUnit;
+
+	  /**
+	   * Divide two scalar values, `x / y`.
+	   * This function is meant for internal use: it is used by the public functions
+	   * `divide` and `inv`.
+	   *
+	   * This function does not support collections (Array or Matrix), and does
+	   * not validate the number of of inputs.
+	   *
+	   * @param  {Number | BigNumber | Boolean | Complex | Unit | null} x   Numerator
+	   * @param  {Number | BigNumber | Boolean | Complex | null} y          Denominator
+	   * @return {Number | BigNumber | Complex | Unit}                      Quotient, `x / y`
+	   * @private
+	   */
+	  math._divide = function _divide(x, y) {
+	    // TODO: this is a temporary function, to be removed as soon as the library is modularized (i.e. no dependencies on math from the individual functions)
+	    if (isNumber(x)) {
+	      if (isNumber(y)) {
+	        // number / number
+	        return x / y;
+	      }
+	      else if (isComplex(y)) {
+	        // number / complex
+	        return _divideComplex(new Complex(x, 0), y);
+	      }
+	    }
+
+	    if (isComplex(x)) {
+	      if (isComplex(y)) {
+	        // complex / complex
+	        return _divideComplex(x, y);
+	      }
+	      else if (isNumber(y)) {
+	        // complex / number
+	        return _divideComplex(x, new Complex(y, 0));
+	      }
+	    }
+
+	    if (x instanceof BigNumber) {
+	      // try to convert to big number
+	      if (isNumber(y)) {
+	        y = BigNumber.convert(y);
+	      }
+	      else if (isBoolean(y) || y === null) {
+	        y = new BigNumber(y ? 1 : 0);
+	      }
+
+	      if (y instanceof BigNumber) {
+	        return x.div(y);
+	      }
+
+	      // downgrade to Number
+	      return _divide(x.toNumber(), y);
+	    }
+	    if (y instanceof BigNumber) {
+	      // try to convert to big number
+	      if (isNumber(x)) {
+	        x = BigNumber.convert(x);
+	      }
+	      else if (isBoolean(x) || x === null) {
+	        x = new BigNumber(x ? 1 : 0);
+	      }
+
+	      if (x instanceof BigNumber) {
+	        return x.div(y)
+	      }
+
+	      // downgrade to Number
+	      return _divide(x, y.toNumber());
+	    }
+
+	    if (isUnit(x)) {
+	      if (isNumber(y)) {
+	        var res = x.clone();
+	        res.value = ((res.value === null) ? res._normalize(1) : res.value) / y;
+	        return res;
+	      }
+	    }
+
+	    if (isBoolean(x) || x === null) {
+	      return _divide(+x, y);
+	    }
+	    if (isBoolean(y) || y === null) {
+	      return _divide(x, +y);
+	    }
+
+	    throw new math.error.UnsupportedTypeError('divide', math['typeof'](x), math['typeof'](y));
+	  };
+
+	  /**
+	   * Divide two complex numbers. x / y or divide(x, y)
+	   * @param {Complex} x
+	   * @param {Complex} y
+	   * @return {Complex} res
+	   * @private
+	   */
+	  function _divideComplex (x, y) {
+	    var den = y.re * y.re + y.im * y.im;
+	    if (den != 0) {
+	      return new Complex(
+	          (x.re * y.re + x.im * y.im) / den,
+	          (x.im * y.re - x.re * y.im) / den
+	      );
+	    }
+	    else {
+	      // both y.re and y.im are zero
+	      return new Complex(
+	          (x.re != 0) ? (x.re / 0) : 0,
+	          (x.im != 0) ? (x.im / 0) : 0
+	      );
+	    }
+	  }
+	};
+
+
+/***/ },
+/* 38 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	module.exports = function(math) {
+	  var collection = __webpack_require__(13);
+	  var isCollection = collection.isCollection;
 
 	  /**
 	   * Divide two values, `x / y`.
@@ -6670,74 +6863,11 @@
 	   * @param  {Number | BigNumber | Boolean | Complex | Array | Matrix | null} y          Denominator
 	   * @return {Number | BigNumber | Complex | Unit | Array | Matrix}                      Quotient, `x / y`
 	   */
-	  math.divide = function divide(x, y) {
+	  math.divide = function(x, y) {
 	    if (arguments.length != 2) {
 	      throw new math.error.ArgumentsError('divide', arguments.length, 2);
 	    }
 
-	    if (isNumber(x)) {
-	      if (isNumber(y)) {
-	        // number / number
-	        return x / y;
-	      }
-	      else if (isComplex(y)) {
-	        // number / complex
-	        return _divideComplex(new Complex(x, 0), y);
-	      }
-	    }
-
-	    if (isComplex(x)) {
-	      if (isComplex(y)) {
-	        // complex / complex
-	        return _divideComplex(x, y);
-	      }
-	      else if (isNumber(y)) {
-	        // complex / number
-	        return _divideComplex(x, new Complex(y, 0));
-	      }
-	    }
-
-	    if (x instanceof BigNumber) {
-	      // try to convert to big number
-	      if (isNumber(y)) {
-	        y = BigNumber.convert(y);
-	      }
-	      else if (isBoolean(y) || y === null) {
-	        y = new BigNumber(y ? 1 : 0);
-	      }
-
-	      if (y instanceof BigNumber) {
-	        return x.div(y);
-	      }
-
-	      // downgrade to Number
-	      return divide(x.toNumber(), y);
-	    }
-	    if (y instanceof BigNumber) {
-	      // try to convert to big number
-	      if (isNumber(x)) {
-	        x = BigNumber.convert(x);
-	      }
-	      else if (isBoolean(x) || x === null) {
-	        x = new BigNumber(x ? 1 : 0);
-	      }
-
-	      if (x instanceof BigNumber) {
-	        return x.div(y)
-	      }
-
-	      // downgrade to Number
-	      return divide(x, y.toNumber());
-	    }
-
-	    if (isUnit(x)) {
-	      if (isNumber(y)) {
-	        var res = x.clone();
-	        res.value /= y;
-	        return res;
-	      }
-	    }
-
 	    if (isCollection(x)) {
 	      if (isCollection(y)) {
 	        // TODO: implement matrix right division using pseudo inverse
@@ -6748,7 +6878,7 @@
 	      }
 	      else {
 	        // matrix / scalar
-	        return collection.deepMap2(x, y, divide);
+	        return collection.deepMap2(x, y, math._divide);
 	      }
 	    }
 
@@ -6757,44 +6887,14 @@
 	      return math.multiply(x, math.inv(y));
 	    }
 
-	    if (isBoolean(x) || x === null) {
-	      return divide(+x, y);
-	    }
-	    if (isBoolean(y) || y === null) {
-	      return divide(x, +y);
-	    }
-
-	    throw new math.error.UnsupportedTypeError('divide', math['typeof'](x), math['typeof'](y));
+	    // divide two scalars
+	    return math._divide(x, y);
 	  };
-
-	  /**
-	   * Divide two complex numbers. x / y or divide(x, y)
-	   * @param {Complex} x
-	   * @param {Complex} y
-	   * @return {Complex} res
-	   * @private
-	   */
-	  function _divideComplex (x, y) {
-	    var den = y.re * y.re + y.im * y.im;
-	    if (den != 0) {
-	      return new Complex(
-	          (x.re * y.re + x.im * y.im) / den,
-	          (x.im * y.re - x.re * y.im) / den
-	      );
-	    }
-	    else {
-	      // both y.re and y.im are zero
-	      return new Complex(
-	          (x.re != 0) ? (x.re / 0) : 0,
-	          (x.im != 0) ? (x.im / 0) : 0
-	      );
-	    }
-	  }
 	};
 
 
 /***/ },
-/* 38 */
+/* 39 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -6844,13 +6944,13 @@
 
 
 /***/ },
-/* 39 */
+/* 40 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 	      collection = __webpack_require__(13);
 
 	  /**
@@ -6895,13 +6995,13 @@
 
 
 /***/ },
-/* 40 */
+/* 41 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 	      collection = __webpack_require__(13);
 
 	  /**
@@ -6943,13 +7043,13 @@
 
 
 /***/ },
-/* 41 */
+/* 42 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Complex = __webpack_require__(6),
@@ -7024,13 +7124,13 @@
 
 
 /***/ },
-/* 42 */
+/* 43 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Complex = __webpack_require__(6),
@@ -7102,13 +7202,13 @@
 
 
 /***/ },
-/* 43 */
+/* 44 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Complex = __webpack_require__(6),
@@ -7180,13 +7280,13 @@
 
 
 /***/ },
-/* 44 */
+/* 45 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      collection = __webpack_require__(13),
@@ -7327,13 +7427,13 @@
 
 
 /***/ },
-/* 45 */
+/* 46 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      collection = __webpack_require__(13),
@@ -7489,13 +7589,13 @@
 
 
 /***/ },
-/* 46 */
+/* 47 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Complex = __webpack_require__(6),
@@ -7592,13 +7692,13 @@
 
 
 /***/ },
-/* 47 */
+/* 48 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Complex = __webpack_require__(6),
@@ -7680,13 +7780,13 @@
 
 
 /***/ },
-/* 48 */
+/* 49 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      collection = __webpack_require__(13),
@@ -7819,13 +7919,13 @@
 
 
 /***/ },
-/* 49 */
+/* 50 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function(math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Complex = __webpack_require__(6),
@@ -7959,7 +8059,7 @@
 	              throw new RangeError('Dimension mismatch in multiplication. ' +
 	                  'Length of A must match length of B ' +
 	                  '(A is ' + sizeX[0] +
-	                  ', B is ' + sizeY[0] +
+	                  ', B is ' + sizeY[0] + ', ' +
 	                  sizeX[0] + ' != ' + sizeY[0] + ')');
 	            }
 
@@ -8250,15 +8350,15 @@
 
 
 /***/ },
-/* 50 */
+/* 51 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
-	    array = __webpack_require__(140),
+	    array = __webpack_require__(153),
 
 	    BigNumber = math.type.BigNumber,
 	    Complex = __webpack_require__(6),
@@ -8438,13 +8538,13 @@
 
 
 /***/ },
-/* 51 */
+/* 52 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147);
+	  var util = __webpack_require__(160);
 
 	  var BigNumber = math.type.BigNumber;
 	  var collection = __webpack_require__(13);
@@ -8637,13 +8737,13 @@
 
 
 /***/ },
-/* 52 */
+/* 53 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Complex = __webpack_require__(6),
@@ -8723,7 +8823,7 @@
 	      }
 
 	      if (y instanceof BigNumber) {
-	        if (y.isInteger() && !x.isNegative()) {
+	        if (y.isInteger() || !x.isNegative()) {
 	          return x.pow(y);
 	        }
 	        else {
@@ -8821,13 +8921,13 @@
 
 
 /***/ },
-/* 53 */
+/* 54 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Complex = __webpack_require__(6),
@@ -8961,13 +9061,13 @@
 
 
 /***/ },
-/* 54 */
+/* 55 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Complex = __webpack_require__(6),
@@ -9041,13 +9141,13 @@
 
 
 /***/ },
-/* 55 */
+/* 56 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Complex = __webpack_require__(6),
@@ -9147,13 +9247,13 @@
 
 
 /***/ },
-/* 56 */
+/* 57 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Complex = __webpack_require__(6),
@@ -9221,13 +9321,13 @@
 
 
 /***/ },
-/* 57 */
+/* 58 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Complex = __webpack_require__(6),
@@ -9381,13 +9481,13 @@
 
 
 /***/ },
-/* 58 */
+/* 59 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math, config) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Complex = __webpack_require__(6),
@@ -9470,13 +9570,13 @@
 
 
 /***/ },
-/* 59 */
+/* 60 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math, config) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Complex = __webpack_require__(6),
@@ -9550,13 +9650,13 @@
 
 
 /***/ },
-/* 60 */
+/* 61 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math, config) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      Matrix = __webpack_require__(9),
 	      BigNumber = math.type.BigNumber,
@@ -9732,217 +9832,101 @@
 
 
 /***/ },
-/* 61 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	module.exports = function (math, config) {
-	  var util = __webpack_require__(147),
-
-	      BigNumber = math.type.BigNumber,
-	      Complex = __webpack_require__(6),
-	      Unit = __webpack_require__(10),
-	      collection = __webpack_require__(13),
-
-	      isNumber = util.number.isNumber,
-	      nearlyEqual = util.number.nearlyEqual,
-	      isBoolean = util['boolean'].isBoolean,
-	      isString = util.string.isString,
-	      isComplex = Complex.isComplex,
-	      isUnit = Unit.isUnit,
-	      isCollection = collection.isCollection;
-
-	  /**
-	   * Compare two values. Returns 1 when x > y, -1 when x < y, and 0 when x == y.
-	   *
-	   * x and y are considered equal when the relative difference between x and y
-	   * is smaller than the configured epsilon. The function cannot be used to
-	   * compare values smaller than approximately 2.22e-16.
-	   *
-	   * For matrices, the function is evaluated element wise.
-	   *
-	   * Syntax:
-	   *
-	   *    math.compare(x, y)
-	   *
-	   * Examples:
-	   *
-	   *    math.compare(6, 1);           // returns 1
-	   *    math.compare(2, 3);           // returns -1
-	   *    math.compare(7, 7);           // returns 0
-	   *
-	   *    var a = math.unit('5 cm');
-	   *    var b = math.unit('40 mm');
-	   *    math.compare(a, b);           // returns 1
-	   *
-	   *    math.compare(2, [1, 2, 3]);   // returns [1, 0, -1]
-	   *
-	   * See also:
-	   *
-	   *    equal, unequal, smaller, smallerEq, larger, largerEq
-	   *
-	   * @param  {Number | BigNumber | Boolean | Unit | String | Array | Matrix | null} x First value to compare
-	   * @param  {Number | BigNumber | Boolean | Unit | String | Array | Matrix | null} y Second value to compare
-	   * @return {Number | BigNumber | Array | Matrix} Returns the result of the comparison: 1, 0 or -1.
-	   */
-	  math.compare = function compare(x, y) {
-	    if (arguments.length != 2) {
-	      throw new math.error.ArgumentsError('compare', arguments.length, 2);
-	    }
-
-	    if (isNumber(x) && isNumber(y)) {
-	      return nearlyEqual(x, y, config.epsilon) ? 0 : (x > y ? 1 : -1);
-	    }
-
-	    if (x instanceof BigNumber) {
-	      // try to convert to big number
-	      if (isNumber(y)) {
-	        y = BigNumber.convert(y);
-	      }
-	      else if (isBoolean(y) || y === null) {
-	        y = new BigNumber(y ? 1 : 0);
-	      }
-
-	      if (y instanceof BigNumber) {
-	        return new BigNumber(x.cmp(y));
-	      }
-
-	      // downgrade to Number
-	      return compare(x.toNumber(), y);
-	    }
-	    if (y instanceof BigNumber) {
-	      // try to convert to big number
-	      if (isNumber(x)) {
-	        x = BigNumber.convert(x);
-	      }
-	      else if (isBoolean(x) || x === null) {
-	        x = new BigNumber(x ? 1 : 0);
-	      }
-
-	      if (x instanceof BigNumber) {
-	        return new BigNumber(x.cmp(y));
-	      }
-
-	      // downgrade to Number
-	      return compare(x, y.toNumber());
-	    }
-
-	    if ((isUnit(x)) && (isUnit(y))) {
-	      if (!x.equalBase(y)) {
-	        throw new Error('Cannot compare units with different base');
-	      }
-	      return (x.value > y.value) ? 1 : ((x.value < y.value) ? -1 : 0);
-	    }
-
-	    if (isCollection(x) || isCollection(y)) {
-	      return collection.deepMap2(x, y, compare);
-	    }
-
-	    // Note: test strings after testing collections,
-	    // else we can't compare a string with a matrix
-	    if (isString(x) || isString(y)) {
-	      return (x > y) ? 1 : ((x < y) ? -1 : 0);
-	    }
-
-	    if (isBoolean(x) || x === null) {
-	      return compare(+x, y);
-	    }
-	    if (isBoolean(y) || y === null) {
-	      return compare(x, +y);
-	    }
-
-	    if (isComplex(x) || isComplex(y)) {
-	      throw new TypeError('No ordering relation is defined for complex numbers');
-	    }
-
-	    throw new math.error.UnsupportedTypeError('compare', math['typeof'](x), math['typeof'](y));
-	  };
-	};
-
-
-/***/ },
 /* 62 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
-	module.exports = function (math) {
-	  var collection = __webpack_require__(13),
-
+	module.exports = function (math, config) {
+	  var util = __webpack_require__(160),
+
+	      BigNumber = math.type.BigNumber,
+	      Matrix = __webpack_require__(9),
+	      Unit = __webpack_require__(10),
+	      collection = __webpack_require__(13),
+
+	      isBoolean = util['boolean'].isBoolean,
+	      isInteger = util.number.isInteger,
+	      isNumber = util.number.isNumber,
 	      isCollection = collection.isCollection,
-	      isArray = Array.isArray;
+
+	      bigBitAnd = util.bignumber.and;
 
 	  /**
-	   * Test element wise whether two matrices are equal.
-	   * The function accepts both matrices and scalar values.
+	   * Bitwise AND two values, `x & y`.
+	   * For matrices, the function is evaluated element wise.
 	   *
 	   * Syntax:
 	   *
-	   *    math.deepEqual(x, y)
+	   *    math.bitAnd(x, y)
 	   *
 	   * Examples:
 	   *
-	   *    math.deepEqual(2, 4);   // returns false
-	   *
-	   *    a = [2, 5, 1];
-	   *    b = [2, 7, 1];
-	   *
-	   *    math.deepEqual(a, b);   // returns false
-	   *    math.equal(a, b);       // returns [true, false, true]
+	   *    math.bitAnd(53, 131);               // returns Number 1
+	   *
+	   *    math.bitAnd([1, 12, 31], 42);       // returns Array [0, 8, 10]
 	   *
 	   * See also:
 	   *
-	   *    equal, unequal
+	   *    bitNot, bitOr, bitXor, leftShift, rightArithShift, rightLogShift
 	   *
-	   * @param  {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix | null} x First matrix to compare
-	   * @param  {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix | null} y Second matrix to compare
-	   * @return {Number | BigNumber | Complex | Unit | Array | Matrix}
-	   *            Returns true when the input matrices have the same size and each of their elements is equal.
+	   * @param  {Number | BigNumber | Boolean | Array | Matrix | null} x First value to and
+	   * @param  {Number | BigNumber | Boolean | Array | Matrix | null} y Second value to and
+	   * @return {Number | BigNumber | Array | Matrix} AND of `x` and `y`
 	   */
-	  math.deepEqual = function deepEqual(x, y) {
+	  math.bitAnd = function bitAnd(x, y) {
 	    if (arguments.length != 2) {
-	      throw new math.error.ArgumentsError('deepEqual', arguments.length, 2);
+	      throw new math.error.ArgumentsError('bitAnd', arguments.length, 2);
+	    }
+
+	    if (isNumber(x) && isNumber(y)) {
+	      if (!isInteger(x) || !isInteger(y)) {
+	        throw new Error('Parameters in function bitAnd must be integer numbers');
+	      }
+
+	      return x & y;
 	    }
 
 	    if (isCollection(x) || isCollection(y)) {
-	      return _deepEqual(x.valueOf(), y.valueOf());
-	    }
-
-	    return math.equal(x, y);
+	      return collection.deepMap2(x, y, bitAnd);
+	    }
+
+	    if (isBoolean(x) || x === null) {
+	      return bitAnd(+x, y);
+	    }
+	    if (isBoolean(y) || y === null) {
+	      return bitAnd(x, +y);
+	    }
+
+	    if (x instanceof BigNumber) {
+	      // try to convert to big number
+	      if (isNumber(y)) {
+	        y = BigNumber.convert(y);
+	      }
+
+	      if (y instanceof BigNumber) {
+	        return bigBitAnd(x, y);
+	      }
+
+	      // downgrade to Number
+	      return bitAnd(x.toNumber(), y);
+	    }
+	    if (y instanceof BigNumber) {
+	      // try to convert to big number
+	      if (isNumber(x)) {
+	        x = BigNumber.convert(x);
+	      }
+
+	      if (x instanceof BigNumber) {
+	        return bigBitAnd(x, y);
+	      }
+
+	      // downgrade to Number
+	      return bitAnd(x, y.toNumber());
+	    }
+
+	    throw new math.error.UnsupportedTypeError('bitAnd', math['typeof'](x), math['typeof'](y));
 	  };
-
-	  /**
-	   * Test whether two arrays have the same size and all elements are equal
-	   * @param {Array | *} x
-	   * @param {Array | *} y
-	   * @return {boolean} Returns true if both arrays are deep equal
-	   */
-	  function _deepEqual(x, y) {
-	    if (isArray(x)) {
-	      if (isArray(y)) {
-	        var len = x.length;
-	        if (len !== y.length) return false;
-
-	        for (var i = 0; i < len; i++) {
-	          if (!_deepEqual(x[i], y[i])) return false;
-	        }
-
-	        return true;
-	      }
-	      else {
-	        return false;
-	      }
-	    }
-	    else {
-	      if (isArray(y)) {
-	        return false;
-	      }
-	      else {
-	        return math.equal(x, y);
-	      }
-	    }
-	  }
 	};
 
 
@@ -9953,159 +9937,68 @@
 	'use strict';
 
 	module.exports = function (math, config) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
-	      Complex = __webpack_require__(6),
+	      Matrix = __webpack_require__(9),
 	      Unit = __webpack_require__(10),
 	      collection = __webpack_require__(13),
 
+	      isBoolean = util['boolean'].isBoolean,
+	      isInteger = util.number.isInteger,
 	      isNumber = util.number.isNumber,
-	      nearlyEqual = util.number.nearlyEqual,
-	      isBoolean = util['boolean'].isBoolean,
-	      isString = util.string.isString,
-	      isComplex = Complex.isComplex,
-	      isUnit = Unit.isUnit,
-	      isCollection = collection.isCollection;
+	      isCollection = collection.isCollection,
+
+	      bigBitNot = util.bignumber.not;
 
 	  /**
-	   * Test whether two values are equal.
-	   *
-	   * The function tests whether the relative difference between x and y is
-	   * smaller than the configured epsilon. The function cannot be used to
-	   * compare values smaller than approximately 2.22e-16.
-	   *
+	   * Bitwise NOT value, `~x`.
 	   * For matrices, the function is evaluated element wise.
-	   * In case of complex numbers, x.re must equal y.re, and x.im must equal y.im.
-	   *
-	   * Values `null` and `undefined` are compared strictly, thus `null` is only
-	   * equal to `null` and nothing else, and `undefined` is only equal to
-	   * `undefined` and nothing else.
+	   * For units, the function is evaluated on the best prefix base.
 	   *
 	   * Syntax:
 	   *
-	   *    math.equal(x, y)
+	   *    math.bitNot(x)
 	   *
 	   * Examples:
 	   *
-	   *    math.equal(2 + 2, 3);         // returns false
-	   *    math.equal(2 + 2, 4);         // returns true
-	   *
-	   *    var a = math.unit('50 cm');
-	   *    var b = math.unit('5 m');
-	   *    math.equal(a, b);             // returns true
-	   *
-	   *    var c = [2, 5, 1];
-	   *    var d = [2, 7, 1];
-	   *
-	   *    math.equal(c, d);             // returns [true, false, true]
-	   *    math.deepEqual(c, d);         // returns false
-	   *
-	   *    math.equal(0, null);          // returns false
+	   *    math.bitNot(1);               // returns Number -2
+	   *
+	   *    math.bitNot([2, -3, 4]);      // returns Array [-3, 2, 5]
 	   *
 	   * See also:
 	   *
-	   *    unequal, smaller, smallerEq, larger, largerEq, compare, deepEqual
+	   *    bitAnd, bitOr, bitXor, leftShift, rightArithShift, rightLogShift
 	   *
-	   * @param  {Number | BigNumber | Boolean | Complex | Unit | String | Array | Matrix | null | undefined} x First value to compare
-	   * @param  {Number | BigNumber | Boolean | Complex | Unit | String | Array | Matrix | null | undefined} y Second value to compare
-	   * @return {Boolean | Array | Matrix} Returns true when the compared values are equal, else returns false
+	   * @param  {Number | BigNumber | Boolean | Array | Matrix | null} x Value to not
+	   * @return {Number | BigNumber | Array | Matrix} NOT of `x`
 	   */
-	  math.equal = function equal(x, y) {
-	    if (arguments.length != 2) {
-	      throw new math.error.ArgumentsError('equal', arguments.length, 2);
+	  math.bitNot = function bitNot(x) {
+	    if (arguments.length != 1) {
+	      throw new math.error.ArgumentsError('bitNot', arguments.length, 1);
 	    }
 
 	    if (isNumber(x)) {
-	      if (isNumber(y)) {
-	        return nearlyEqual(x, y, config.epsilon);
-	      }
-	      else if (isComplex(y)) {
-	        return nearlyEqual(x, y.re, config.epsilon) && nearlyEqual(y.im, 0, config.epsilon);
-	      }
-	    }
+	      if (!isInteger(x)) {
+	        throw new Error('Parameter in function bitNot must be integer numbers');
+	      }
 
-	    if (isComplex(x)) {
-	      if (isNumber(y)) {
-	        return nearlyEqual(x.re, y, config.epsilon) && nearlyEqual(x.im, 0, config.epsilon);
-	      }
-	      else if (isComplex(y)) {
-	        return nearlyEqual(x.re, y.re, config.epsilon) && nearlyEqual(x.im, y.im, config.epsilon);
-	      }
+	      return ~x;
 	    }
 
 	    if (x instanceof BigNumber) {
-	      // try to convert to big number
-	      if (isNumber(y)) {
-	        y = BigNumber.convert(y);
-	      }
-	      else if (isBoolean(y)) {
-	        y = new BigNumber(y ? 1 : 0);
-	      }
-
-	      if (y instanceof BigNumber) {
-	        return x.eq(y);
-	      }
-
-	      // downgrade to Number
-	      return equal(x.toNumber(), y);
-	    }
-	    if (y instanceof BigNumber) {
-	      // try to convert to big number
-	      if (isNumber(x)) {
-	        x = BigNumber.convert(x);
-	      }
-	      else if (isBoolean(x)) {
-	        x = new BigNumber(x ? 1 : 0);
-	      }
-
-	      if (x instanceof BigNumber) {
-	        return x.eq(y);
-	      }
-
-	      // downgrade to Number
-	      return equal(x, y.toNumber());
-	    }
-
-	    if ((isUnit(x)) && (isUnit(y))) {
-	      if (!x.equalBase(y)) {
-	        throw new Error('Cannot compare units with different base');
-	      }
-	      return x.value == y.value;
-	    }
-
-	    if (isCollection(x) || isCollection(y)) {
-	      return collection.deepMap2(x, y, equal);
-	    }
-
-	    // Note: test strings after testing collections,
-	    // else we can accidentally compare a stringified array with a string
-	    if (isString(x) || isString(y)) {
-	      return x == y;
-	    }
-
-	    if (isBoolean(x)) {
-	      return equal(+x, y);
-	    }
-	    if (isBoolean(y)) {
-	      return equal(x, +y);
-	    }
-
-	    if (x === null) {
-	      return y === null;
-	    }
-	    if (y === null) {
-	      return x === null;
-	    }
-
-	    if (x === undefined) {
-	      return y === undefined;
-	    }
-	    if (y === undefined) {
-	      return x === undefined;
-	    }
-
-	    throw new math.error.UnsupportedTypeError('equal', math['typeof'](x), math['typeof'](y));
+	      return bigBitNot(x);
+	    }
+
+	    if (isCollection(x)) {
+	      return collection.deepMap(x, bitNot);
+	    }
+
+	    if (isBoolean(x) || x === null) {
+	      return bitNot(+x);
+	    }
+
+	    throw new math.error.UnsupportedTypeError('bitNot', math['typeof'](x));
 	  };
 	};
 
@@ -10117,58 +10010,65 @@
 	'use strict';
 
 	module.exports = function (math, config) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
-	      Complex = __webpack_require__(6),
+	      Matrix = __webpack_require__(9),
 	      Unit = __webpack_require__(10),
 	      collection = __webpack_require__(13),
 
+	      isBoolean = util['boolean'].isBoolean,
+	      isInteger = util.number.isInteger,
 	      isNumber = util.number.isNumber,
-	      nearlyEqual = util.number.nearlyEqual,
-	      isBoolean = util['boolean'].isBoolean,
-	      isString = util.string.isString,
-	      isComplex = Complex.isComplex,
-	      isUnit = Unit.isUnit,
-	      isCollection = collection.isCollection;
+	      isCollection = collection.isCollection,
+
+	      bigBitOr = util.bignumber.or;
 
 	  /**
-	   * Test whether value x is larger than y.
-	   *
-	   * The function returns true when x is larger than y and the relative
-	   * difference between x and y is larger than the configured epsilon. The
-	   * function cannot be used to compare values smaller than approximately 2.22e-16.
-	   *
+	   * Bitwise OR two values, `x | y`.
 	   * For matrices, the function is evaluated element wise.
+	   * For units, the function is evaluated on the lowest print base.
 	   *
 	   * Syntax:
 	   *
-	   *    math.larger(x, y)
+	   *    math.bitOr(x, y)
 	   *
 	   * Examples:
 	   *
-	   *    math.larger(2, 3);             // returns false
-	   *    math.larger(5, 2 + 2);         // returns true
+	   *    math.bitOr(1, 2);               // returns Number 3
 	   *
-	   *    var a = math.unit('5 cm');
-	   *    var b = math.unit('2 inch');
-	   *    math.larger(a, b);             // returns false
+	   *    math.bitOr([1, 2, 3], 4);       // returns Array [5, 6, 7]
 	   *
 	   * See also:
 	   *
-	   *    equal, unequal, smaller, smallerEq, largerEq, compare
+	   *    bitAnd, bitNot, bitXor, leftShift, rightArithShift, rightLogShift
 	   *
-	   * @param  {Number | BigNumber | Boolean | Unit | String | Array | Matrix | null} x First value to compare
-	   * @param  {Number | BigNumber | Boolean | Unit | String | Array | Matrix | null} y Second value to compare
-	   * @return {Boolean | Array | Matrix} Returns true when the x is larger than y, else returns false
+	   * @param  {Number | BigNumber | Boolean | Array | Matrix | null} x First value to or
+	   * @param  {Number | BigNumber | Boolean | Array | Matrix | null} y Second value to or
+	   * @return {Number | BigNumber | Array | Matrix} OR of `x` and `y`
 	   */
-	  math.larger = function larger(x, y) {
+	  math.bitOr = function bitOr(x, y) {
 	    if (arguments.length != 2) {
-	      throw new math.error.ArgumentsError('larger', arguments.length, 2);
+	      throw new math.error.ArgumentsError('bitOr', arguments.length, 2);
 	    }
 
 	    if (isNumber(x) && isNumber(y)) {
-	      return !nearlyEqual(x, y, config.epsilon) && x > y;
+	      if (!isInteger(x) || !isInteger(y)) {
+	        throw new Error('Parameters in function bitOr must be integer numbers');
+	      }
+
+	      return x | y;
+	    }
+
+	    if (isCollection(x) || isCollection(y)) {
+	      return collection.deepMap2(x, y, bitOr);
+	    }
+
+	    if (isBoolean(x) || x === null) {
+	      return bitOr(+x, y);
+	    }
+	    if (isBoolean(y) || y === null) {
+	      return bitOr(x, +y);
 	    }
 
 	    if (x instanceof BigNumber) {
@@ -10176,63 +10076,29 @@
 	      if (isNumber(y)) {
 	        y = BigNumber.convert(y);
 	      }
-	      else if (isBoolean(y) || y === null) {
-	        y = new BigNumber(y ? 1 : 0);
-	      }
 
 	      if (y instanceof BigNumber) {
-	        return x.gt(y);
+	        return bigBitOr(x, y);
 	      }
 
 	      // downgrade to Number
-	      return larger(x.toNumber(), y);
+	      return bitOr(x.toNumber(), y);
 	    }
 	    if (y instanceof BigNumber) {
 	      // try to convert to big number
 	      if (isNumber(x)) {
 	        x = BigNumber.convert(x);
 	      }
-	      else if (isBoolean(x) || x === null) {
-	        x = new BigNumber(x ? 1 : 0);
-	      }
 
 	      if (x instanceof BigNumber) {
-	        return x.gt(y)
+	        return bigBitOr(x, y);
 	      }
 
 	      // downgrade to Number
-	      return larger(x, y.toNumber());
-	    }
-
-	    if ((isUnit(x)) && (isUnit(y))) {
-	      if (!x.equalBase(y)) {
-	        throw new Error('Cannot compare units with different base');
-	      }
-	      return x.value > y.value;
-	    }
-
-	    if (isCollection(x) || isCollection(y)) {
-	      return collection.deepMap2(x, y, larger);
-	    }
-
-	    // Note: test strings after testing collections,
-	    // else we can't compare a string with a matrix
-	    if (isString(x) || isString(y)) {
-	      return x > y;
-	    }
-
-	    if (isBoolean(x) || x === null) {
-	      return larger(+x, y);
-	    }
-	    if (isBoolean(y) || y === null) {
-	      return larger(x, +y);
-	    }
-
-	    if (isComplex(x) || isComplex(y)) {
-	      throw new TypeError('No ordering relation is defined for complex numbers');
-	    }
-
-	    throw new math.error.UnsupportedTypeError('larger', math['typeof'](x), math['typeof'](y));
+	      return bitOr(x, y.toNumber());
+	    }
+
+	    throw new math.error.UnsupportedTypeError('bitOr', math['typeof'](x), math['typeof'](y));
 	  };
 	};
 
@@ -10244,54 +10110,64 @@
 	'use strict';
 
 	module.exports = function (math, config) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
-	      Complex = __webpack_require__(6),
+	      Matrix = __webpack_require__(9),
 	      Unit = __webpack_require__(10),
 	      collection = __webpack_require__(13),
 
+	      isBoolean = util['boolean'].isBoolean,
+	      isInteger = util.number.isInteger,
 	      isNumber = util.number.isNumber,
-	      nearlyEqual = util.number.nearlyEqual,
-	      isBoolean = util['boolean'].isBoolean,
-	      isString = util.string.isString,
-	      isComplex = Complex.isComplex,
-	      isUnit = Unit.isUnit,
-	      isCollection = collection.isCollection;
+	      isCollection = collection.isCollection,
+
+	      bigBitXor = util.bignumber.xor;
 
 	  /**
-	   * Test whether value x is larger or equal to y.
-	   *
-	   * The function returns true when x is larger than y or the relative
-	   * difference between x and y is smaller than the configured epsilon. The
-	   * function cannot be used to compare values smaller than approximately 2.22e-16.
-	   *
+	   * Bitwise XOR two values, `x ^ y`.
 	   * For matrices, the function is evaluated element wise.
 	   *
 	   * Syntax:
 	   *
-	   *    math.largerEq(x, y)
+	   *    math.bitXor(x, y)
 	   *
 	   * Examples:
 	   *
-	   *    math.larger(2, 1 + 1);         // returns false
-	   *    math.largerEq(2, 1 + 1);       // returns true
+	   *    math.bitXor(1, 2);               // returns Number 3
+	   *
+	   *    math.bitXor([2, 3, 4], 4);       // returns Array [6, 7, 0]
 	   *
 	   * See also:
 	   *
-	   *    equal, unequal, smaller, smallerEq, larger, compare
+	   *    bitAnd, bitNot, bitOr, leftShift, rightArithShift, rightLogShift
 	   *
-	   * @param  {Number | BigNumber | Boolean | Unit | String | Array | Matrix | null} x First value to compare
-	   * @param  {Number | BigNumber | Boolean | Unit | String | Array | Matrix | null} y Second value to compare
-	   * @return {Boolean | Array | Matrix} Returns true when the x is larger or equal to y, else returns false
+	   * @param  {Number | BigNumber | Boolean | Array | Matrix | null} x First value to xor
+	   * @param  {Number | BigNumber | Boolean | Array | Matrix | null} y Second value to xor
+	   * @return {Number | BigNumber | Array | Matrix} XOR of `x` and `y`
 	   */
-	  math.largerEq = function largerEq(x, y) {
+	  math.bitXor = function bitXor(x, y) {
 	    if (arguments.length != 2) {
-	      throw new math.error.ArgumentsError('largerEq', arguments.length, 2);
+	      throw new math.error.ArgumentsError('bitXor', arguments.length, 2);
 	    }
 
 	    if (isNumber(x) && isNumber(y)) {
-	      return nearlyEqual(x, y, config.epsilon) || x > y;
+	      if (!isInteger(x) || !isInteger(y)) {
+	        throw new Error('Parameters in function bitXor must be integer numbers');
+	      }
+
+	      return x ^ y;
+	    }
+
+	    if (isCollection(x) || isCollection(y)) {
+	      return collection.deepMap2(x, y, bitXor);
+	    }
+
+	    if (isBoolean(x) || x === null) {
+	      return bitXor(+x, y);
+	    }
+	    if (isBoolean(y) || y === null) {
+	      return bitXor(x, +y);
 	    }
 
 	    if (x instanceof BigNumber) {
@@ -10299,69 +10175,30 @@
 	      if (isNumber(y)) {
 	        y = BigNumber.convert(y);
 	      }
-	      else if (isBoolean(y) || y === null) {
-	        y = new BigNumber(y ? 1 : 0);
-	      }
 
 	      if (y instanceof BigNumber) {
-	        return x.gte(y);
+	        return bigBitXor(x, y);
 	      }
 
 	      // downgrade to Number
-	      return largerEq(x.toNumber(), y);
+	      return bitXor(x.toNumber(), y);
 	    }
 	    if (y instanceof BigNumber) {
 	      // try to convert to big number
 	      if (isNumber(x)) {
 	        x = BigNumber.convert(x);
 	      }
-	      else if (isBoolean(x) || x === null) {
-	        x = new BigNumber(x ? 1 : 0);
-	      }
 
 	      if (x instanceof BigNumber) {
-	        return x.gte(y)
+	        return bigBitXor(x, y);
 	      }
 
 	      // downgrade to Number
-	      return largerEq(x, y.toNumber());
-	    }
-
-	    if ((isUnit(x)) && (isUnit(y))) {
-	      if (!x.equalBase(y)) {
-	        throw new Error('Cannot compare units with different base');
-	      }
-	      return x.value >= y.value;
-	    }
-
-	    if (isCollection(x) || isCollection(y)) {
-	      return collection.deepMap2(x, y, largerEq);
-	    }
-
-	    // Note: test strings after testing collections,
-	    // else we can't compare a string with a matrix
-	    if (isString(x) || isString(y)) {
-	      return x >= y;
-	    }
-
-	    if (isBoolean(x) || x === null) {
-	      return largerEq(+x, y);
-	    }
-	    if (isBoolean(y) || y === null) {
-	      return largerEq(x, +y);
-	    }
-
-	    if (isComplex(x) || isComplex(y)) {
-	      throw new TypeError('No ordering relation is defined for complex numbers');
-	    }
-
-	    throw new math.error.UnsupportedTypeError('largerEq', math['typeof'](x), math['typeof'](y));
+	      return bitXor(x, y.toNumber());
+	    }
+
+	    throw new math.error.UnsupportedTypeError('bitXor', math['typeof'](x), math['typeof'](y));
 	  };
-
-	  // TODO: deprecated since version 0.23.0, cleanup some day
-	  math.largereq = function () {
-	    throw new Error('Function largereq is renamed to largerEq');
-	  }
 	};
 
 
@@ -10372,122 +10209,117 @@
 	'use strict';
 
 	module.exports = function (math, config) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
-	      Complex = __webpack_require__(6),
+	      Matrix = __webpack_require__(9),
 	      Unit = __webpack_require__(10),
 	      collection = __webpack_require__(13),
 
+	      isBoolean = util['boolean'].isBoolean,
+	      isInteger = util.number.isInteger,
 	      isNumber = util.number.isNumber,
-	      nearlyEqual = util.number.nearlyEqual,
-	      isBoolean = util['boolean'].isBoolean,
-	      isString = util.string.isString,
-	      isComplex = Complex.isComplex,
-	      isUnit = Unit.isUnit,
-	      isCollection = collection.isCollection;
+	      isCollection = collection.isCollection,
+
+	      bigLeftShift = util.bignumber.leftShift;
 
 	  /**
-	   * Test whether value x is smaller than y.
-	   *
-	   * The function returns true when x is smaller than y and the relative
-	   * difference between x and y is larger than the configured epsilon. The
-	   * function cannot be used to compare values smaller than approximately 2.22e-16.
-	   *
+	   * Bitwise left logical shift of a value x by y number of bits, `x << y`.
 	   * For matrices, the function is evaluated element wise.
+	   * For units, the function is evaluated on the best prefix base.
 	   *
 	   * Syntax:
 	   *
-	   *    math.smaller(x, y)
+	   *    math.leftShift(x, y)
 	   *
 	   * Examples:
 	   *
-	   *    math.smaller(2, 3);            // returns true
-	   *    math.smaller(5, 2 * 2);        // returns false
+	   *    math.leftShift(1, 2);               // returns Number 4
 	   *
-	   *    var a = math.unit('5 cm');
-	   *    var b = math.unit('2 inch');
-	   *    math.smaller(a, b);            // returns true
+	   *    math.leftShift([1, 2, 3], 4);       // returns Array [16, 32, 64]
 	   *
 	   * See also:
 	   *
-	   *    equal, unequal, smallerEq, larger, largerEq, compare
+	   *    bitAnd, bitNot, bitOr, bitXor, rightArithShift, rightLogShift
 	   *
-	   * @param  {Number | BigNumber | Boolean | Unit | String | Array | Matrix | null} x First value to compare
-	   * @param  {Number | BigNumber | Boolean | Unit | String | Array | Matrix | null} y Second value to compare
-	   * @return {Boolean | Array | Matrix} Returns true when the x is smaller than y, else returns false
+	   * @param  {Number | BigNumber | Boolean | Array | Matrix | null} x Value to be shifted
+	   * @param  {Number | BigNumber | Boolean | null} y Amount of shifts
+	   * @return {Number | BigNumber | Array | Matrix} `x` shifted left `y` times
 	   */
-	  math.smaller = function smaller(x, y) {
+	  math.leftShift = function leftShift(x, y) {
 	    if (arguments.length != 2) {
-	      throw new math.error.ArgumentsError('smaller', arguments.length, 2);
-	    }
-
-	    if (isNumber(x) && isNumber(y)) {
-	      return !nearlyEqual(x, y, config.epsilon) && x < y;
-	    }
-
-	    if (x instanceof BigNumber) {
-	      // try to convert to big number
+	      throw new math.error.ArgumentsError('leftShift', arguments.length, 2);
+	    }
+
+	    if (isNumber(x)) {
 	      if (isNumber(y)) {
+	        if (!isInteger(x) || !isInteger(y)) {
+	          throw new Error('Parameters in function leftShift must be integer numbers');
+	        }
+
+	        return x << y;
+	      }
+
+	      if (y instanceof BigNumber) {
+	        return bigLeftShift(BigNumber.convert(x), y);
+	      }
+	    }
+	    if (isNumber(y)) {
+	      if (isFinite(y) && !isInteger(y)) {
+	        throw new Error('Parameters in function leftShift must be integer numbers');
+	      }
+
+	      if (x instanceof BigNumber) {
+	        if (x.isFinite() && !x.isInteger()) {
+	          throw new Error('Parameters in function leftShift must be integer numbers');
+	        }
+
+	        if (x.isNaN() || isNaN(y) || y < 0) {
+	          return new BigNumber(NaN);
+	        }
+
+	        if (y == 0 || x.isZero()) {
+	          return x;
+	        }
+	        if (y == Infinity && !x.isFinite()) {
+	          return new BigNumber(NaN);
+	        }
+
+	        // Math.pow(2, y) is fully precise for y < 55, and fast
+	        if (y < 55) {
+	          return x.times(Math.pow(2, y) + '');
+	        }
+
 	        y = BigNumber.convert(y);
-	      }
-	      else if (isBoolean(y) || y === null) {
-	        y = new BigNumber(y ? 1 : 0);
-	      }
-
-	      if (y instanceof BigNumber) {
-	        return x.lt(y);
-	      }
-
-	      // downgrade to Number
-	      return smaller(x.toNumber(), y);
-	    }
-	    if (y instanceof BigNumber) {
-	      // try to convert to big number
-	      if (isNumber(x)) {
-	        x = BigNumber.convert(x);
-	      }
-	      else if (isBoolean(x) || x === null) {
-	        x = new BigNumber(x ? 1 : 0);
-	      }
-
-	      if (x instanceof BigNumber) {
-	        return x.lt(y)
-	      }
-
-	      // downgrade to Number
-	      return smaller(x, y.toNumber());
-	    }
-
-	    if ((isUnit(x)) && (isUnit(y))) {
-	      if (!x.equalBase(y)) {
-	        throw new Error('Cannot compare units with different base');
-	      }
-	      return x.value < y.value;
-	    }
-
-	    if (isCollection(x) || isCollection(y)) {
-	      return collection.deepMap2(x, y, smaller);
-	    }
-
-	    // Note: test strings after testing collections,
-	    // else we can't compare a string with a matrix
-	    if (isString(x) || isString(y)) {
-	      return x < y;
+	        return bigLeftShift(x, y);
+	      }
+	    }
+
+	    if (isCollection(x) && isNumber(y)) {
+	      return collection.deepMap2(x, y, leftShift);
 	    }
 
 	    if (isBoolean(x) || x === null) {
-	      return smaller(+x, y);
+	      return leftShift(+x, y);
 	    }
 	    if (isBoolean(y) || y === null) {
-	      return smaller(x, +y);
-	    }
-
-	    if (isComplex(x) || isComplex(y)) {
-	      throw new TypeError('No ordering relation is defined for complex numbers');
-	    }
-
-	    throw new math.error.UnsupportedTypeError('smaller', math['typeof'](x), math['typeof'](y));
+	      return leftShift(x, +y);
+	    }
+
+	    if (x instanceof BigNumber) {
+	      if (y instanceof BigNumber) {
+	        return bigLeftShift(x, y);
+	      }
+
+	      // downgrade to Number
+	      return leftShift(x.toNumber(), y);
+	    }
+	    if (y instanceof BigNumber) {
+	      // x is probably incompatible with BigNumber
+	      return leftShift(x, y.toNumber());
+	    }
+
+	    throw new math.error.UnsupportedTypeError('leftShift', math['typeof'](x), math['typeof'](y));
 	  };
 	};
 
@@ -10499,123 +10331,120 @@
 	'use strict';
 
 	module.exports = function (math, config) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
-	      Complex = __webpack_require__(6),
+	      Matrix = __webpack_require__(9),
 	      Unit = __webpack_require__(10),
 	      collection = __webpack_require__(13),
 
+	      isBoolean = util['boolean'].isBoolean,
+	      isInteger = util.number.isInteger,
 	      isNumber = util.number.isNumber,
-	      nearlyEqual = util.number.nearlyEqual,
-	      isBoolean = util['boolean'].isBoolean,
-	      isString = util.string.isString,
-	      isComplex = Complex.isComplex,
-	      isUnit = Unit.isUnit,
-	      isCollection = collection.isCollection;
+	      isCollection = collection.isCollection,
+
+	      bigRightShift = util.bignumber.rightShift;
 
 	  /**
-	   * Test whether value x is smaller or equal to y.
-	   *
-	   * The function returns true when x is smaller than y or the relative
-	   * difference between x and y is smaller than the configured epsilon. The
-	   * function cannot be used to compare values smaller than approximately 2.22e-16.
+	   * Bitwise right arithmetic shift of a value x by y number of bits, `x >> y`.
 	   * For matrices, the function is evaluated element wise.
+	   * For units, the function is evaluated on the best prefix base.
 	   *
 	   * Syntax:
 	   *
-	   *    math.smallerEq(x, y)
+	   *    math.rightArithShift(x, y)
 	   *
 	   * Examples:
 	   *
-	   *    math.smaller(1 + 2, 3);        // returns false
-	   *    math.smallerEq(1 + 2, 3);      // returns true
+	   *    math.rightArithShift(4, 2);               // returns Number 1
+	   *
+	   *    math.rightArithShift([16, -32, 64], 4);   // returns Array [1, -2, 3]
 	   *
 	   * See also:
 	   *
-	   *    equal, unequal, smaller, larger, largerEq, compare
+	   *    bitAnd, bitNot, bitOr, bitXor, leftShift, rightLogShift
 	   *
-	   * @param  {Number | BigNumber | Boolean | Unit | String | Array | Matrix | null} x First value to compare
-	   * @param  {Number | BigNumber | Boolean | Unit | String | Array | Matrix | null} y Second value to compare
-	   * @return {Boolean | Array | Matrix} Returns true when the x is smaller than y, else returns false
+	   * @param  {Number | BigNumber | Boolean | Array | Matrix | null} x Value to be shifted
+	   * @param  {Number | BigNumber | Boolean | null} y Amount of shifts
+	   * @return {Number | BigNumber | Array | Matrix} `x` sign-filled shifted right `y` times
 	   */
-	  math.smallerEq = function smallerEq(x, y) {
+	  math.rightArithShift = function rightArithShift(x, y) {
 	    if (arguments.length != 2) {
-	      throw new math.error.ArgumentsError('smallerEq', arguments.length, 2);
-	    }
-
-	    if (isNumber(x) && isNumber(y)) {
-	      return nearlyEqual(x, y, config.epsilon) || x < y;
-	    }
-
-	    if (x instanceof BigNumber) {
-	      // try to convert to big number
+	      throw new math.error.ArgumentsError('rightArithShift', arguments.length, 2);
+	    }
+
+	    if (isNumber(x)) {
 	      if (isNumber(y)) {
+	        if (!isInteger(x) || !isInteger(y)) {
+	          throw new Error('Parameters in function rightArithShift must be integer numbers');
+	        }
+
+	        return x >> y;
+	      }
+
+	      if (y instanceof BigNumber) {
+	        return bigRightShift(BigNumber.convert(x), y);
+	      }
+	    }
+	    if (isNumber(y)) {
+	      if (isFinite(y) && !isInteger(y)) {
+	        throw new Error('Parameters in function rightArithShift must be integer numbers');
+	      }
+
+	      if (x instanceof BigNumber) {
+	        if (x.isFinite() && !x.isInteger()) {
+	          throw new Error('Parameters in function rightArithShift must be integer numbers');
+	        }
+
+	        if (x.isNaN() || isNaN(y) || y < 0) {
+	          return new BigNumber(NaN);
+	        }
+	        if (y == Infinity) {
+	          if (x.isNegative()) {
+	            return new BigNumber(-1);
+	          }
+	          if (!x.isFinite()) {
+	            return new BigNumber(NaN);
+	          }
+	          return new BigNumber(0);
+	        }
+
+	        // Math.pow(2, y) is fully precise for y < 55, and fast
+	        if (y < 55) {
+	          return x.div(Math.pow(2, y) + '').floor();
+	        }
+
 	        y = BigNumber.convert(y);
-	      }
-	      else if (isBoolean(y) || y === null) {
-	        y = new BigNumber(y ? 1 : 0);
-	      }
-
-	      if (y instanceof BigNumber) {
-	        return x.lte(y);
-	      }
-
-	      // downgrade to Number
-	      return smallerEq(x.toNumber(), y);
-	    }
-	    if (y instanceof BigNumber) {
-	      // try to convert to big number
-	      if (isNumber(x)) {
-	        x = BigNumber.convert(x);
-	      }
-	      else if (isBoolean(x) || x === null) {
-	        x = new BigNumber(x ? 1 : 0);
-	      }
-
-	      if (x instanceof BigNumber) {
-	        return x.lte(y)
-	      }
-
-	      // downgrade to Number
-	      return smallerEq(x, y.toNumber());
-	    }
-
-	    if ((isUnit(x)) && (isUnit(y))) {
-	      if (!x.equalBase(y)) {
-	        throw new Error('Cannot compare units with different base');
-	      }
-	      return x.value <= y.value;
-	    }
-
-	    if (isCollection(x) || isCollection(y)) {
-	      return collection.deepMap2(x, y, smallerEq);
-	    }
-
-	    // Note: test strings after testing collections,
-	    // else we can't compare a string with a matrix
-	    if (isString(x) || isString(y)) {
-	      return x <= y;
+	        return bigRightShift(x, y);
+	      }
+	    }
+
+	    if (isCollection(x) && isNumber(y)) {
+	      return collection.deepMap2(x, y, rightArithShift);
 	    }
 
 	    if (isBoolean(x) || x === null) {
-	      return smallerEq(+x, y);
+	      return rightArithShift(+x, y);
 	    }
 	    if (isBoolean(y) || y === null) {
-	      return smallerEq(x, +y);
-	    }
-
-	    if (isComplex(x) || isComplex(y)) {
-	      throw new TypeError('No ordering relation is defined for complex numbers');
-	    }
-
-	    throw new math.error.UnsupportedTypeError('smallerEq', math['typeof'](x), math['typeof'](y));
+	      return rightArithShift(x, +y);
+	    }
+
+	    if (x instanceof BigNumber) {
+	      if (y instanceof BigNumber) {
+	        return bigRightShift(x, y);
+	      }
+
+	      // downgrade to Number
+	      return rightArithShift(x.toNumber(), y);
+	    }
+	    if (y instanceof BigNumber) {
+	      // x is probably incompatible with BigNumber
+	      return rightArithShift(x, y.toNumber());
+	    }
+
+	    throw new math.error.UnsupportedTypeError('rightArithShift', math['typeof'](x), math['typeof'](y));
 	  };
-
-	  // TODO: deprecated since version 0.23.0, cleanup some day
-	  math.smallereq = function () {
-	    throw new Error('Function smallereq is renamed to smallerEq');
-	  }
 	};
 
 
@@ -10626,158 +10455,65 @@
 	'use strict';
 
 	module.exports = function (math, config) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
-	      BigNumber = math.type.BigNumber,
-	      Complex = __webpack_require__(6),
+	      Matrix = __webpack_require__(9),
 	      Unit = __webpack_require__(10),
 	      collection = __webpack_require__(13),
 
+	      isBoolean = util['boolean'].isBoolean,
+	      isInteger = util.number.isInteger,
 	      isNumber = util.number.isNumber,
-	      nearlyEqual = util.number.nearlyEqual,
-	      isBoolean = util['boolean'].isBoolean,
-	      isString = util.string.isString,
-	      isComplex = Complex.isComplex,
-	      isUnit = Unit.isUnit,
 	      isCollection = collection.isCollection;
 
 	  /**
-	   * Test whether two values are unequal.
-	   *
-	   * The function tests whether the relative difference between x and y is
-	   * larger than the configured epsilon. The function cannot be used to compare
-	   * values smaller than approximately 2.22e-16.
-	   *
+	   * Bitwise right logical shift of value x by y number of bits, `x >>> y`.
 	   * For matrices, the function is evaluated element wise.
-	   * In case of complex numbers, x.re must unequal y.re, or x.im must unequal y.im.
-	   *
-	   * Values `null` and `undefined` are compared strictly, thus `null` is unequal
-	   * with everything except `null`, and `undefined` is unequal with everying
-	   * except. `undefined`.
+	   * For units, the function is evaluated on the best prefix base.
 	   *
 	   * Syntax:
 	   *
-	   *    math.unequal(x, y)
+	   *    math.rightLogShift(x, y)
 	   *
 	   * Examples:
 	   *
-	   *    math.unequal(2 + 2, 3);       // returns true
-	   *    math.unequal(2 + 2, 4);       // returns false
-	   *
-	   *    var a = math.unit('50 cm');
-	   *    var b = math.unit('5 m');
-	   *    math.unequal(a, b);           // returns false
-	   *
-	   *    var c = [2, 5, 1];
-	   *    var d = [2, 7, 1];
-	   *
-	   *    math.unequal(c, d);           // returns [false, true, false]
-	   *    math.deepEqual(c, d);         // returns false
-	   *
-	   *    math.unequal(0, null);        // returns true
+	   *    math.rightLogShift(4, 2);               // returns Number 1
+	   *
+	   *    math.rightLogShift([16, -32, 64], 4);   // returns Array [1, 2, 3]
+	   *
 	   * See also:
 	   *
-	   *    equal, deepEqual, smaller, smallerEq, larger, largerEq, compare
+	   *    bitAnd, bitNot, bitOr, bitXor, leftShift, rightArithShift
 	   *
-	   * @param  {Number | BigNumber | Boolean | Complex | Unit | String | Array | Matrix | null | undefined} x First value to compare
-	   * @param  {Number | BigNumber | Boolean | Complex | Unit | String | Array | Matrix | null | undefined} y Second value to compare
-	   * @return {Boolean | Array | Matrix} Returns true when the compared values are unequal, else returns false
+	   * @param  {Number | Boolean | Array | Matrix | null} x Value to be shifted
+	   * @param  {Number | Boolean | null} y Amount of shifts
+	   * @return {Number | Array | Matrix} `x` zero-filled shifted right `y` times
 	   */
-	  math.unequal = function unequal(x, y) {
+	  math.rightLogShift = function rightLogShift(x, y) {
 	    if (arguments.length != 2) {
-	      throw new math.error.ArgumentsError('unequal', arguments.length, 2);
-	    }
-
-	    if (isNumber(x)) {
-	      if (isNumber(y)) {
-	        return !nearlyEqual(x, y, config.epsilon);
-	      }
-	      else if (isComplex(y)) {
-	        return !nearlyEqual(x, y.re, config.epsilon) || !nearlyEqual(y.im, 0, config.epsilon);
-	      }
-	    }
-
-	    if (isComplex(x)) {
-	      if (isNumber(y)) {
-	        return !nearlyEqual(x.re, y, config.epsilon) || !nearlyEqual(x.im, 0, config.epsilon);
-	      }
-	      else if (isComplex(y)) {
-	        return !nearlyEqual(x.re, y.re, config.epsilon) || !nearlyEqual(x.im, y.im, config.epsilon);
-	      }
-	    }
-
-	    if (x instanceof BigNumber) {
-	      // try to convert to big number
-	      if (isNumber(y)) {
-	        y = BigNumber.convert(y);
-	      }
-	      else if (isBoolean(y)) {
-	        y = new BigNumber(y ? 1 : 0);
-	      }
-
-	      if (y instanceof BigNumber) {
-	        return !x.eq(y);
-	      }
-
-	      // downgrade to Number
-	      return unequal(x.toNumber(), y);
-	    }
-	    if (y instanceof BigNumber) {
-	      // try to convert to big number
-	      if (isNumber(x)) {
-	        x = BigNumber.convert(x);
-	      }
-	      else if (isBoolean(x)) {
-	        x = new BigNumber(x ? 1 : 0);
-	      }
-
-	      if (x instanceof BigNumber) {
-	        return !x.eq(y)
-	      }
-
-	      // downgrade to Number
-	      return unequal(x, y.toNumber());
-	    }
-
-	    if ((isUnit(x)) && (isUnit(y))) {
-	      if (!x.equalBase(y)) {
-	        throw new Error('Cannot compare units with different base');
-	      }
-	      return x.value != y.value;
-	    }
-
-	    if (isCollection(x) || isCollection(y)) {
-	      return collection.deepMap2(x, y, unequal);
-	    }
-
-	    // Note: test strings after testing collections,
-	    // else we can accidentally compare a stringified array with a string
-	    if (isString(x) || isString(y)) {
-	      return x != y;
-	    }
-
-	    if (isBoolean(x)) {
-	      return unequal(+x, y);
-	    }
-	    if (isBoolean(y)) {
-	      return unequal(x, +y);
-	    }
-
-	    if (x === null) {
-	      return y !== null;
-	    }
-	    if (y === null) {
-	      return x !== null;
-	    }
-
-	    if (x === undefined) {
-	      return y !== undefined;
-	    }
-	    if (y === undefined) {
-	      return x !== undefined;
-	    }
-
-	    throw new math.error.UnsupportedTypeError('unequal', math['typeof'](x), math['typeof'](y));
+	      throw new math.error.ArgumentsError('rightLogShift', arguments.length, 2);
+	    }
+
+	    if (isNumber(x) && isNumber(y)) {
+	      if (!isInteger(x) || !isInteger(y)) {
+	        throw new Error('Parameters in function rightLogShift must be integer numbers');
+	      }
+
+	      return x >>> y;
+	    }
+
+	    if (isCollection(x) && isNumber(y)) {
+	      return collection.deepMap2(x, y, rightLogShift);
+	    }
+
+	    if (isBoolean(x) || x === null) {
+	      return rightLogShift(+x, y);
+	    }
+	    if (isBoolean(y) || y === null) {
+	      return rightLogShift(x, +y);
+	    }
+
+	    throw new math.error.UnsupportedTypeError('rightLogShift', math['typeof'](x), math['typeof'](y));
 	  };
 	};
 
@@ -10789,7 +10525,7 @@
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Complex = __webpack_require__(6),
@@ -10866,7 +10602,7 @@
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Complex = __webpack_require__(6),
@@ -10941,7 +10677,7 @@
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Complex = __webpack_require__(6),
@@ -11018,7 +10754,7 @@
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Complex = __webpack_require__(6),
@@ -11094,7 +10830,7 @@
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      // take the BigNumber instance the provided math.js instance
 	      BigNumber = math.type.BigNumber,
@@ -11163,7 +10899,7 @@
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      collection = __webpack_require__(13),
@@ -11257,7 +10993,7 @@
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Complex = __webpack_require__(6),
@@ -11390,7 +11126,7 @@
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Index = __webpack_require__(8);
@@ -11464,7 +11200,7 @@
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 	      Matrix = __webpack_require__(9);
 
 	  /**
@@ -11479,7 +11215,7 @@
 	   *
 	   * Examples:
 	   *
-	   *    var m = math.matrix([[1, 2], [3, 4]);
+	   *    var m = math.matrix([[1, 2], [3, 4]]);
 	   *    m.size();                        // Array [2, 2]
 	   *    m.resize([3, 2], 5);
 	   *    m.valueOf();                     // Array [[1, 2], [3, 4], [5, 5]]
@@ -11509,7 +11245,7 @@
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147);
+	  var util = __webpack_require__(160);
 
 	  var BigNumber = math.type.BigNumber;
 	  var Unit = math.type.Unit;
@@ -11665,44 +11401,58 @@
 
 	module.exports = function (math) {
 	  /**
-	   * Wrap any value in a Selector, allowing to perform chained operations on
+	   * Wrap any value in a chain, allowing to perform chained operations on
 	   * the value.
 	   *
-	   * All methods available in the math.js library can be called upon the selector,
+	   * All methods available in the math.js library can be called upon the chain,
 	   * and then will be evaluated with the value itself as first argument.
-	   * The selector can be closed by executing `selector.done()`, which returns
+	   * The chain can be closed by executing `chain.done()`, which returns
 	   * the final value.
 	   *
-	   * The Selector has a number of special functions:
+	   * The chain has a number of special functions:
 	   *
-	   * - `done()`     Finalize the chained operation and return the selectors value.
+	   * - `done()`     Finalize the chain and return the chain's value.
 	   * - `valueOf()`  The same as `done()`
-	   * - `toString()` Executes `math.format()` onto the selectors value, returning
+	   * - `toString()` Executes `math.format()` onto the chain's value, returning
 	   *                a string representation of the value.
 	   *
 	   * Syntax:
 	   *
-	   *    math.select(value)
+	   *    math.chain(value)
 	   *
 	   * Examples:
 	   *
-	   *     math.select(3)
+	   *     math.chain(3)
 	   *         .add(4)
 	   *         .subtract(2)
 	   *         .done();     // 5
 	   *
-	   *     math.select( [[1, 2], [3, 4]] )
+	   *     math.chain( [[1, 2], [3, 4]] )
 	   *         .set([1, 1], 8)
 	   *         .multiply(3)
 	   *         .done();     // [[24, 6], [9, 12]]
 	   *
 	   * @param {*} [value]   A value of any type on which to start a chained operation.
-	   * @return {math.chaining.Selector} The created selector
+	   * @return {math.chaining.Chain} The created chain
 	   */
-	  math.select = function select(value) {
+	  math.chain = function(value) {
 	    // TODO: check number of arguments
-	    return new math.chaining.Selector(value);
+	    return new math.chaining.Chain(value);
 	  };
+
+	  // TODO: deprecate math.select in v2.0
+	  math.select = function(value) {
+	    // give a warning once.
+	    if (console && typeof console.log === 'function') {
+	      console.log('WARNING: Function "select" is renamed to "chain". It will be deprecated in v2.0.')
+	    }
+
+	    // replace warning function with chain function
+	    math.select = math.chain;
+	    math.chaining.Chain.prototype['select'] = math.select;
+
+	    return math.chain(value);
+	  }
 	};
 
 
@@ -11713,7 +11463,7 @@
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      collection = __webpack_require__(13),
 
@@ -11780,7 +11530,7 @@
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Unit = __webpack_require__(10),
@@ -11867,9 +11617,390 @@
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
-
-	      BigNumber = __webpack_require__(142),
+	  var util = __webpack_require__(160),
+
+	      BigNumber = math.type.BigNumber,
+	      Complex = __webpack_require__(6),
+	      Unit = __webpack_require__(10),
+	      collection = __webpack_require__(13),
+
+	      isNumber = util.number.isNumber,
+	      isBoolean = util['boolean'].isBoolean,
+	      isComplex = Complex.isComplex,
+	      isUnit = Unit.isUnit,
+	      isCollection = collection.isCollection;
+
+	  /**
+	   * Logical `and`. Test whether two values are both defined with a nonzero/nonempty value.
+	   * For matrices, the function is evaluated element wise.
+	   *
+	   * Syntax:
+	   *
+	   *    math.and(x, y)
+	   *
+	   * Examples:
+	   *
+	   *    math.and(2, 4);   // returns true
+	   *
+	   *    a = [2, 0, 0];
+	   *    b = [3, 7, 0];
+	   *    c = 0;
+	   *
+	   *    math.and(a, b);   // returns [true, false, false]
+	   *    math.and(a, c);   // returns [false, false, false]
+	   *
+	   * See also:
+	   *
+	   *    not, or, xor
+	   *
+	   * @param  {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix | null} x First value to check
+	   * @param  {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix | null} y Second value to check
+	   * @return {Boolean | Array | Matrix}
+	   *            Returns true when both inputs are defined with a nonzero/nonempty value.
+	   */
+	  math.and = function and(x, y) {
+	    if (arguments.length != 2) {
+	      throw new math.error.ArgumentsError('and', arguments.length, 2);
+	    }
+
+	    if ((isNumber(x) || isBoolean(x) || x === null) &&
+	        (isNumber(y) || isBoolean(y) || y === null)) {
+	      return !!(x && y);
+	    }
+
+	    if (isComplex(x)) {
+	      if (x.re == 0 && x.im == 0) {
+	        return false;
+	      }
+
+	      return and(true, y);
+	    }
+	    if (isComplex(y)) {
+	      if (y.re == 0 && y.im == 0) {
+	        return false;
+	      }
+
+	      return and(x, true);
+	    }
+
+	    if (x instanceof BigNumber) {
+	      if (x.isZero() || x.isNaN()) {
+	        return false;
+	      }
+
+	      return and(true, y);
+	    }
+	    if (y instanceof BigNumber) {
+	      if (y.isZero() || y.isNaN()) {
+	        return false;
+	      }
+
+	      return and(x, true);
+	    }
+
+	    if (isUnit(x)) {
+	      if (x.value === null || x.value == 0) {
+	        return false;
+	      }
+
+	      return and(true, y);
+	    }
+	    if (isUnit(y)) {
+	      if (y.value === null || y.value == 0) {
+	        return false;
+	      }
+
+	      return and(x, true);
+	    }
+
+	    if (isCollection(x) || isCollection(y)) {
+	      return collection.deepMap2(x, y, and);
+	    }
+
+	    throw new math.error.UnsupportedTypeError('and', math['typeof'](x), math['typeof'](y));
+	  };
+	};
+
+
+/***/ },
+/* 84 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	module.exports = function (math) {
+	  var util = __webpack_require__(160),
+
+	      BigNumber = math.type.BigNumber,
+	      Complex = __webpack_require__(6),
+	      Unit = __webpack_require__(10),
+	      collection = __webpack_require__(13),
+
+	      isNumber = util.number.isNumber,
+	      isBoolean = util['boolean'].isBoolean,
+	      isComplex = Complex.isComplex,
+	      isUnit = Unit.isUnit,
+	      isCollection = collection.isCollection;
+
+	  /**
+	   * Logical `not`. Flips boolean value of a given parameter.
+	   * For matrices, the function is evaluated element wise.
+	   *
+	   * Syntax:
+	   *
+	   *    math.not(x)
+	   *
+	   * Examples:
+	   *
+	   *    math.not(2);      // returns false
+	   *    math.not(0);      // returns true
+	   *    math.not(true);   // returns false
+	   *
+	   *    a = [2, -7, 0];
+	   *    math.not(a);      // returns [false, false, true]
+	   *
+	   * See also:
+	   *
+	   *    and, or, xor
+	   *
+	   * @param  {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix | null} x First value to check
+	   * @return {Boolean | Array | Matrix}
+	   *            Returns true when input is a zero or empty value.
+	   */
+	  math.not = function not(x) {
+	    if (arguments.length != 1) {
+	      throw new math.error.ArgumentsError('not', arguments.length, 1);
+	    }
+
+	    if (isNumber(x) || isBoolean(x) || x === null) {
+	      return !x;
+	    }
+
+	    if (isComplex(x)) {
+	      return x.re == 0 && x.im == 0;
+	    }
+
+	    if (x instanceof BigNumber) {
+	      return x.isZero() || x.isNaN();
+	    }
+
+	    if (isUnit(x)) {
+	      return x.value === null || x.value == 0;
+	    }
+
+	    if (isCollection(x)) {
+	      return collection.deepMap(x, not);
+	    }
+
+	    throw new math.error.UnsupportedTypeError('not', math['typeof'](x));
+	  };
+	};
+
+
+/***/ },
+/* 85 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	module.exports = function (math) {
+	  var util = __webpack_require__(160),
+
+	      BigNumber = math.type.BigNumber,
+	      Complex = __webpack_require__(6),
+	      Unit = __webpack_require__(10),
+	      collection = __webpack_require__(13),
+
+	      isNumber = util.number.isNumber,
+	      isBoolean = util['boolean'].isBoolean,
+	      isComplex = Complex.isComplex,
+	      isUnit = Unit.isUnit,
+	      isCollection = collection.isCollection;
+
+	  /**
+	   * Logical `or`. Test if at least one value is defined with a nonzero/nonempty value.
+	   * For matrices, the function is evaluated element wise.
+	   *
+	   * Syntax:
+	   *
+	   *    math.or(x, y)
+	   *
+	   * Examples:
+	   *
+	   *    math.or(2, 4);   // returns true
+	   *
+	   *    a = [2, 5, 0];
+	   *    b = [0, 22, 0];
+	   *    c = 0;
+	   *
+	   *    math.or(a, b);   // returns [true, true, false]
+	   *    math.or(b, c);   // returns [false, true, false]
+	   *
+	   * See also:
+	   *
+	   *    and, not, xor
+	   *
+	   * @param  {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix | null} x First value to check
+	   * @param  {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix | null} y Second value to check
+	   * @return {Boolean | Array | Matrix}
+	   *            Returns true when one of the inputs is defined with a nonzero/nonempty value.
+	   */
+	  math.or = function or(x, y) {
+	    if (arguments.length != 2) {
+	      throw new math.error.ArgumentsError('or', arguments.length, 2);
+	    }
+
+	    if ((isNumber(x) || isBoolean(x) || x === null) &&
+	        (isNumber(y) || isBoolean(y) || y === null)) {
+	      return !!(x || y);
+	    }
+
+	    if (isComplex(x)) {
+	      if (x.re == 0 && x.im == 0) {
+	        return or(false, y);
+	      }
+	      return true;
+	    }
+	    if (isComplex(y)) {
+	      if (y.re == 0 && y.im == 0) {
+	        return or(x, false);
+	      }
+	      return true;
+	    }
+
+	    if (x instanceof BigNumber) {
+	      if (x.isZero() || x.isNaN()) {
+	        return or(false, y);
+	      }
+	      return true;
+	    }
+	    if (y instanceof BigNumber) {
+	      if (y.isZero() || y.isNaN()) {
+	        return or(x, false);
+	      }
+	      return true;
+	    }
+
+	    if (isUnit(x)) {
+	      if (x.value === null || x.value == 0) {
+	        return or(false, y);
+	      }
+	      return true;
+	    }
+	    if (isUnit(y)) {
+	      if (y.value === null || y.value == 0) {
+	        return or(x, false);
+	      }
+	      return true;
+	    }
+
+	    if (isCollection(x) || isCollection(y)) {
+	      return collection.deepMap2(x, y, or);
+	    }
+
+	    throw new math.error.UnsupportedTypeError('or', math['typeof'](x), math['typeof'](y));
+	  };
+	};
+
+
+/***/ },
+/* 86 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	module.exports = function (math) {
+	  var util = __webpack_require__(160),
+
+	      BigNumber = math.type.BigNumber,
+	      Complex = __webpack_require__(6),
+	      Unit = __webpack_require__(10),
+	      collection = __webpack_require__(13),
+
+	      isNumber = util.number.isNumber,
+	      isBoolean = util['boolean'].isBoolean,
+	      isComplex = Complex.isComplex,
+	      isUnit = Unit.isUnit,
+	      isCollection = collection.isCollection;
+
+	  /**
+	   * Logical `xor`. Test whether one and only one value is defined with a nonzero/nonempty value.
+	   * For matrices, the function is evaluated element wise.
+	   *
+	   * Syntax:
+	   *
+	   *    math.xor(x, y)
+	   *
+	   * Examples:
+	   *
+	   *    math.xor(2, 4);   // returns false
+	   *
+	   *    a = [2, 0, 0];
+	   *    b = [2, 7, 0];
+	   *    c = 0;
+	   *
+	   *    math.xor(a, b);   // returns [false, true, false]
+	   *    math.xor(a, c);   // returns [true, false, false]
+	   *
+	   * See also:
+	   *
+	   *    and, not, or
+	   *
+	   * @param  {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix | null} x First value to check
+	   * @param  {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix | null} y Second value to check
+	   * @return {Boolean | Array | Matrix}
+	   *            Returns true when one and only one input is defined with a nonzero/nonempty value.
+	   */
+	  math.xor = function xor(x, y) {
+	    if (arguments.length != 2) {
+	      throw new math.error.ArgumentsError('xor', arguments.length, 2);
+	    }
+
+	    if ((isNumber(x) || isBoolean(x) || x === null) &&
+	        (isNumber(y) || isBoolean(y) || y === null)) {
+	      return !!(!!x ^ !!y);
+	    }
+
+	    if (isComplex(x)) {
+	      return xor(!(x.re == 0 && x.im == 0), y);
+	    }
+	    if (isComplex(y)) {
+	      return xor(x, !(y.re == 0 && y.im == 0));
+	    }
+
+	    if (x instanceof BigNumber) {
+	      return xor(!(x.isZero() || x.isNaN()), y);
+	    }
+	    if (y instanceof BigNumber) {
+	      return xor(x, !(y.isZero() || y.isNaN()));
+	    }
+
+	    if (isUnit(x)) {
+	      return xor(!(x.value === null || x.value == 0), y);
+	    }
+	    if (isUnit(y)) {
+	      return xor(x, !(y.value === null || y.value == 0));
+	    }
+
+	    if (isCollection(x) || isCollection(y)) {
+	      return collection.deepMap2(x, y, xor);
+	    }
+
+	    throw new math.error.UnsupportedTypeError('xor', math['typeof'](x), math['typeof'](y));
+	  };
+	};
+
+
+/***/ },
+/* 87 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	module.exports = function (math) {
+	  var util = __webpack_require__(160),
+
+	      BigNumber = __webpack_require__(159),
 	      Matrix = __webpack_require__(9),
 	      collection = __webpack_require__(13),
 
@@ -12003,13 +12134,13 @@
 
 
 /***/ },
-/* 84 */
+/* 88 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function(math) {
-	  var array = __webpack_require__(140);
+	  var array = __webpack_require__(153);
 	  var Matrix = __webpack_require__(9);
 
 	  /**
@@ -12088,13 +12219,13 @@
 
 
 /***/ },
-/* 85 */
+/* 89 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      Matrix = __webpack_require__(9),
 
@@ -12249,13 +12380,13 @@
 
 
 /***/ },
-/* 86 */
+/* 90 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Matrix = __webpack_require__(9),
@@ -12366,13 +12497,13 @@
 
 
 /***/ },
-/* 87 */
+/* 91 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function(math) {
-	  var array = __webpack_require__(140);
+	  var array = __webpack_require__(153);
 	  var Matrix = __webpack_require__(9);
 
 	  /**
@@ -12447,13 +12578,13 @@
 
 
 /***/ },
-/* 88 */
+/* 92 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math, config) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Matrix = __webpack_require__(9),
@@ -12550,13 +12681,13 @@
 
 
 /***/ },
-/* 89 */
+/* 93 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math, config) {
-	  var util = __webpack_require__(147);
+	  var util = __webpack_require__(160);
 
 	  var Matrix = __webpack_require__(9);
 
@@ -12603,16 +12734,14 @@
 
 
 /***/ },
-/* 90 */
+/* 94 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
-	      string = util.string,
-
-	      Matrix = __webpack_require__(9);
+	  var util = __webpack_require__(160);
+	  var Matrix = __webpack_require__(9);
 
 	  /**
 	   * Calculate the inverse of a square matrix.
@@ -12642,25 +12771,25 @@
 	    switch (size.length) {
 	      case 0:
 	        // scalar
-	        return math.divide(1, x);
+	        return math._divide(1, x);
 
 	      case 1:
 	        // vector
 	        if (size[0] == 1) {
 	          if (x instanceof Matrix) {
 	            return new Matrix([
-	              math.divide(1, x.valueOf()[0])
+	              math._divide(1, x.valueOf()[0])
 	            ]);
 	          }
 	          else {
 	            return [
-	              math.divide(1, x[0])
+	              math._divide(1, x[0])
 	            ];
 	          }
 	        }
 	        else {
 	          throw new RangeError('Matrix must be square ' +
-	              '(size: ' + string.format(size) + ')');
+	              '(size: ' + util.string.format(size) + ')');
 	        }
 
 	      case 2:
@@ -12680,13 +12809,13 @@
 	        }
 	        else {
 	          throw new RangeError('Matrix must be square ' +
-	              '(size: ' + string.format(size) + ')');
+	              '(size: ' + util.string.format(size) + ')');
 	        }
 
 	      default:
 	        // multi dimensional array
 	        throw new RangeError('Matrix must be two dimensional ' +
-	            '(size: ' + string.format(size) + ')');
+	            '(size: ' + util.string.format(size) + ')');
 	    }
 	  };
 
@@ -12708,7 +12837,7 @@
 	        throw Error('Cannot calculate inverse, determinant is zero');
 	      }
 	      return [[
-	        math.divide(1, value)
+	        math._divide(1, value)
 	      ]];
 	    }
 	    else if (rows == 2) {
@@ -12719,12 +12848,12 @@
 	      }
 	      return [
 	        [
-	          math.divide(matrix[1][1], d),
-	          math.divide(math.unaryMinus(matrix[0][1]), d)
+	          math._divide(matrix[1][1], d),
+	          math._divide(math.unaryMinus(matrix[0][1]), d)
 	        ],
 	        [
-	          math.divide(math.unaryMinus(matrix[1][0]), d),
-	          math.divide(matrix[0][0], d)
+	          math._divide(math.unaryMinus(matrix[1][0]), d),
+	          math._divide(matrix[0][0], d)
 	        ]
 	      ];
 	    }
@@ -12771,7 +12900,7 @@
 	          if(r != c) {
 	            // eliminate value at column c and row r
 	            if (Ar[c] != 0) {
-	              f = math.divide(math.unaryMinus(Ar[c]), Ac[c]);
+	              f = math._divide(math.unaryMinus(Ar[c]), Ac[c]);
 
 	              // add (f * row c) to row r to eliminate the value
 	              // at column c
@@ -12788,10 +12917,10 @@
 	            // divide each value on row r with the value at Acc
 	            f = Ac[c];
 	            for (s = c; s < cols; s++) {
-	              Ar[s] = math.divide(Ar[s], f);
+	              Ar[s] = math._divide(Ar[s], f);
 	            }
 	            for (s = 0; s < cols; s++) {
-	              Br[s] = math.divide(Br[s], f);
+	              Br[s] = math._divide(Br[s], f);
 	            }
 	          }
 	        }
@@ -12803,13 +12932,13 @@
 
 
 /***/ },
-/* 91 */
+/* 95 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math, config) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Matrix = __webpack_require__(9),
@@ -12880,13 +13009,13 @@
 
 
 /***/ },
-/* 92 */
+/* 96 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math, config) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Matrix = __webpack_require__(9),
@@ -13206,13 +13335,13 @@
 
 
 /***/ },
-/* 93 */
+/* 97 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math, config) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Matrix = __webpack_require__(9),
@@ -13341,13 +13470,13 @@
 
 
 /***/ },
-/* 94 */
+/* 98 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math, config) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Complex = __webpack_require__(6),
@@ -13414,13 +13543,13 @@
 
 
 /***/ },
-/* 95 */
+/* 99 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      Matrix = __webpack_require__(9),
 
@@ -13478,13 +13607,13 @@
 
 
 /***/ },
-/* 96 */
+/* 100 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      Matrix = __webpack_require__(9),
 	      Index = __webpack_require__(8),
@@ -13695,13 +13824,13 @@
 
 
 /***/ },
-/* 97 */
+/* 101 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      Matrix = __webpack_require__(9),
 
@@ -13778,13 +13907,13 @@
 
 
 /***/ },
-/* 98 */
+/* 102 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math, config) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      Matrix = __webpack_require__(9),
@@ -13854,13 +13983,13 @@
 
 
 /***/ },
-/* 99 */
+/* 103 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      collection = __webpack_require__(13),
@@ -13887,7 +14016,7 @@
 	   *
 	   * See also:
 	   *
-	   *    combinations, permutations
+	   *    combinations, gamma, permutations
 	   *
 	   * @param {Number | BigNumber | Array | Matrix | Boolean | null} n   An integer number
 	   * @return {Number | BigNumber | Array | Matrix}    The factorial of `n`
@@ -13900,47 +14029,39 @@
 	    }
 
 	    if (isNumber(n)) {
-	      if (!isInteger(n) || n < 0) {
-	        throw new TypeError('Positive integer value expected in function factorial');
-	      }
-
-	      value = n - 1;
-	      res = n;
-	      while (value > 1) {
-	        res *= value;
-	        value--;
-	      }
-
-	      if (res == 0) {
-	        res = 1;        // 0! is per definition 1
-	      }
-
-	      return res;
+	      return math.gamma(n + 1);
 	    }
 
 	    if (n instanceof BigNumber) {
-	      if (!(isPositiveInteger(n))) {
-	        throw new TypeError('Positive integer value expected in function factorial');
+	      if (!(isPositiveInteger(n)) && n.isFinite()) {
+	        return math.gamma(n.plus(1));
+	      }
+
+	      if (!n.isFinite()) {
+	        return new BigNumber(n);
+	      }
+
+	      n = n.toNumber();
+	      if (n < fac.length) {
+	        return (n < 21)
+	          ? new BigNumber(fac[n])
+	          : fac[n];
 	      }
 
 	      var one = new BigNumber(1);
-
-	      value = n.minus(one);
-	      res = n;
-	      while (value.gt(one)) {
+	      value = new BigNumber(fac.length);
+	      res = fac[fac.length - 1];
+	      for (var i = fac.length; i < n; ++i) {
 	        res = res.times(value);
-	        value = value.minus(one);
-	      }
-
-	      if (res.equals(0)) {
-	        res = one;        // 0! is per definition 1
-	      }
-
-	      return res;
+	        value = value.plus(one);
+	        fac[i] = res;
+	      }
+
+	      return fac[n] = res.times(value);
 	    }
 
 	    if (isBoolean(n) || n === null) {
-	      return 1; // factorial(1) = 1, factorial(0) = 1
+	      return 1;           // factorial(1) = 1, factorial(0) = 1
 	    }
 
 	    if (isCollection(n)) {
@@ -13956,19 +14077,239 @@
 	   * @returns {boolean} isPositiveInteger
 	   */
 	  var isPositiveInteger = function(n) {
-	    return n.isInteger() && n.gte(0);
-	  };
-	};
-
-
-/***/ },
-/* 100 */
+	    return n.isInteger() && (!n.isNegative() || n.isZero());
+	  };
+
+	  // 0-21! values
+	  var fac = [
+	    1,
+	    1,
+	    2,
+	    6,
+	    24,
+	    120,
+	    720,
+	    5040,
+	    40320,
+	    362880,
+	    3628800,
+	    39916800,
+	    479001600,
+	    6227020800,
+	    87178291200,
+	    1307674368000,
+	    20922789888000,
+	    355687428096000,
+	    6402373705728000,
+	    121645100408832000,
+	    2432902008176640000,
+	    new BigNumber('51090942171709440000')
+	  ]
+	};
+
+
+/***/ },
+/* 104 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	module.exports = function (math, config) {
+	  var util = __webpack_require__(160),
+
+	      BigNumber = math.type.BigNumber,
+	      Complex = __webpack_require__(6),
+	      collection = __webpack_require__(13),
+
+	      isBoolean = util['boolean'].isBoolean,
+	      isComplex = Complex.isComplex,
+	      isNumber = util.number.isNumber,
+	      isInteger = util.number.isInteger,
+	      isCollection = collection.isCollection;
+
+	  /**
+	   * Compute the gamma function of a value using Lanczos approximation for
+	   * small values, and an extended Stirling approximation for large values.
+	   *
+	   * For matrices, the function is evaluated element wise.
+	   *
+	   * Syntax:
+	   *
+	   *    math.gamma(n)
+	   *
+	   * Examples:
+	   *
+	   *    math.gamma(5);       // returns 24
+	   *    math.gamma(-0.5);    // returns -3.5449077018110335
+	   *    math.gamma(math.i);  // returns -0.15494982830180973 - 0.49801566811835596i
+	   *
+	   * See also:
+	   *
+	   *    combinations, factorial, permutations
+	   *
+	   * @param {Number | Array | Matrix | Boolean | null} n   An integer number
+	   * @return {Number | Array | Matrix}    The gamma of `n`
+	   */
+	  math.gamma = function gamma (n) {
+	    var t, x;
+	    var g = 4.7421875;
+
+	    if (arguments.length != 1) {
+	      throw new math.error.ArgumentsError('gamma', arguments.length, 1);
+	    }
+
+	    if (isNumber(n)) {
+	      if (isInteger(n)) {
+	        if (n <= 0) {
+	          return isFinite(n)
+	            ? Infinity
+	            : NaN;
+	        }
+
+	        if (n > 171) {
+	          return Infinity;                  // Will overflow
+	        }
+
+	        var value = n - 2;
+	        var res = n - 1;
+	        while (value > 1) {
+	          res *= value;
+	          value--;
+	        }
+
+	        if (res == 0) {
+	          res = 1;                          // 0! is per definition 1
+	        }
+
+	        return res;
+	      }
+
+	      if (n < 0.5) {
+	        return Math.PI / (Math.sin(Math.PI*n) * gamma(1-n));
+	      }
+
+	      if (n >= 171.35) {
+	        return Infinity;                    // will overflow
+	      }
+
+	      if (n > 85.0) {                       // Extended Stirling Approx
+	        var twoN = n*n;
+	        var threeN = twoN*n;
+	        var fourN = threeN*n;
+	        var fiveN = fourN*n;
+	        return Math.sqrt(2*Math.PI/n) * Math.pow((n/Math.E), n) *
+	          (1 + 1/(12*n) + 1/(288*twoN) - 139/(51840*threeN) -
+	           571/(2488320*fourN) + 163879/(209018880*fiveN) +
+	           5246819/(75246796800*fiveN*n));
+	      }
+
+	      --n;
+	      x = p[0];
+	      for (var i = 1; i < p.length; ++i) {
+	        x += p[i] / (n+i);
+	      }
+
+	      t = n + g + 0.5;
+	      return Math.sqrt(2*Math.PI) * Math.pow(t, n+0.5) * Math.exp(-t) * x;
+	    }
+
+	    if (isComplex(n)) {
+	      if (n.im == 0) {
+	        return gamma(n.re);
+	      }
+
+	      n = new Complex(n.re - 1, n.im);
+	      x = new Complex(p[0], 0);
+	      for (var i = 1; i < p.length; ++i) {
+	        var real = n.re + i;                // x += p[i]/(n+i)
+	        var den = real*real + n.im*n.im;
+	        if (den != 0) {
+	          x.re += p[i] * real / den;
+	          x.im += -(p[i] * n.im) / den;
+	        } else {
+	          x.re = p[i] < 0
+	            ? -Infinity
+	            :  Infinity;
+	        }
+	      }
+
+	      t = new Complex(n.re + g + 0.5, n.im);
+	      var twoPiSqrt = Math.sqrt(2*Math.PI);
+
+	      n.re += 0.5;
+	      var result = math.pow(t, n);
+	      if (result.im == 0) {                 // sqrt(2*PI)*result
+	        result.re *= twoPiSqrt;
+	      } else if (result.re == 0) {
+	        result.im *= twoPiSqrt;
+	      } else {
+	        result.re *= twoPiSqrt;
+	        result.im *= twoPiSqrt;
+	      }
+
+	      var r = Math.exp(-t.re);              // exp(-t)
+	      t.re = r * Math.cos(-t.im);
+	      t.im = r * Math.sin(-t.im);
+
+	      return math.multiply(math.multiply(result, t), x);
+	    }
+
+	    if (n instanceof BigNumber) {
+	      if (n.isInteger()) {
+	        return n.isNegative() || n.isZero()
+	          ? new BigNumber(Infinity)
+	          : math.factorial(n.minus(1));
+	      }
+
+	      if (!n.isFinite()) {
+	        return new BigNumber(n.isNegative()
+	          ? NaN
+	          : Infinity);
+	      }
+	    }
+
+	    if (isBoolean(n) || n === null) {
+	      return n
+	        ? 1
+	        : Infinity;
+	    }
+
+	    if (isCollection(n)) {
+	      return collection.deepMap(n, gamma);
+	    }
+
+	    throw new math.error.UnsupportedTypeError('gamma', math['typeof'](n));
+	  };
+
+	  var p = [
+	     0.99999999999999709182,
+	     57.156235665862923517,
+	    -59.597960355475491248,
+	     14.136097974741747174,
+	    -0.49191381609762019978,
+	     0.33994649984811888699e-4,
+	     0.46523628927048575665e-4,
+	    -0.98374475304879564677e-4,
+	     0.15808870322491248884e-3,
+	    -0.21026444172410488319e-3,
+	     0.21743961811521264320e-3,
+	    -0.16431810653676389022e-3,
+	     0.84418223983852743293e-4,
+	    -0.26190838401581408670e-4,
+	     0.36899182659531622704e-5
+	  ];
+
+	};
+
+
+/***/ },
+/* 105 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var distribution = __webpack_require__(181)(math);
+	  var distribution = __webpack_require__(194)(math);
 
 	  /**
 	   * Return a random number larger or equal to `min` and smaller than `max`
@@ -14005,13 +14346,13 @@
 
 
 /***/ },
-/* 101 */
+/* 106 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var distribution = __webpack_require__(181)(math);
+	  var distribution = __webpack_require__(194)(math);
 
 	  /**
 	   * Return a random integer number larger or equal to `min` and smaller than `max`
@@ -14048,13 +14389,13 @@
 
 
 /***/ },
-/* 102 */
+/* 107 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var distribution = __webpack_require__(181)(math);
+	  var distribution = __webpack_require__(194)(math);
 
 	  /**
 	   * Random pick a value from a one dimensional array.
@@ -14080,13 +14421,13 @@
 
 
 /***/ },
-/* 103 */
+/* 108 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 
@@ -14193,13 +14534,13 @@
 
 
 /***/ },
-/* 104 */
+/* 109 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
 
 	module.exports = function (math) {
-	  var util = __webpack_require__(147),
+	  var util = __webpack_require__(160),
 
 	      BigNumber = math.type.BigNumber,
 	      collection = __webpack_require__(13),
@@ -14290,7 +14631,1058 @@
 
 
 /***/ },
-/* 105 */
+/* 110 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	module.exports = function (math, config) {
+	  var util = __webpack_require__(160),
+
+	      BigNumber = math.type.BigNumber,
+	      Complex = __webpack_require__(6),
+	      Unit = __webpack_require__(10),
+	      collection = __webpack_require__(13),
+
+	      isNumber = util.number.isNumber,
+	      nearlyEqual = util.number.nearlyEqual,
+	      isBoolean = util['boolean'].isBoolean,
+	      isString = util.string.isString,
+	      isComplex = Complex.isComplex,
+	      isUnit = Unit.isUnit,
+	      isCollection = collection.isCollection;
+
+	  /**
+	   * Compare two values. Returns 1 when x > y, -1 when x < y, and 0 when x == y.
+	   *
+	   * x and y are considered equal when the relative difference between x and y
+	   * is smaller than the configured epsilon. The function cannot be used to
+	   * compare values smaller than approximately 2.22e-16.
+	   *
+	   * For matrices, the function is evaluated element wise.
+	   *
+	   * Syntax:
+	   *
+	   *    math.compare(x, y)
+	   *
+	   * Examples:
+	   *
+	   *    math.compare(6, 1);           // returns 1
+	   *    math.compare(2, 3);           // returns -1
+	   *    math.compare(7, 7);           // returns 0
+	   *
+	   *    var a = math.unit('5 cm');
+	   *    var b = math.unit('40 mm');
+	   *    math.compare(a, b);           // returns 1
+	   *
+	   *    math.compare(2, [1, 2, 3]);   // returns [1, 0, -1]
+	   *
+	   * See also:
+	   *
+	   *    equal, unequal, smaller, smallerEq, larger, largerEq
+	   *
+	   * @param  {Number | BigNumber | Boolean | Unit | String | Array | Matrix | null} x First value to compare
+	   * @param  {Number | BigNumber | Boolean | Unit | String | Array | Matrix | null} y Second value to compare
+	   * @return {Number | BigNumber | Array | Matrix} Returns the result of the comparison: 1, 0 or -1.
+	   */
+	  math.compare = function compare(x, y) {
+	    if (arguments.length != 2) {
+	      throw new math.error.ArgumentsError('compare', arguments.length, 2);
+	    }
+
+	    if (isNumber(x) && isNumber(y)) {
+	      return nearlyEqual(x, y, config.epsilon) ? 0 : (x > y ? 1 : -1);
+	    }
+
+	    if (x instanceof BigNumber) {
+	      // try to convert to big number
+	      if (isNumber(y)) {
+	        y = BigNumber.convert(y);
+	      }
+	      else if (isBoolean(y) || y === null) {
+	        y = new BigNumber(y ? 1 : 0);
+	      }
+
+	      if (y instanceof BigNumber) {
+	        return new BigNumber(x.cmp(y));
+	      }
+
+	      // downgrade to Number
+	      return compare(x.toNumber(), y);
+	    }
+	    if (y instanceof BigNumber) {
+	      // try to convert to big number
+	      if (isNumber(x)) {
+	        x = BigNumber.convert(x);
+	      }
+	      else if (isBoolean(x) || x === null) {
+	        x = new BigNumber(x ? 1 : 0);
+	      }
+
+	      if (x instanceof BigNumber) {
+	        return new BigNumber(x.cmp(y));
+	      }
+
+	      // downgrade to Number
+	      return compare(x, y.toNumber());
+	    }
+
+	    if ((isUnit(x)) && (isUnit(y))) {
+	      if (!x.equalBase(y)) {
+	        throw new Error('Cannot compare units with different base');
+	      }
+	      return (x.value > y.value) ? 1 : ((x.value < y.value) ? -1 : 0);
+	    }
+
+	    if (isCollection(x) || isCollection(y)) {
+	      return collection.deepMap2(x, y, compare);
+	    }
+
+	    // Note: test strings after testing collections,
+	    // else we can't compare a string with a matrix
+	    if (isString(x) || isString(y)) {
+	      return (x > y) ? 1 : ((x < y) ? -1 : 0);
+	    }
+
+	    if (isBoolean(x) || x === null) {
+	      return compare(+x, y);
+	    }
+	    if (isBoolean(y) || y === null) {
+	      return compare(x, +y);
+	    }
+
+	    if (isComplex(x) || isComplex(y)) {
+	      throw new TypeError('No ordering relation is defined for complex numbers');
+	    }
+
+	    throw new math.error.UnsupportedTypeError('compare', math['typeof'](x), math['typeof'](y));
+	  };
+	};
+
+
+/***/ },
+/* 111 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	module.exports = function (math) {
+	  var collection = __webpack_require__(13),
+
+	      isCollection = collection.isCollection,
+	      isArray = Array.isArray;
+
+	  /**
+	   * Test element wise whether two matrices are equal.
+	   * The function accepts both matrices and scalar values.
+	   *
+	   * Syntax:
+	   *
+	   *    math.deepEqual(x, y)
+	   *
+	   * Examples:
+	   *
+	   *    math.deepEqual(2, 4);   // returns false
+	   *
+	   *    a = [2, 5, 1];
+	   *    b = [2, 7, 1];
+	   *
+	   *    math.deepEqual(a, b);   // returns false
+	   *    math.equal(a, b);       // returns [true, false, true]
+	   *
+	   * See also:
+	   *
+	   *    equal, unequal
+	   *
+	   * @param  {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix | null} x First matrix to compare
+	   * @param  {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix | null} y Second matrix to compare
+	   * @return {Number | BigNumber | Complex | Unit | Array | Matrix}
+	   *            Returns true when the input matrices have the same size and each of their elements is equal.
+	   */
+	  math.deepEqual = function deepEqual(x, y) {
+	    if (arguments.length != 2) {
+	      throw new math.error.ArgumentsError('deepEqual', arguments.length, 2);
+	    }
+
+	    if (isCollection(x) || isCollection(y)) {
+	      return _deepEqual(x.valueOf(), y.valueOf());