mathjs 8.1.0 → 12.2.1

package/lib/cjs/function/matrix/inv.js

@@ -4,28 +4,22 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createInv = void 0;
-
 var _is = require("../../utils/is.js");
-
 var _array = require("../../utils/array.js");
-
 var _factory = require("../../utils/factory.js");
-
 var _string = require("../../utils/string.js");
-
 var name = 'inv';
 var dependencies = ['typed', 'matrix', 'divideScalar', 'addScalar', 'multiply', 'unaryMinus', 'det', 'identity', 'abs'];
-var createInv = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+var createInv = exports.createInv = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
-      matrix = _ref.matrix,
-      divideScalar = _ref.divideScalar,
-      addScalar = _ref.addScalar,
-      multiply = _ref.multiply,
-      unaryMinus = _ref.unaryMinus,
-      det = _ref.det,
-      identity = _ref.identity,
-      abs = _ref.abs;
-
+    matrix = _ref.matrix,
+    divideScalar = _ref.divideScalar,
+    addScalar = _ref.addScalar,
+    multiply = _ref.multiply,
+    unaryMinus = _ref.unaryMinus,
+    det = _ref.det,
+    identity = _ref.identity,
+    abs = _ref.abs;
   /**
    * Calculate the inverse of a square matrix.
    *
@@ -49,7 +43,6 @@ var createInv = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
   return typed(name, {
     'Array | Matrix': function ArrayMatrix(x) {
       var size = (0, _is.isMatrix)(x) ? x.size() : (0, _array.arraySize)(x);
-
       switch (size.length) {
         case 1:
           // vector
@@ -62,13 +55,11 @@ var createInv = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
           } else {
             throw new RangeError('Matrix must be square ' + '(size: ' + (0, _string.format)(size) + ')');
           }
-
         case 2:
           // two dimensional array
           {
             var rows = size[0];
             var cols = size[1];
-
             if (rows === cols) {
               if ((0, _is.isMatrix)(x)) {
                 return matrix(_inv(x.valueOf(), rows, cols), x.storage());
@@ -80,7 +71,6 @@ var createInv = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
               throw new RangeError('Matrix must be square ' + '(size: ' + (0, _string.format)(size) + ')');
             }
           }
-
         default:
           // multi dimensional array
           throw new RangeError('Matrix must be two dimensional ' + '(size: ' + (0, _string.format)(size) + ')');
@@ -91,6 +81,7 @@ var createInv = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
       return divideScalar(1, x); // FIXME: create a BigNumber one when configured for bignumbers
     }
   });
+
   /**
    * Calculate the inverse of a square matrix
    * @param {Array[]} mat     A square matrix
@@ -99,27 +90,21 @@ var createInv = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
    * @return {Array[]} inv    Inverse matrix
    * @private
    */
-
   function _inv(mat, rows, cols) {
     var r, s, f, value, temp;
-
     if (rows === 1) {
       // this is a 1 x 1 matrix
       value = mat[0][0];
-
       if (value === 0) {
         throw Error('Cannot calculate inverse, determinant is zero');
       }
-
       return [[divideScalar(1, value)]];
     } else if (rows === 2) {
       // this is a 2 x 2 matrix
       var d = det(mat);
-
       if (d === 0) {
         throw Error('Cannot calculate inverse, determinant is zero');
       }
-
       return [[divideScalar(mat[1][1], d), divideScalar(unaryMinus(mat[0][1]), d)], [divideScalar(unaryMinus(mat[1][0]), d), divideScalar(mat[0][0], d)]];
     } else {
       // this is a matrix of 3 x 3 or larger
@@ -127,38 +112,34 @@ var createInv = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
       //      https://en.wikipedia.org/wiki/Gaussian_elimination
       //      http://mathworld.wolfram.com/MatrixInverse.html
       //      http://math.uww.edu/~mcfarlat/inverse.htm
+
       // make a copy of the matrix (only the arrays, not of the elements)
       var A = mat.concat();
-
       for (r = 0; r < rows; r++) {
         A[r] = A[r].concat();
-      } // create an identity matrix which in the end will contain the
-      // matrix inverse
-
+      }
 
-      var B = identity(rows).valueOf(); // loop over all columns, and perform row reductions
+      // create an identity matrix which in the end will contain the
+      // matrix inverse
+      var B = identity(rows).valueOf();
 
+      // loop over all columns, and perform row reductions
       for (var c = 0; c < cols; c++) {
         // Pivoting: Swap row c with row r, where row r contains the largest element A[r][c]
         var ABig = abs(A[c][c]);
         var rBig = c;
         r = c + 1;
-
         while (r < rows) {
           if (abs(A[r][c]) > ABig) {
             ABig = abs(A[r][c]);
             rBig = r;
           }
-
           r++;
         }
-
         if (ABig === 0) {
           throw Error('Cannot calculate inverse, determinant is zero');
         }
-
         r = rBig;
-
         if (r !== c) {
           temp = A[c];
           A[c] = A[r];
@@ -166,26 +147,24 @@ var createInv = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
           temp = B[c];
           B[c] = B[r];
           B[r] = temp;
-        } // eliminate non-zero values on the other rows at column c
-
+        }
 
+        // eliminate non-zero values on the other rows at column c
         var Ac = A[c];
         var Bc = B[c];
-
         for (r = 0; r < rows; r++) {
           var Ar = A[r];
           var Br = B[r];
-
           if (r !== c) {
             // eliminate value at column c and row r
             if (Ar[c] !== 0) {
-              f = divideScalar(unaryMinus(Ar[c]), Ac[c]); // add (f * row c) to row r to eliminate the value
-              // at column c
+              f = divideScalar(unaryMinus(Ar[c]), Ac[c]);
 
+              // add (f * row c) to row r to eliminate the value
+              // at column c
               for (s = c; s < cols; s++) {
                 Ar[s] = addScalar(Ar[s], multiply(f, Ac[s]));
               }
-
               for (s = 0; s < cols; s++) {
                 Br[s] = addScalar(Br[s], multiply(f, Bc[s]));
               }
@@ -194,20 +173,16 @@ var createInv = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
             // normalize value at Acc to 1,
             // divide each value on row r with the value at Acc
             f = Ac[c];
-
             for (s = c; s < cols; s++) {
               Ar[s] = divideScalar(Ar[s], f);
             }
-
             for (s = 0; s < cols; s++) {
               Br[s] = divideScalar(Br[s], f);
             }
           }
         }
       }
-
       return B;
     }
   }
-});
-exports.createInv = createInv;
+});

package/lib/cjs/function/matrix/kron.js

@@ -4,18 +4,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createKron = void 0;
-
 var _array = require("../../utils/array.js");
-
 var _factory = require("../../utils/factory.js");
-
 var name = 'kron';
 var dependencies = ['typed', 'matrix', 'multiplyScalar'];
-var createKron = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+var createKron = exports.createKron = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
-      matrix = _ref.matrix,
-      multiplyScalar = _ref.multiplyScalar;
-
+    matrix = _ref.matrix,
+    multiplyScalar = _ref.multiplyScalar;
   /**
      * Calculates the kronecker product of 2 matrices or vectors.
      *
@@ -55,6 +51,7 @@ var createKron = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
     },
     'Array, Array': _kron
   });
+
   /**
      * Calculate the kronecker product of two matrices / vectors
      * @param {Array} a  First vector
@@ -62,23 +59,19 @@ var createKron = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
      * @returns {Array} Returns the kronecker product of x and y
      * @private
      */
-
   function _kron(a, b) {
     // Deal with the dimensions of the matricies.
     if ((0, _array.arraySize)(a).length === 1) {
       // Wrap it in a 2D Matrix
       a = [a];
     }
-
     if ((0, _array.arraySize)(b).length === 1) {
       // Wrap it in a 2D Matrix
       b = [b];
     }
-
     if ((0, _array.arraySize)(a).length > 2 || (0, _array.arraySize)(b).length > 2) {
       throw new RangeError('Vectors with dimensions greater then 2 are not supported expected ' + '(Size x = ' + JSON.stringify(a.length) + ', y = ' + JSON.stringify(b.length) + ')');
     }
-
     var t = [];
     var r = [];
     return a.map(function (a) {
@@ -93,5 +86,4 @@ var createKron = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
       });
     }) && t;
   }
-});
-exports.createKron = createKron;
+});

package/lib/cjs/function/matrix/map.js

@@ -4,19 +4,22 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createMap = void 0;
-
-var _function = require("../../utils/function.js");
-
+var _applyCallback = require("../../utils/applyCallback.js");
 var _factory = require("../../utils/factory.js");
-
 var name = 'map';
 var dependencies = ['typed'];
-var createMap = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+var createMap = exports.createMap = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed;
-
   /**
-   * Create a new matrix or array with the results of the callback function executed on
-   * each entry of the matrix/array.
+   * Create a new matrix or array with the results of a callback function executed on
+   * each entry of a given matrix/array.
+   *
+   * For each entry of the input, the callback is invoked with three arguments:
+   * the value of the entry, the index at which that entry occurs, and the full
+   * matrix/array being traversed. Note that because the matrix/array might be
+   * multidimensional, the "index" argument is always an array of numbers giving
+   * the index in each dimension. This is true even for vectors: the "index"
+   * argument is an array of length 1, rather than simply a number.
    *
    * Syntax:
    *
@@ -28,15 +31,20 @@ var createMap = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
    *      return value * value
    *    })  // returns [1, 4, 9]
    *
+   *    // The callback is normally called with three arguments:
+   *    //    callback(value, index, Array)
+   *    // If you want to call with only one argument, use:
+   *    math.map([1, 2, 3], x => math.format(x)) // returns ['1', '2', '3']
+   *
    * See also:
    *
    *    filter, forEach, sort
    *
-   * @param {Matrix | Array} x    The matrix to iterate on.
-   * @param {Function} callback   The callback method is invoked with three
-   *                              parameters: the value of the element, the index
-   *                              of the element, and the matrix being traversed.
-   * @return {Matrix | array}     Transformed map of x
+   * @param {Matrix | Array} x    The input to iterate on.
+   * @param {Function} callback
+   *     The function to call (as described above) on each entry of the input
+   * @return {Matrix | array}
+   *     Transformed map of x; always has the same type and shape as x
    */
   return typed(name, {
     'Array, function': _map,
@@ -45,6 +53,7 @@ var createMap = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
     }
   });
 });
+
 /**
  * Map for a multi dimensional array
  * @param {Array} array
@@ -52,13 +61,7 @@ var createMap = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
  * @return {Array}
  * @private
  */
-
-exports.createMap = createMap;
-
 function _map(array, callback) {
-  // figure out what number of arguments the callback function expects
-  var args = (0, _function.maxArgumentCount)(callback);
-
   var recurse = function recurse(value, index) {
     if (Array.isArray(value)) {
       return value.map(function (child, i) {
@@ -67,16 +70,8 @@ function _map(array, callback) {
       });
     } else {
       // invoke the callback function with the right number of arguments
-      if (args === 1) {
-        return callback(value);
-      } else if (args === 2) {
-        return callback(value, index);
-      } else {
-        // 3 or -1
-        return callback(value, index, array);
-      }
+      return (0, _applyCallback.applyCallback)(callback, value, index, array, 'map');
     }
   };
-
   return recurse(array, []);
 }

package/lib/cjs/function/matrix/matrixFromColumns.js

@@ -0,0 +1,106 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMatrixFromColumns = void 0;
+var _factory = require("../../utils/factory.js");
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+var name = 'matrixFromColumns';
+var dependencies = ['typed', 'matrix', 'flatten', 'size'];
+var createMatrixFromColumns = exports.createMatrixFromColumns = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    matrix = _ref.matrix,
+    flatten = _ref.flatten,
+    size = _ref.size;
+  /**
+   * Create a dense matrix from vectors as individual columns.
+   * If you pass row vectors, they will be transposed (but not conjugated!)
+   *
+   * Syntax:
+   *
+   *    math.matrixFromColumns(...arr)
+   *    math.matrixFromColumns(col1, col2)
+   *    math.matrixFromColumns(col1, col2, col3)
+   *
+   * Examples:
+   *
+   *    math.matrixFromColumns([1, 2, 3], [[4],[5],[6]])
+   *    math.matrixFromColumns(...vectors)
+   *
+   * See also:
+   *
+   *    matrix, matrixFromRows, matrixFromFunction, zeros
+   *
+   * @param {... Array | Matrix} cols Multiple columns
+   * @return { number[][] | Matrix } if at least one of the arguments is an array, an array will be returned
+   */
+  return typed(name, {
+    '...Array': function Array(arr) {
+      return _createArray(arr);
+    },
+    '...Matrix': function Matrix(arr) {
+      return matrix(_createArray(arr.map(function (m) {
+        return m.toArray();
+      })));
+    }
+
+    // TODO implement this properly for SparseMatrix
+  });
+  function _createArray(arr) {
+    if (arr.length === 0) throw new TypeError('At least one column is needed to construct a matrix.');
+    var N = checkVectorTypeAndReturnLength(arr[0]);
+
+    // create an array with empty rows
+    var result = [];
+    for (var i = 0; i < N; i++) {
+      result[i] = [];
+    }
+
+    // loop columns
+    var _iterator = _createForOfIteratorHelper(arr),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var col = _step.value;
+        var colLength = checkVectorTypeAndReturnLength(col);
+        if (colLength !== N) {
+          throw new TypeError('The vectors had different length: ' + (N | 0) + ' ≠ ' + (colLength | 0));
+        }
+        var f = flatten(col);
+
+        // push a value to each row
+        for (var _i = 0; _i < N; _i++) {
+          result[_i].push(f[_i]);
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return result;
+  }
+  function checkVectorTypeAndReturnLength(vec) {
+    var s = size(vec);
+    if (s.length === 1) {
+      // 1D vector
+      return s[0];
+    } else if (s.length === 2) {
+      // 2D vector
+      if (s[0] === 1) {
+        // row vector
+        return s[1];
+      } else if (s[1] === 1) {
+        // col vector
+        return s[0];
+      } else {
+        throw new TypeError('At least one of the arguments is not a vector.');
+      }
+    } else {
+      throw new TypeError('Only one- or two-dimensional vectors are supported.');
+    }
+  }
+});

package/lib/cjs/function/matrix/matrixFromFunction.js

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMatrixFromFunction = void 0;
+var _factory = require("../../utils/factory.js");
+var name = 'matrixFromFunction';
+var dependencies = ['typed', 'matrix', 'isZero'];
+var createMatrixFromFunction = exports.createMatrixFromFunction = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    matrix = _ref.matrix,
+    isZero = _ref.isZero;
+  /**
+   * Create a matrix by evaluating a generating function at each index.
+   * The simplest overload returns a multi-dimensional array as long as `size` is an array.
+   * Passing `size` as a Matrix or specifying a `format` will result in returning a Matrix.
+   *
+   * Syntax:
+   *
+   *    math.matrixFromFunction(size, fn)
+   *    math.matrixFromFunction(size, fn, format)
+   *    math.matrixFromFunction(size, fn, format, datatype)
+   *    math.matrixFromFunction(size, format, fn)
+   *    math.matrixFromFunction(size, format, datatype, fn)
+   *
+   * Examples:
+   *
+   *    math.matrixFromFunction([3,3], i => i[0] - i[1]) // an antisymmetric matrix
+   *    math.matrixFromFunction([100, 100], 'sparse', i => i[0] - i[1] === 1 ? 4 : 0) // a sparse subdiagonal matrix
+   *    math.matrixFromFunction([5], i => math.random()) // a random vector
+   *
+   * See also:
+   *
+   *    matrix, zeros
+   *
+   * @param {Array | Matrix} size   The size of the matrix to be created
+   * @param {function} fn           Callback function invoked for every entry in the matrix
+   * @param {string} [format]       The Matrix storage format, either `'dense'` or `'sparse'`
+   * @param {string} [datatype]     Type of the values
+   * @return {Array | Matrix} Returns the created matrix
+   */
+  return typed(name, {
+    'Array | Matrix, function, string, string': function ArrayMatrixFunctionStringString(size, fn, format, datatype) {
+      return _create(size, fn, format, datatype);
+    },
+    'Array | Matrix, function, string': function ArrayMatrixFunctionString(size, fn, format) {
+      return _create(size, fn, format);
+    },
+    'Matrix, function': function MatrixFunction(size, fn) {
+      return _create(size, fn, 'dense');
+    },
+    'Array, function': function ArrayFunction(size, fn) {
+      return _create(size, fn, 'dense').toArray();
+    },
+    'Array | Matrix, string, function': function ArrayMatrixStringFunction(size, format, fn) {
+      return _create(size, fn, format);
+    },
+    'Array | Matrix, string, string, function': function ArrayMatrixStringStringFunction(size, format, datatype, fn) {
+      return _create(size, fn, format, datatype);
+    }
+  });
+  function _create(size, fn, format, datatype) {
+    var m;
+    if (datatype !== undefined) {
+      m = matrix(format, datatype);
+    } else {
+      m = matrix(format);
+    }
+    m.resize(size);
+    m.forEach(function (_, index) {
+      var val = fn(index);
+      if (isZero(val)) return;
+      m.set(index, val);
+    });
+    return m;
+  }
+});

package/lib/cjs/function/matrix/matrixFromRows.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMatrixFromRows = void 0;
+var _factory = require("../../utils/factory.js");
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+var name = 'matrixFromRows';
+var dependencies = ['typed', 'matrix', 'flatten', 'size'];
+var createMatrixFromRows = exports.createMatrixFromRows = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    matrix = _ref.matrix,
+    flatten = _ref.flatten,
+    size = _ref.size;
+  /**
+   * Create a dense matrix from vectors as individual rows.
+   * If you pass column vectors, they will be transposed (but not conjugated!)
+   *
+   * Syntax:
+   *
+   *    math.matrixFromRows(...arr)
+   *    math.matrixFromRows(row1, row2)
+   *    math.matrixFromRows(row1, row2, row3)
+   *
+   * Examples:
+   *
+   *    math.matrixFromRows([1, 2, 3], [[4],[5],[6]])
+   *    math.matrixFromRows(...vectors)
+   *
+   * See also:
+   *
+   *    matrix, matrixFromColumns, matrixFromFunction, zeros
+   *
+   * @param {... Array | Matrix} rows  Multiple rows
+   * @return { number[][] | Matrix } if at least one of the arguments is an array, an array will be returned
+   */
+  return typed(name, {
+    '...Array': function Array(arr) {
+      return _createArray(arr);
+    },
+    '...Matrix': function Matrix(arr) {
+      return matrix(_createArray(arr.map(function (m) {
+        return m.toArray();
+      })));
+    }
+
+    // TODO implement this properly for SparseMatrix
+  });
+  function _createArray(arr) {
+    if (arr.length === 0) throw new TypeError('At least one row is needed to construct a matrix.');
+    var N = checkVectorTypeAndReturnLength(arr[0]);
+    var result = [];
+    var _iterator = _createForOfIteratorHelper(arr),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var row = _step.value;
+        var rowLength = checkVectorTypeAndReturnLength(row);
+        if (rowLength !== N) {
+          throw new TypeError('The vectors had different length: ' + (N | 0) + ' ≠ ' + (rowLength | 0));
+        }
+        result.push(flatten(row));
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return result;
+  }
+  function checkVectorTypeAndReturnLength(vec) {
+    var s = size(vec);
+    if (s.length === 1) {
+      // 1D vector
+      return s[0];
+    } else if (s.length === 2) {
+      // 2D vector
+      if (s[0] === 1) {
+        // row vector
+        return s[1];
+      } else if (s[1] === 1) {
+        // col vector
+        return s[0];
+      } else {
+        throw new TypeError('At least one of the arguments is not a vector.');
+      }
+    } else {
+      throw new TypeError('Only one- or two-dimensional vectors are supported.');
+    }
+  }
+});