mathjs 5.0.0 → 5.0.4

package/src/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/src/function/algebra/rationalize.js

@@ -4,7 +4,6 @@ function factory (type, config, load, typed) {
   const simplify = load(require('./simplify'))
   const simplifyCore = load(require('./simplify/simplifyCore'))
   const simplifyConstant = load(require('./simplify/simplifyConstant'))
-  const ArgumentsError = require('../../error/ArgumentsError')
   const parse = load(require('../../expression/function/parse'))
   const number = require('../../utils/number')
   const 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:
    *
@@ -98,31 +100,20 @@ function factory (type, config, load, typed) {
       if (nVars >= 1) { // If expression in not a constant
         const setRules = rulesRationalize() // Rules for change polynomial in near canonical form
         expr = expandPower(expr) // First expand power of polynomials (cannot be made from rules!)
-        let redoInic = true // If has change after start, redo the beginning
-        let s = '' // New expression
         let sBefore // Previous expression
-        let rules
-        let 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()
+          const 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
 
       const coefficients = []
@@ -208,17 +199,23 @@ function factory (type, config, load, typed) {
       const 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 (let i = 0; i < node.args.length; i++) {
             recPoly(node.args[i])
@@ -234,7 +231,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
@@ -257,6 +254,7 @@ function factory (type, config, load, typed) {
       {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'}]
 
@@ -493,23 +491,23 @@ 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') }
+                                noPai.fn !== 'subtract' && noPai.fn !== 'multiply') { 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') }
+              noPai.fn !== 'add' && noPai.fn !== 'subtract') { 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') }
+            node.fn === 'unaryMinus') && o.noFil !== 0) { throw new Error('Invalid ' + node.op + ' placing') }
         } // Has parent
 
         // Firers: ^,*       Old:   ^,&,-(unary): firers
@@ -529,7 +527,7 @@ function factory (type, config, load, typed) {
           recurPol(node.args[i], node, o)
         } // for in children
       } else if (tp === 'SymbolNode') { // ***** SymbolName *****
-        if (node.name !== varname && varname !== '') { throw new ArgumentsError('There is more than one variable') }
+        if (node.name !== varname && varname !== '') { throw new Error('There is more than one variable') }
         varname = node.name
         if (noPai === null) {
           coefficients[1] = 1
@@ -537,10 +535,10 @@ 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') }
+        if (noPai.op === '^' && o.noFil !== 0) { 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') }
+        if (noPai.op === '*' && o.noFil !== 1) { 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)
         if (o.fire === '' || o.fire === '*') {
@@ -556,9 +554,9 @@ 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') }
+          if (!number.isInteger(valor) || valor <= 0) { throw new Error('Non-integer exponent is not allowed') }
 
           for (let i = maxExpo + 1; i < valor; i++) coefficients[i] = 0
           if (valor > maxExpo) coefficients[valor] = 0
@@ -570,7 +568,7 @@ function factory (type, config, load, typed) {
 
         // Cte: firer '' => There is no exponent and no multiplication, so the exponent is 0.
         if (o.fire === '') { coefficients[0] += o.cte * (o.oper === '+' ? 1 : -1) }
-      } else { throw new ArgumentsError('Type ' + tp + ' is not allowed') }
+      } else { throw new Error('Type ' + tp + ' is not allowed') }
     } // End of recurPol
   } // End of polyToCanonical
 

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

@@ -38,7 +38,7 @@ function factory (type, config, load, typed, math) {
       const 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/src/function/algebra/simplify/simplifyCore.js

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

package/src/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/src/function/algebra/simplify.js

@@ -351,7 +351,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
+        const 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
         const _transform = function (node) {

package/src/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/src/function/probability/combinations.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const isInteger = require('../../utils/number').isInteger
-
+const product = require('./product')
 function factory (type, config, load, typed) {
   /**
    * Compute the number of ways of picking `k` unordered outcomes from `n`
@@ -26,9 +26,10 @@ function factory (type, config, load, typed) {
    * @param {number | BigNumber} k    Number of objects in the subset
    * @return {number | BigNumber}     Number of possible combinations.
    */
+
   const combinations = typed('combinations', {
     'number, number': function (n, k) {
-      let max, result, i
+      let prodrange, nMinusk
 
       if (!isInteger(n) || n < 0) {
         throw new TypeError('Positive integer value expected in function combinations')
@@ -40,13 +41,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 (n, k) {

package/src/function/probability/gamma.js

@@ -6,7 +6,7 @@ const isInteger = require('../../utils/number').isInteger
 function factory (type, config, load, typed) {
   const multiply = load(require('../arithmetic/multiply'))
   const pow = load(require('../arithmetic/pow'))
-
+  const 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`
    */
+
   const gamma = typed('gamma', {
+
     'number': function (n) {
       let t, x
 
@@ -43,18 +45,7 @@ function factory (type, config, load, typed) {
           return Infinity // Will overflow
         }
 
-        let value = n - 2
-        let 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) {
@@ -153,6 +144,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/src/function/probability/permutations.js

@@ -4,7 +4,7 @@ const isInteger = require('../../utils/number').isInteger
 
 function factory (type, config, load, typed) {
   const factorial = load(require('./factorial'))
-
+  const product = require('./product')
   /**
    * Compute the number of ways of obtaining an ordered subset of `k` elements
    * from a set of `n` elements.
@@ -32,10 +32,7 @@ function factory (type, config, load, typed) {
    */
   const permutations = typed('permutations', {
     'number | BigNumber': factorial,
-
     'number, number': function (n, k) {
-      let result, i
-
       if (!isInteger(n) || n < 0) {
         throw new TypeError('Positive integer value expected in function permutations')
       }
@@ -45,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 (n, k) {

package/src/function/probability/product.js

@@ -0,0 +1,17 @@
+/** @param {integer} i
+ *  @param {integer} n
+ *  @returns : product of i to n
+ */
+function product (i, n) {
+  let half
+  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/src/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/src/function/utils/typeof.js

@@ -29,19 +29,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/src/index.js

@@ -3,8 +3,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/src/type/bignumber/BigNumber.js

@@ -1,5 +1,6 @@
 'use strict'
-const Decimal = require('decimal.js/decimal.js') // make sure to pick the es5 version
+
+import Decimal from 'decimal.js'
 
 function factory (type, config, load, typed, math) {
   const BigNumber = Decimal.clone({precision: config.precision})

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

@@ -51,8 +51,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/src/type/unit/Unit.js

@@ -801,7 +801,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')
@@ -813,7 +813,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/src/utils/array.js

@@ -218,6 +218,19 @@ export function reshape (array, sizes) {
     throw new DimensionError(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 DimensionError(
+      product(sizes),
+      product(exports.size(array)),
+      '!='
+    )
+  }
+
   try {
     newArray = _reshape(flatArray, sizes)
   } catch (e) {
@@ -231,41 +244,36 @@ export function reshape (array, sizes) {
     throw e
   }
 
-  if (flatArray.length > 0) {
-    throw new DimensionError(
-      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) {
-  let accumulator = []
-  let i
 
-  if (sizes.length === 0) {
-    if (array.length === 0) {
-      throw new DimensionError(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()
-  }
-  for (i = 0; i < sizes[0]; i += 1) {
-    accumulator.push(_reshape(array, sizes.slice(1)))
+    // set it as the new tmpArray for the next loop turn or for return
+    tmpArray = tmpArray2
   }
-  return accumulator
+
+  return tmpArray
 }
 
 /**

package/src/utils/bignumber/formatter.js

@@ -31,8 +31,9 @@ const 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