mathjs 5.0.3 → 5.0.4

package/docs/reference/functions/typeof.md

@@ -29,19 +29,19 @@ math.type.Matrix       | `'Matrix'`    | `math.typeof(math.matrix([[1,2], [3, 4]
 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/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/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/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/version.js

@@ -1,5 +1,5 @@
 'use strict';
 
-module.exports = '5.0.3';
+module.exports = '5.0.4';
 // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mathjs",
-  "version": "5.0.3",
+  "version": "5.0.4",
   "description": "Math.js is an extensive math library for JavaScript and Node.js. It features a flexible expression parser with support for symbolic computation, comes with a large set of built-in functions and constants, and offers an integrated solution to work with different data types like numbers, big numbers, complex numbers, fractions, units, and matrices.",
   "author": "Jos de Jong <wjosdejong@gmail.com> (https://github.com/josdejong)",
   "contributors": [
@@ -30,6 +30,7 @@
     "Gary Passero (https://github.com/gap777)",
     "Harry Sarson (https://github.com/HarrySarson)",
     "Holman Gao (https://github.com/golmansax)",
+    "Honybar (https://github.com/honeybar)",
     "Guillermo Indalecio Fernández (https://github.com/guillermobox)",
     "Gulfaraz (https://github.com/gulfaraz)",
     "hamadu (https://github.com/hamadu)",

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/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/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/version.js

@@ -1,3 +1,3 @@
-module.exports = '5.0.3'
+module.exports = '5.0.4'
 // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.