mathjs 5.0.0 → 5.0.4

package/lib/function/algebra/decomposition/qr.js

@@ -53,7 +53,7 @@ function factory(type, config, load, typed) {
    *
    * See also:
    *
-   *    lu
+   *    lup, lusolve
    *
    * @param {Matrix | Array} A    A two dimensional matrix or array
    * for which to get the QR decomposition.

package/lib/function/algebra/rationalize.js

@@ -4,7 +4,6 @@ function factory(type, config, load, typed) {
   var simplify = load(require('./simplify'));
   var simplifyCore = load(require('./simplify/simplifyCore'));
   var simplifyConstant = load(require('./simplify/simplifyConstant'));
-  var ArgumentsError = require('../../error/ArgumentsError');
   var parse = load(require('../../expression/function/parse'));
   var number = require('../../utils/number');
   var ConstantNode = load(require('../../expression/node/ConstantNode'));
@@ -26,22 +25,25 @@ function factory(type, config, load, typed) {
    *
    * Examples:
    *
-   *     math.rationalize('sin(x)+y')  //  Error: There is an unsolved function call
-   *     math.rationalize('2x/y - y/(x+1)')  // (2*x^2-y^2+2*x)/(x*y+y)
+   *     math.rationalize('sin(x)+y')
+   *                   //  Error: There is an unsolved function call
+   *     math.rationalize('2x/y - y/(x+1)')
+   *                   // (2*x^2-y^2+2*x)/(x*y+y)
    *     math.rationalize('(2x+1)^6')
-   *                   //     64*x^6+192*x^5+240*x^4+160*x^3+60*x^2+12*x+1
+   *                   // 64*x^6+192*x^5+240*x^4+160*x^3+60*x^2+12*x+1
    *     math.rationalize('2x/( (2x-1) / (3x+2) ) - 5x/ ( (3x+4) / (2x^2-5) ) + 3')
-   *                   //    -20*x^4+28*x^3+104*x^2+6*x-12)/(6*x^2+5*x-4)
+   *                   // -20*x^4+28*x^3+104*x^2+6*x-12)/(6*x^2+5*x-4)
    *     math.rationalize('x/(1-x)/(x-2)/(x-3)/(x-4) + 2x/ ( (1-2x)/(2-3x) )/ ((3-4x)/(4-5x) )') =
-   *                   //  (-30*x^7+344*x^6-1506*x^5+3200*x^4-3472*x^3+1846*x^2-381*x)/
-   *                   //   (-8*x^6+90*x^5-383*x^4+780*x^3-797*x^2+390*x-72)
+   *                   // (-30*x^7+344*x^6-1506*x^5+3200*x^4-3472*x^3+1846*x^2-381*x)/
+   *                   //     (-8*x^6+90*x^5-383*x^4+780*x^3-797*x^2+390*x-72)
    *
    *     math.rationalize('x+x+x+y',{y:1}) // 3*x+1
    *     math.rationalize('x+x+x+y',{})    // 3*x+y
-   *     ret = math.rationalize('x+x+x+y',{},true)
-   *                          // ret.expression=3*x+y,  ret.variables = ["x","y"]
-   *     ret = math.rationalize('-2+5x^2',{},true)
-   *                          // ret.expression=5*x^2-2,  ret.variables = ["x"], ret.coefficients=[-2,0,5]
+   *
+   *     const ret = math.rationalize('x+x+x+y',{},true)
+   *                   // ret.expression=3*x+y, ret.variables = ["x","y"]
+   *     const ret = math.rationalize('-2+5x^2',{},true)
+   *                   // ret.expression=5*x^2-2, ret.variables = ["x"], ret.coefficients=[-2,0,5]
    *
    * See also:
    *
@@ -99,33 +101,21 @@ function factory(type, config, load, typed) {
         // If expression in not a constant
         var setRules = rulesRationalize(); // Rules for change polynomial in near canonical form
         expr = expandPower(expr); // First expand power of polynomials (cannot be made from rules!)
-        var redoInic = true; // If has change after start, redo the beginning
-        var s = ''; // New expression
         var sBefore = void 0; // Previous expression
-        var rules = void 0;
-        var eDistrDiv = true;
-
-        expr = simplify(expr, setRules.firstRules); // Apply the initial rules, including succ div rules
-        s = expr.toString();
 
         while (true) {
           // Apply alternately  successive division rules and distr.div.rules
-          rules = eDistrDiv ? setRules.distrDivRules : setRules.sucDivRules;
-          expr = simplify(expr, rules); // until no more changes
-          eDistrDiv = !eDistrDiv; // Swap between Distr.Div and Succ. Div. Rules
+          expr = simplify(expr, setRules.firstRules); // Apply the initial rules, including succ div rules
+          expr = simplify(expr, setRules.distrDivRules); // and distr.div.rules until no more changes
 
-          s = expr.toString();
+          var s = expr.toString();
           if (s === sBefore) break; // No changes : end of the loop
 
-          redoInic = true;
           sBefore = s;
         }
 
-        if (redoInic) {
-          // Apply first rules again without succ div rules (if there are changes)
-          expr = simplify(expr, setRules.firstRulesAgain);
-        }
-        expr = simplify(expr, setRules.finalRules); // Aplly final rules
+        expr = simplify(expr, setRules.firstRulesAgain);
+        expr = simplify(expr, setRules.finalRules); // Apply final rules
       } // NVars >= 1
 
       var coefficients = [];
@@ -212,17 +202,23 @@ function factory(type, config, load, typed) {
       var tp = node.type; // node type
       if (tp === 'FunctionNode') {
         // No function call in polynomial expression
-        throw new ArgumentsError('There is an unsolved function call');
+        throw new Error('There is an unsolved function call');
       } else if (tp === 'OperatorNode') {
         if (node.op === '^' && node.isBinary()) {
-          if (node.args[1].type !== 'ConstantNode' || !number.isInteger(parseFloat(node.args[1].value))) {
-            throw new ArgumentsError('There is a non-integer exponent');
+          if (node.args[1].op === '-' && node.args[1].isUnary()) {
+            if (node.args[1].args[0].type !== 'ConstantNode' || !number.isInteger(parseFloat(node.args[1].args[0].value))) {
+              throw new Error('There is a non-integer exponent');
+            } else {
+              recPoly(node.args[0]);
+            }
+          } else if (node.args[1].type !== 'ConstantNode' || !number.isInteger(parseFloat(node.args[1].value))) {
+            throw new Error('There is a non-integer exponent');
           } else {
             recPoly(node.args[0]);
           }
         } else {
           if (oper.indexOf(node.op) === -1) {
-            throw new ArgumentsError('Operator ' + node.op + ' invalid in polynomial expression');
+            throw new Error('Operator ' + node.op + ' invalid in polynomial expression');
           }
           for (var i = 0; i < node.args.length; i++) {
             recPoly(node.args[i]);
@@ -238,7 +234,7 @@ function factory(type, config, load, typed) {
       } else if (tp === 'ParenthesisNode') {
         recPoly(node.content);
       } else if (tp !== 'ConstantNode') {
-        throw new ArgumentsError('type ' + tp + ' is not allowed in polynomial expression');
+        throw new Error('type ' + tp + ' is not allowed in polynomial expression');
       }
     } // end of recPoly
   } // end of polynomial
@@ -256,7 +252,7 @@ function factory(type, config, load, typed) {
   function rulesRationalize() {
     var oldRules = [simplifyCore, // sCore
     { l: 'n+n', r: '2*n' }, { l: 'n+-n', r: '0' }, simplifyConstant, // sConstant
-    { l: 'n*(n1^-1)', r: 'n/n1' }, { l: 'n*n1^-n2', r: 'n/n1^n2' }, { l: 'n1^-1', r: '1/n1' }, { l: 'n*(n1/n2)', r: '(n*n1)/n2' }, { l: '1*n', r: 'n' }];
+    { l: 'n*(n1^-1)', r: 'n/n1' }, { l: 'n*n1^-n2', r: 'n/n1^n2' }, { l: 'n1^-1', r: '1/n1' }, { l: 'n1^-n2', r: '1/n1^n2' }, { l: 'n*(n1/n2)', r: '(n*n1)/n2' }, { l: '1*n', r: 'n' }];
 
     var rulesFirst = [{ l: '(-n1)/(-n2)', r: 'n1/n2' }, // Unary division
     { l: '(-n1)*(-n2)', r: 'n1*n2' }, // Unary multiplication
@@ -513,25 +509,25 @@ function factory(type, config, load, typed) {
       if (tp === 'FunctionNode') {
         // ***** FunctionName *****
         // No function call in polynomial expression
-        throw new ArgumentsError('There is an unsolved function call');
+        throw new Error('There is an unsolved function call');
       } else if (tp === 'OperatorNode') {
         // ***** OperatorName *****
-        if ('+-*^'.indexOf(node.op) === -1) throw new ArgumentsError('Operator ' + node.op + ' invalid');
+        if ('+-*^'.indexOf(node.op) === -1) throw new Error('Operator ' + node.op + ' invalid');
 
         if (noPai !== null) {
           // -(unary),^  : children of *,+,-
           if ((node.fn === 'unaryMinus' || node.fn === 'pow') && noPai.fn !== 'add' && noPai.fn !== 'subtract' && noPai.fn !== 'multiply') {
-            throw new ArgumentsError('Invalid ' + node.op + ' placing');
+            throw new Error('Invalid ' + node.op + ' placing');
           }
 
           // -,+,* : children of +,-
           if ((node.fn === 'subtract' || node.fn === 'add' || node.fn === 'multiply') && noPai.fn !== 'add' && noPai.fn !== 'subtract') {
-            throw new ArgumentsError('Invalid ' + node.op + ' placing');
+            throw new Error('Invalid ' + node.op + ' placing');
           }
 
           // -,+ : first child
           if ((node.fn === 'subtract' || node.fn === 'add' || node.fn === 'unaryMinus') && o.noFil !== 0) {
-            throw new ArgumentsError('Invalid ' + node.op + ' placing');
+            throw new Error('Invalid ' + node.op + ' placing');
           }
         } // Has parent
 
@@ -554,7 +550,7 @@ function factory(type, config, load, typed) {
       } else if (tp === 'SymbolNode') {
         // ***** SymbolName *****
         if (node.name !== varname && varname !== '') {
-          throw new ArgumentsError('There is more than one variable');
+          throw new Error('There is more than one variable');
         }
         varname = node.name;
         if (noPai === null) {
@@ -564,12 +560,12 @@ function factory(type, config, load, typed) {
 
         // ^: Symbol is First child
         if (noPai.op === '^' && o.noFil !== 0) {
-          throw new ArgumentsError('In power the variable should be the first parameter');
+          throw new Error('In power the variable should be the first parameter');
         }
 
         // *: Symbol is Second child
         if (noPai.op === '*' && o.noFil !== 1) {
-          throw new ArgumentsError('In multiply the variable should be the second parameter');
+          throw new Error('In multiply the variable should be the second parameter');
         }
 
         // Symbol: firers '',* => it means there is no exponent above, so it's 1 (cte * var)
@@ -586,10 +582,10 @@ function factory(type, config, load, typed) {
         }
         if (noPai.op === '^') {
           // cte: second  child of power
-          if (o.noFil !== 1) throw new ArgumentsError('Constant cannot be powered');
+          if (o.noFil !== 1) throw new Error('Constant cannot be powered');
 
           if (!number.isInteger(valor) || valor <= 0) {
-            throw new ArgumentsError('Non-integer exponent is not allowed');
+            throw new Error('Non-integer exponent is not allowed');
           }
 
           for (var _i2 = maxExpo + 1; _i2 < valor; _i2++) {
@@ -606,7 +602,7 @@ function factory(type, config, load, typed) {
           coefficients[0] += o.cte * (o.oper === '+' ? 1 : -1);
         }
       } else {
-        throw new ArgumentsError('Type ' + tp + ' is not allowed');
+        throw new Error('Type ' + tp + ' is not allowed');
       }
     } // End of recurPol
   } // End of polyToCanonical

package/lib/function/algebra/simplify/resolve.js

@@ -38,7 +38,7 @@ function factory(type, config, load, typed, math) {
       var args = node.args.map(function (arg) {
         return resolve(arg, scope);
       });
-      return new OperatorNode(node.op, node.fn, args);
+      return new OperatorNode(node.op, node.fn, args, node.implicit);
     } else if (type.isParenthesisNode(node)) {
       return new ParenthesisNode(resolve(node.content, scope));
     } else if (type.isFunctionNode(node)) {

package/lib/function/algebra/simplify/simplifyCore.js

@@ -116,12 +116,12 @@ function factory(type, config, load, typed, math) {
             var a00 = _a.args[0];
             if (type.isConstantNode(a00)) {
               var a00a1 = new ConstantNode(multiply(a00.value, a1.value));
-              return new OperatorNode(node.op, node.fn, [a00a1, _a.args[1]]); // constants on left
+              return new OperatorNode(node.op, node.fn, [a00a1, _a.args[1]], node.implicit); // constants on left
             }
           }
-          return new OperatorNode(node.op, node.fn, [a1, _a]); // constants on left
+          return new OperatorNode(node.op, node.fn, [a1, _a], node.implicit); // constants on left
         }
-        return new OperatorNode(node.op, node.fn, [_a, a1]);
+        return new OperatorNode(node.op, node.fn, [_a, a1], node.implicit);
       } else if (node.op === '/') {
         if (type.isConstantNode(_a)) {
           if (isZero(_a.value)) {

package/lib/function/algebra/simplify/util.js

@@ -127,7 +127,7 @@ function factory(type, config, load, typed, math) {
     if (type.isOperatorNode(node)) {
       return function (args) {
         try {
-          return new OperatorNode(node.op, node.fn, args);
+          return new OperatorNode(node.op, node.fn, args, node.implicit);
         } catch (err) {
           console.error(err);
           return [];

package/lib/function/algebra/simplify.js

@@ -336,7 +336,12 @@ function factory(type, config, load, typed, math) {
         // const before = res.toString({parenthesis: 'all'})
 
         // Create a new node by cloning the rhs of the matched rule
+        // we keep any implicit multiplication state if relevant
+        var implicit = res.implicit;
         res = repl.clone();
+        if (implicit && 'implicit' in repl) {
+          res.implicit = true;
+        }
 
         // Replace placeholders with their respective nodes without traversing deeper into the replaced nodes
         var _transform = function _transform(node) {

package/lib/function/combinatorics/stirlingS2.js

@@ -30,7 +30,7 @@ function factory(type, config, load, typed) {
    *
    * See also:
    *
-   *    Bell numbers
+   *    bellNumbers
    *
    * @param {Number | BigNumber} n    Total number of objects in the set
    * @param {Number | BigNumber} k    Number of objects in the subset

package/lib/function/probability/combinations.js

@@ -1,7 +1,7 @@
 'use strict';
 
 var isInteger = require('../../utils/number').isInteger;
-
+var product = require('./product');
 function factory(type, config, load, typed) {
   /**
    * Compute the number of ways of picking `k` unordered outcomes from `n`
@@ -26,11 +26,11 @@ function factory(type, config, load, typed) {
    * @param {number | BigNumber} k    Number of objects in the subset
    * @return {number | BigNumber}     Number of possible combinations.
    */
+
   var combinations = typed('combinations', {
     'number, number': function numberNumber(n, k) {
-      var max = void 0,
-          result = void 0,
-          i = void 0;
+      var prodrange = void 0,
+          nMinusk = void 0;
 
       if (!isInteger(n) || n < 0) {
         throw new TypeError('Positive integer value expected in function combinations');
@@ -42,13 +42,14 @@ function factory(type, config, load, typed) {
         throw new TypeError('k must be less than or equal to n');
       }
 
-      max = Math.max(k, n - k);
-      result = 1;
-      for (i = 1; i <= n - max; i++) {
-        result = result * (max + i) / i;
-      }
+      nMinusk = n - k;
 
-      return result;
+      if (k < nMinusk) {
+        prodrange = product(nMinusk + 1, n);
+        return prodrange / product(1, k);
+      }
+      prodrange = product(k + 1, n);
+      return prodrange / product(1, nMinusk);
     },
 
     'BigNumber, BigNumber': function BigNumberBigNumber(n, k) {

package/lib/function/probability/gamma.js

@@ -6,7 +6,7 @@ var isInteger = require('../../utils/number').isInteger;
 function factory(type, config, load, typed) {
   var multiply = load(require('../arithmetic/multiply'));
   var pow = load(require('../arithmetic/pow'));
-
+  var product = require('./product');
   /**
    * Compute the gamma function of a value using Lanczos approximation for
    * small values, and an extended Stirling approximation for large values.
@@ -30,7 +30,9 @@ function factory(type, config, load, typed) {
    * @param {number | Array | Matrix} n   A real or complex number
    * @return {number | Array | Matrix}    The gamma of `n`
    */
+
   var gamma = typed('gamma', {
+
     'number': function number(n) {
       var t = void 0,
           x = void 0;
@@ -44,18 +46,7 @@ function factory(type, config, load, typed) {
           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;
+        return product(1, n - 1);
       }
 
       if (n < 0.5) {
@@ -150,6 +141,7 @@ function factory(type, config, load, typed) {
    * @param {BigNumber} n
    * @returns {BigNumber} Returns the factorial of n
    */
+
   function bigFactorial(n) {
     if (n.isZero()) {
       return new type.BigNumber(1); // 0! is per definition 1

package/lib/function/probability/permutations.js

@@ -4,7 +4,7 @@ var isInteger = require('../../utils/number').isInteger;
 
 function factory(type, config, load, typed) {
   var factorial = load(require('./factorial'));
-
+  var product = require('./product');
   /**
    * Compute the number of ways of obtaining an ordered subset of `k` elements
    * from a set of `n` elements.
@@ -32,11 +32,7 @@ function factory(type, config, load, typed) {
    */
   var permutations = typed('permutations', {
     'number | BigNumber': factorial,
-
     'number, number': function numberNumber(n, k) {
-      var result = void 0,
-          i = void 0;
-
       if (!isInteger(n) || n < 0) {
         throw new TypeError('Positive integer value expected in function permutations');
       }
@@ -46,14 +42,8 @@ function factory(type, config, load, typed) {
       if (k > n) {
         throw new TypeError('second argument k must be less than or equal to first argument n');
       }
-
       // Permute n objects, k at a time
-      result = 1;
-      for (i = n - k + 1; i <= n; i++) {
-        result = result * i;
-      }
-
-      return result;
+      return product(n - k + 1, n);
     },
 
     'BigNumber, BigNumber': function BigNumberBigNumber(n, k) {

package/lib/function/probability/product.js

@@ -0,0 +1,19 @@
+"use strict";
+
+/** @param {integer} i
+ *  @param {integer} n
+ *  @returns : product of i to n
+ */
+function product(i, n) {
+  var half = void 0;
+  if (n < i) {
+    return 1;
+  }
+  if (n === i) {
+    return n;
+  }
+  half = n + i >> 1; // divide (n + i) by 2 and truncate to integer
+  return product(i, half) * product(half + 1, n);
+}
+
+module.exports = product;

package/lib/function/string/format.js

@@ -37,8 +37,8 @@ function factory(type, config, load, typed) {
    *        For example '123.4' and '1.4e7'.
    *    - `precision: number`
    *      A number between 0 and 16 to round the digits of the number. In case
-   *      of notations 'exponential' and 'auto', `precision` defines the total
-   *      number of significant digits returned.
+   *      of notations 'exponential', 'engineering', and 'auto', `precision`
+   *      defines the total number of significant digits returned.
    *      In case of notation 'fixed', `precision` defines the number of
    *      significant digits after the decimal point.
    *      `precision` is undefined by default.

package/lib/function/utils/typeof.js

@@ -31,19 +31,19 @@ function factory(type, config, load, typed) {
    * math.type.Range        | `'Range'`     | `math.typeof(math.range(0, 10))`
    * math.type.ResultSet    | `'ResultSet'` | `math.typeof(math.eval('a=2\nb=3'))`
    * math.type.Unit         | `'Unit'`      | `math.typeof(math.unit('45 deg'))`
-   * math.expression.node.AccessorNode            | `'AccessorNode'`            | `math.typeof(math.parse('A[2]'))`
-   * math.expression.node.ArrayNode               | `'ArrayNode'`               | `math.typeof(math.parse('[1,2,3]'))`
-   * math.expression.node.AssignmentNode          | `'AssignmentNode'`          | `math.typeof(math.parse('x=2'))`
-   * math.expression.node.BlockNode               | `'BlockNode'`               | `math.typeof(math.parse('a=2; b=3'))`
-   * math.expression.node.ConditionalNode         | `'ConditionalNode'`         | `math.typeof(math.parse('x<0 ? -x : x'))`
-   * math.expression.node.ConstantNode            | `'ConstantNode'`            | `math.typeof(math.parse('2.3'))`
-   * math.expression.node.FunctionAssignmentNode  | `'FunctionAssignmentNode'`  | `math.typeof(math.parse('f(x)=x^2'))`
-   * math.expression.node.FunctionNode            | `'FunctionNode'`            | `math.typeof(math.parse('sqrt(4)'))`
-   * math.expression.node.IndexNode               | `'IndexNode'`               | `math.typeof(math.parse('A[2]').index)`
-   * math.expression.node.ObjectNode              | `'ObjectNode'`              | `math.typeof(math.parse('{a:2}'))`
-   * math.expression.node.ParenthesisNode         | `'ParenthesisNode'`         | `math.typeof(math.parse('(2+3)'))`
-   * math.expression.node.RangeNode               | `'RangeNode'`               | `math.typeof(math.parse('1:10'))`
-   * math.expression.node.SymbolNode              | `'SymbolNode'`              | `math.typeof(math.parse('x'))`
+   * math.expression.node&#8203;.AccessorNode            | `'AccessorNode'`            | `math.typeof(math.parse('A[2]'))`
+   * math.expression.node&#8203;.ArrayNode               | `'ArrayNode'`               | `math.typeof(math.parse('[1,2,3]'))`
+   * math.expression.node&#8203;.AssignmentNode          | `'AssignmentNode'`          | `math.typeof(math.parse('x=2'))`
+   * math.expression.node&#8203;.BlockNode               | `'BlockNode'`               | `math.typeof(math.parse('a=2; b=3'))`
+   * math.expression.node&#8203;.ConditionalNode         | `'ConditionalNode'`         | `math.typeof(math.parse('x<0 ? -x : x'))`
+   * math.expression.node&#8203;.ConstantNode            | `'ConstantNode'`            | `math.typeof(math.parse('2.3'))`
+   * math.expression.node&#8203;.FunctionAssignmentNode  | `'FunctionAssignmentNode'`  | `math.typeof(math.parse('f(x)=x^2'))`
+   * math.expression.node&#8203;.FunctionNode            | `'FunctionNode'`            | `math.typeof(math.parse('sqrt(4)'))`
+   * math.expression.node&#8203;.IndexNode               | `'IndexNode'`               | `math.typeof(math.parse('A[2]').index)`
+   * math.expression.node&#8203;.ObjectNode              | `'ObjectNode'`              | `math.typeof(math.parse('{a:2}'))`
+   * math.expression.node&#8203;.ParenthesisNode         | `'ParenthesisNode'`         | `math.typeof(math.parse('(2+3)'))`
+   * math.expression.node&#8203;.RangeNode               | `'RangeNode'`               | `math.typeof(math.parse('1:10'))`
+   * math.expression.node&#8203;.SymbolNode              | `'SymbolNode'`              | `math.typeof(math.parse('x'))`
    *
    * Syntax:
    *

package/lib/index.js

@@ -4,8 +4,12 @@
 
 module.exports = [require('./type'), // data types (Matrix, Complex, Unit, ...)
 require('./constants'), // constants
-require('./expression'), // expression parsing
 require('./function'), // functions
+
+// load ./expression *after* ./function since we need to
+// attach transforms to functions that are imported there
+require('./expression'), // expression parsing
+
 require('./json'), // serialization utility (math.json.reviver)
 require('./error') // errors
 ];

package/lib/type/bignumber/BigNumber.js

@@ -1,9 +1,13 @@
 'use strict';
 
-var Decimal = require('decimal.js/decimal.js'); // make sure to pick the es5 version
+var _decimal = require('decimal.js');
+
+var _decimal2 = _interopRequireDefault(_decimal);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function factory(type, config, load, typed, math) {
-  var BigNumber = Decimal.clone({ precision: config.precision });
+  var BigNumber = _decimal2.default.clone({ precision: config.precision });
 
   /**
    * Attach type information

package/lib/type/matrix/utils/algorithm13.js

@@ -55,8 +55,6 @@ function factory(type, config, load, typed) {
     if (typeof adt === 'string' && adt === bdt) {
       // datatype
       dt = adt;
-      // convert b to the same datatype
-      b = typed.convert(b, dt);
       // callback
       cf = typed.find(callback, [dt, dt]);
     }

package/lib/type/unit/Unit.js

@@ -807,7 +807,7 @@ function factory(type, config, load, typed, math) {
       // other = new Unit(null, valuelessUnit)
       other = Unit.parse(valuelessUnit);
       if (!this.equalBase(other)) {
-        throw new Error('Units do not match');
+        throw new Error('Units do not match (\'' + other.toString() + '\' != \'' + this.toString() + '\')');
       }
       if (other.value !== null) {
         throw new Error('Cannot convert to a unit with a value');
@@ -819,7 +819,7 @@ function factory(type, config, load, typed, math) {
       return other;
     } else if (type.isUnit(valuelessUnit)) {
       if (!this.equalBase(valuelessUnit)) {
-        throw new Error('Units do not match');
+        throw new Error('Units do not match (\'' + valuelessUnit.toString() + '\' != \'' + this.toString() + '\')');
       }
       if (valuelessUnit.value !== null) {
         throw new Error('Cannot convert to a unit with a value');

package/lib/utils/array.js

@@ -247,6 +247,15 @@ function reshape(array, sizes) {
     throw new _DimensionError2.default(0, product(exports.size(array)), '!=');
   }
 
+  var totalSize = 1;
+  for (var sizeIndex = 0; sizeIndex < sizes.length; sizeIndex++) {
+    totalSize *= sizes[sizeIndex];
+  }
+
+  if (flatArray.length !== totalSize) {
+    throw new _DimensionError2.default(product(sizes), product(exports.size(array)), '!=');
+  }
+
   try {
     newArray = _reshape(flatArray, sizes);
   } catch (e) {
@@ -256,37 +265,36 @@ function reshape(array, sizes) {
     throw e;
   }
 
-  if (flatArray.length > 0) {
-    throw new _DimensionError2.default(product(sizes), product(exports.size(array)), '!=');
-  }
-
   return newArray;
 }
 
 /**
- * Recursively re-shape a multi dimensional array to fit the specified dimensions
+ * Iteratively re-shape a multi dimensional array to fit the specified dimensions
  * @param {Array} array           Array to be reshaped
  * @param {Array.<number>} sizes  List of sizes for each dimension
  * @returns {Array}               Array whose data has been formatted to fit the
  *                                specified dimensions
- *
- * @throws {DimensionError}       If the product of the new dimension sizes does
- *                                not equal that of the old ones
  */
-function _reshape(array, sizes) {
-  var accumulator = [];
-  var i = void 0;
 
-  if (sizes.length === 0) {
-    if (array.length === 0) {
-      throw new _DimensionError2.default(null, null, '!=');
+function _reshape(array, sizes) {
+  // testing if there are enough elements for the requested shape
+  var tmpArray = array;
+  var tmpArray2;
+  // for each dimensions starting by the last one and ignoring the first one
+  for (var sizeIndex = sizes.length - 1; sizeIndex > 0; sizeIndex--) {
+    var size = sizes[sizeIndex];
+    tmpArray2 = [];
+
+    // aggregate the elements of the current tmpArray in elements of the requested size
+    var length = tmpArray.length / size;
+    for (var i = 0; i < length; i++) {
+      tmpArray2.push(tmpArray.slice(i * size, (i + 1) * size));
     }
-    return array.shift();
+    // set it as the new tmpArray for the next loop turn or for return
+    tmpArray = tmpArray2;
   }
-  for (i = 0; i < sizes[0]; i += 1) {
-    accumulator.push(_reshape(array, sizes.slice(1)));
-  }
-  return accumulator;
+
+  return tmpArray;
 }
 
 /**

package/lib/utils/bignumber/formatter.js

@@ -31,8 +31,9 @@ var objectUtils = require('../object');
  *                                          For example '123.4' and '1.4e7'.
  *                     {number} precision   A number between 0 and 16 to round
  *                                          the digits of the number.
- *                                          In case of notations 'exponential' and
- *                                          'auto', `precision` defines the total
+ *                                          In case of notations 'exponential',
+ *                                          'engineering', and 'auto',
+ *                                          `precision` defines the total
  *                                          number of significant digits returned.
  *                                          In case of notation 'fixed',
  *                                          `precision` defines the number of