mathjs 8.1.0 → 12.2.1

package/lib/esm/type/matrix/DenseMatrix.js

@@ -1,30 +1,29 @@
 import { isArray, isBigNumber, isCollection, isIndex, isMatrix, isNumber, isString, typeOf } from '../../utils/is.js';
-import { arraySize, getArrayDataType, reshape, resize, unsqueeze, validate, validateIndex } from '../../utils/array.js';
+import { arraySize, getArrayDataType, processSizesWildcard, reshape, resize, unsqueeze, validate, validateIndex, broadcastTo } from '../../utils/array.js';
 import { format } from '../../utils/string.js';
 import { isInteger } from '../../utils/number.js';
 import { clone, deepStrictEqual } from '../../utils/object.js';
 import { DimensionError } from '../../error/DimensionError.js';
 import { factory } from '../../utils/factory.js';
+import { maxArgumentCount } from '../../utils/function.js';
 var name = 'DenseMatrix';
 var dependencies = ['Matrix'];
-export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     Matrix
   } = _ref;
-
   /**
    * Dense Matrix implementation. A regular, dense matrix, supporting multi-dimensional matrices. This is the default matrix type.
    * @class DenseMatrix
+   * @enum {{ value, index: number[] }}
    */
   function DenseMatrix(data, datatype) {
     if (!(this instanceof DenseMatrix)) {
       throw new SyntaxError('Constructor must be called with the new operator');
     }
-
     if (datatype && !isString(datatype)) {
       throw new Error('Invalid datatype: ' + datatype);
     }
-
     if (isMatrix(data)) {
       // check data is a DenseMatrix
       if (data.type === 'DenseMatrix') {
@@ -41,18 +40,18 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
     } else if (data && isArray(data.data) && isArray(data.size)) {
       // initialize fields from JSON representation
       this._data = data.data;
-      this._size = data.size; // verify the dimensions of the array
-
+      this._size = data.size;
+      // verify the dimensions of the array
       validate(this._data, this._size);
       this._datatype = datatype || data.datatype;
     } else if (isArray(data)) {
       // replace nested Matrices with Arrays
-      this._data = preprocess(data); // get the dimensions of the array
-
-      this._size = arraySize(this._data); // verify the dimensions of the array, TODO: compute size while processing array
-
-      validate(this._data, this._size); // data type unknown
-
+      this._data = preprocess(data);
+      // get the dimensions of the array
+      this._size = arraySize(this._data);
+      // verify the dimensions of the array, TODO: compute size while processing array
+      validate(this._data, this._size);
+      // data type unknown
       this._datatype = datatype;
     } else if (data) {
       // unsupported type
@@ -64,22 +63,25 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
       this._datatype = datatype;
     }
   }
-
   DenseMatrix.prototype = new Matrix();
+
   /**
    * Create a new DenseMatrix
    */
-
   DenseMatrix.prototype.createDenseMatrix = function (data, datatype) {
     return new DenseMatrix(data, datatype);
   };
+
   /**
    * Attach type information
    */
-
-
+  Object.defineProperty(DenseMatrix, 'name', {
+    value: 'DenseMatrix'
+  });
+  DenseMatrix.prototype.constructor = DenseMatrix;
   DenseMatrix.prototype.type = 'DenseMatrix';
   DenseMatrix.prototype.isDenseMatrix = true;
+
   /**
    * Get the matrix type
    *
@@ -89,10 +91,10 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
    * @memberOf DenseMatrix
    * @return {string}   type information; if multiple types are found from the Matrix, it will return "mixed"
    */
-
   DenseMatrix.prototype.getDataType = function () {
     return getArrayDataType(this._data, typeOf);
   };
+
   /**
    * Get the storage format used by the matrix.
    *
@@ -102,11 +104,10 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
    * @memberof DenseMatrix
    * @return {string}           The storage format.
    */
-
-
   DenseMatrix.prototype.storage = function () {
     return 'dense';
   };
+
   /**
    * Get the datatype of the data stored in the matrix.
    *
@@ -116,22 +117,20 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
    * @memberof DenseMatrix
    * @return {string}           The datatype.
    */
-
-
   DenseMatrix.prototype.datatype = function () {
     return this._datatype;
   };
+
   /**
    * Create a new DenseMatrix
    * @memberof DenseMatrix
    * @param {Array} data
    * @param {string} [datatype]
    */
-
-
   DenseMatrix.prototype.create = function (data, datatype) {
     return new DenseMatrix(data, datatype);
   };
+
   /**
    * Get a subset of the matrix, or replace a subset of the matrix.
    *
@@ -146,54 +145,47 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
    *                                  the matrix is resized. If not provided,
    *                                  new matrix elements will be filled with zeros.
    */
-
-
   DenseMatrix.prototype.subset = function (index, replacement, defaultValue) {
     switch (arguments.length) {
       case 1:
         return _get(this, index);
-      // intentional fall through
 
+      // intentional fall through
       case 2:
       case 3:
         return _set(this, index, replacement, defaultValue);
-
       default:
         throw new SyntaxError('Wrong number of arguments');
     }
   };
+
   /**
    * Get a single element from the matrix.
    * @memberof DenseMatrix
    * @param {number[]} index   Zero-based index
    * @return {*} value
    */
-
-
   DenseMatrix.prototype.get = function (index) {
     if (!isArray(index)) {
       throw new TypeError('Array expected');
     }
-
     if (index.length !== this._size.length) {
       throw new DimensionError(index.length, this._size.length);
-    } // check index
-
+    }
 
+    // check index
     for (var x = 0; x < index.length; x++) {
       validateIndex(index[x], this._size[x]);
     }
-
     var data = this._data;
-
     for (var i = 0, ii = index.length; i < ii; i++) {
       var indexI = index[i];
       validateIndex(indexI, data.length);
       data = data[indexI];
     }
-
     return data;
   };
+
   /**
    * Replace a single element in the matrix.
    * @memberof DenseMatrix
@@ -204,40 +196,36 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
    *                                  new matrix elements will be left undefined.
    * @return {DenseMatrix} self
    */
-
-
   DenseMatrix.prototype.set = function (index, value, defaultValue) {
     if (!isArray(index)) {
       throw new TypeError('Array expected');
     }
-
     if (index.length < this._size.length) {
       throw new DimensionError(index.length, this._size.length, '<');
     }
+    var i, ii, indexI;
 
-    var i, ii, indexI; // enlarge matrix when needed
-
+    // enlarge matrix when needed
     var size = index.map(function (i) {
       return i + 1;
     });
+    _fit(this, size, defaultValue);
 
-    _fit(this, size, defaultValue); // traverse over the dimensions
-
-
+    // traverse over the dimensions
     var data = this._data;
-
     for (i = 0, ii = index.length - 1; i < ii; i++) {
       indexI = index[i];
       validateIndex(indexI, data.length);
       data = data[indexI];
-    } // set new value
-
+    }
 
+    // set new value
     indexI = index[index.length - 1];
     validateIndex(indexI, data.length);
     data[indexI] = value;
     return this;
   };
+
   /**
    * Get a submatrix of this matrix
    * @memberof DenseMatrix
@@ -245,40 +233,35 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
    * @param {Index} index   Zero-based index
    * @private
    */
-
-
   function _get(matrix, index) {
     if (!isIndex(index)) {
       throw new TypeError('Invalid index');
     }
-
     var isScalar = index.isScalar();
-
     if (isScalar) {
       // return a scalar
       return matrix.get(index.min());
     } else {
       // validate dimensions
       var size = index.size();
-
       if (size.length !== matrix._size.length) {
         throw new DimensionError(size.length, matrix._size.length);
-      } // validate if any of the ranges in the index is out of range
-
+      }
 
+      // validate if any of the ranges in the index is out of range
       var min = index.min();
       var max = index.max();
-
       for (var i = 0, ii = matrix._size.length; i < ii; i++) {
         validateIndex(min[i], matrix._size[i]);
         validateIndex(max[i], matrix._size[i]);
-      } // retrieve submatrix
-      // TODO: more efficient when creating an empty matrix and setting _data and _size manually
-
+      }
 
+      // retrieve submatrix
+      // TODO: more efficient when creating an empty matrix and setting _data and _size manually
       return new DenseMatrix(_getSubmatrix(matrix._data, index, size.length, 0), matrix._datatype);
     }
   }
+
   /**
    * Recursively get a submatrix of a multi dimensional matrix.
    * Index is not checked for correct number or length of dimensions.
@@ -290,12 +273,9 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
    * @return {Array} submatrix
    * @private
    */
-
-
   function _getSubmatrix(data, index, dims, dim) {
     var last = dim === dims - 1;
     var range = index.dimension(dim);
-
     if (last) {
       return range.map(function (i) {
         validateIndex(i, data.length);
@@ -309,6 +289,7 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
       }).valueOf();
     }
   }
+
   /**
    * Replace a submatrix in this matrix
    * Indexes are zero-based.
@@ -321,80 +302,85 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
    * @return {DenseMatrix} matrix
    * @private
    */
-
-
   function _set(matrix, index, submatrix, defaultValue) {
     if (!index || index.isIndex !== true) {
       throw new TypeError('Invalid index');
-    } // get index size and check whether the index contains a single value
-
+    }
 
+    // get index size and check whether the index contains a single value
     var iSize = index.size();
-    var isScalar = index.isScalar(); // calculate the size of the submatrix, and convert it into an Array if needed
+    var isScalar = index.isScalar();
 
+    // calculate the size of the submatrix, and convert it into an Array if needed
     var sSize;
-
     if (isMatrix(submatrix)) {
       sSize = submatrix.size();
       submatrix = submatrix.valueOf();
     } else {
       sSize = arraySize(submatrix);
     }
-
     if (isScalar) {
       // set a scalar
+
       // check whether submatrix is a scalar
       if (sSize.length !== 0) {
         throw new TypeError('Scalar expected');
       }
-
       matrix.set(index.min(), submatrix, defaultValue);
     } else {
       // set a submatrix
+
+      // broadcast submatrix
+      if (!deepStrictEqual(sSize, iSize)) {
+        try {
+          if (sSize.length === 0) {
+            submatrix = broadcastTo([submatrix], iSize);
+          } else {
+            submatrix = broadcastTo(submatrix, iSize);
+          }
+          sSize = arraySize(submatrix);
+        } catch (_unused) {}
+      }
+
       // validate dimensions
       if (iSize.length < matrix._size.length) {
         throw new DimensionError(iSize.length, matrix._size.length, '<');
       }
-
       if (sSize.length < iSize.length) {
         // calculate number of missing outer dimensions
         var i = 0;
         var outer = 0;
-
         while (iSize[i] === 1 && sSize[i] === 1) {
           i++;
         }
-
         while (iSize[i] === 1) {
           outer++;
           i++;
-        } // unsqueeze both outer and inner dimensions
-
+        }
 
+        // unsqueeze both outer and inner dimensions
         submatrix = unsqueeze(submatrix, iSize.length, outer, sSize);
-      } // check whether the size of the submatrix matches the index size
-
+      }
 
+      // check whether the size of the submatrix matches the index size
       if (!deepStrictEqual(iSize, sSize)) {
         throw new DimensionError(iSize, sSize, '>');
-      } // enlarge matrix when needed
-
+      }
 
+      // enlarge matrix when needed
       var size = index.max().map(function (i) {
         return i + 1;
       });
+      _fit(matrix, size, defaultValue);
 
-      _fit(matrix, size, defaultValue); // insert the sub matrix
-
-
+      // insert the sub matrix
       var dims = iSize.length;
       var dim = 0;
-
       _setSubmatrix(matrix._data, index, submatrix, dims, dim);
     }
-
     return matrix;
   }
+
   /**
    * Replace a submatrix of a multi dimensional matrix.
    * @memberof DenseMatrix
@@ -405,12 +391,9 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
    * @param {number} dim
    * @private
    */
-
-
   function _setSubmatrix(data, index, submatrix, dims, dim) {
     var last = dim === dims - 1;
     var range = index.dimension(dim);
-
     if (last) {
       range.forEach(function (dataIndex, subIndex) {
         validateIndex(dataIndex);
@@ -419,11 +402,11 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
     } else {
       range.forEach(function (dataIndex, subIndex) {
         validateIndex(dataIndex);
-
         _setSubmatrix(data[dataIndex], index, submatrix[subIndex[0]], dims, dim + 1);
       });
     }
   }
+
   /**
    * Resize the matrix to the given size. Returns a copy of the matrix when
    * `copy=true`, otherwise return the matrix itself (resize in place).
@@ -437,44 +420,40 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
    *
    * @return {Matrix}                 The resized matrix
    */
-
-
   DenseMatrix.prototype.resize = function (size, defaultValue, copy) {
     // validate arguments
     if (!isCollection(size)) {
       throw new TypeError('Array or Matrix expected');
-    } // SparseMatrix input is always 2d, flatten this into 1d if it's indeed a vector
-
+    }
 
+    // SparseMatrix input is always 2d, flatten this into 1d if it's indeed a vector
     var sizeArray = size.valueOf().map(value => {
       return Array.isArray(value) && value.length === 1 ? value[0] : value;
-    }); // matrix to resize
-
-    var m = copy ? this.clone() : this; // resize matrix
+    });
 
+    // matrix to resize
+    var m = copy ? this.clone() : this;
+    // resize matrix
     return _resize(m, sizeArray, defaultValue);
   };
-
   function _resize(matrix, size, defaultValue) {
     // check size
     if (size.length === 0) {
       // first value in matrix
-      var v = matrix._data; // go deep
-
+      var v = matrix._data;
+      // go deep
       while (isArray(v)) {
         v = v[0];
       }
-
       return v;
-    } // resize matrix
-
-
+    }
+    // resize matrix
     matrix._size = size.slice(0); // copy the array
-
-    matrix._data = resize(matrix._data, matrix._size, defaultValue); // return matrix
-
+    matrix._data = resize(matrix._data, matrix._size, defaultValue);
+    // return matrix
     return matrix;
   }
+
   /**
    * Reshape the matrix to the given size. Returns a copy of the matrix when
    * `copy=true`, otherwise return the matrix itself (reshape in place).
@@ -489,14 +468,14 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
    *
    * @return {Matrix}                 The reshaped matrix
    */
-
-
   DenseMatrix.prototype.reshape = function (size, copy) {
     var m = copy ? this.clone() : this;
     m._data = reshape(m._data, size);
-    m._size = size.slice(0);
+    var currentLength = m._size.reduce((length, size) => length * size);
+    m._size = processSizesWildcard(size, currentLength);
     return m;
   };
+
   /**
    * Enlarge the matrix when it is smaller than given size.
    * If the matrix is larger or equal sized, nothing is done.
@@ -506,39 +485,36 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
    * @param {*} defaultValue          Default value, filled in on new entries.
    * @private
    */
-
-
   function _fit(matrix, size, defaultValue) {
-    var // copy the array
+    var
+    // copy the array
     newSize = matrix._size.slice(0);
+    var changed = false;
 
-    var changed = false; // add dimensions when needed
-
+    // add dimensions when needed
     while (newSize.length < size.length) {
       newSize.push(0);
       changed = true;
-    } // enlarge size when needed
-
+    }
 
+    // enlarge size when needed
     for (var i = 0, ii = size.length; i < ii; i++) {
       if (size[i] > newSize[i]) {
         newSize[i] = size[i];
         changed = true;
       }
     }
-
     if (changed) {
       // resize only when size is changed
       _resize(matrix, newSize, defaultValue);
     }
   }
+
   /**
    * Create a clone of the matrix
    * @memberof DenseMatrix
    * @return {DenseMatrix} clone
    */
-
-
   DenseMatrix.prototype.clone = function () {
     var m = new DenseMatrix({
       data: clone(this._data),
@@ -547,16 +523,16 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
     });
     return m;
   };
+
   /**
    * Retrieve the size of the matrix.
    * @memberof DenseMatrix
    * @returns {number[]} size
    */
-
-
   DenseMatrix.prototype.size = function () {
     return this._size.slice(0); // return a clone of _size
   };
+
   /**
    * Create a new matrix with the results of the callback function executed on
    * each entry of the matrix.
@@ -567,28 +543,35 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
    *
    * @return {DenseMatrix} matrix
    */
-
-
   DenseMatrix.prototype.map = function (callback) {
     // matrix instance
     var me = this;
-
+    var args = maxArgumentCount(callback);
     var recurse = function recurse(value, index) {
       if (isArray(value)) {
         return value.map(function (child, i) {
           return recurse(child, index.concat(i));
         });
       } else {
-        return callback(value, index, me);
+        // 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, me);
+        }
       }
-    }; // determine the new datatype when the original matrix has datatype defined
-    // TODO: should be done in matrix constructor instead
-
+    };
 
+    // determine the new datatype when the original matrix has datatype defined
+    // TODO: should be done in matrix constructor instead
     var data = recurse(this._data, []);
     var datatype = this._datatype !== undefined ? getArrayDataType(data, typeOf) : undefined;
     return new DenseMatrix(data, datatype);
   };
+
   /**
    * Execute a callback function on each entry of the matrix.
    * @memberof DenseMatrix
@@ -596,12 +579,9 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
    *                              parameters: the value of the element, the index
    *                              of the element, and the Matrix being traversed.
    */
-
-
   DenseMatrix.prototype.forEach = function (callback) {
     // matrix instance
     var me = this;
-
     var recurse = function recurse(value, index) {
       if (isArray(value)) {
         value.forEach(function (child, i) {
@@ -611,29 +591,86 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
         callback(value, index, me);
       }
     };
-
     recurse(this._data, []);
   };
+
+  /**
+   * Iterate over the matrix elements
+   * @return {Iterable<{ value, index: number[] }>}
+   */
+  DenseMatrix.prototype[Symbol.iterator] = function* () {
+    var recurse = function* recurse(value, index) {
+      if (isArray(value)) {
+        for (var i = 0; i < value.length; i++) {
+          yield* recurse(value[i], index.concat(i));
+        }
+      } else {
+        yield {
+          value,
+          index
+        };
+      }
+    };
+    yield* recurse(this._data, []);
+  };
+
+  /**
+   * Returns an array containing the rows of a 2D matrix
+   * @returns {Array<Matrix>}
+   */
+  DenseMatrix.prototype.rows = function () {
+    var result = [];
+    var s = this.size();
+    if (s.length !== 2) {
+      throw new TypeError('Rows can only be returned for a 2D matrix.');
+    }
+    var data = this._data;
+    for (var row of data) {
+      result.push(new DenseMatrix([row], this._datatype));
+    }
+    return result;
+  };
+
+  /**
+   * Returns an array containing the columns of a 2D matrix
+   * @returns {Array<Matrix>}
+   */
+  DenseMatrix.prototype.columns = function () {
+    var _this = this;
+    var result = [];
+    var s = this.size();
+    if (s.length !== 2) {
+      throw new TypeError('Rows can only be returned for a 2D matrix.');
+    }
+    var data = this._data;
+    var _loop = function _loop(i) {
+      var col = data.map(row => [row[i]]);
+      result.push(new DenseMatrix(col, _this._datatype));
+    };
+    for (var i = 0; i < s[1]; i++) {
+      _loop(i);
+    }
+    return result;
+  };
+
   /**
    * Create an Array with a copy of the data of the DenseMatrix
    * @memberof DenseMatrix
    * @returns {Array} array
    */
-
-
   DenseMatrix.prototype.toArray = function () {
     return clone(this._data);
   };
+
   /**
    * Get the primitive value of the DenseMatrix: a multidimensional array
    * @memberof DenseMatrix
    * @returns {Array} array
    */
-
-
   DenseMatrix.prototype.valueOf = function () {
     return this._data;
   };
+
   /**
    * Get a string representation of the matrix, with optional formatting options.
    * @memberof DenseMatrix
@@ -643,28 +680,24 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
    *                                                options.
    * @returns {string} str
    */
-
-
   DenseMatrix.prototype.format = function (options) {
     return format(this._data, options);
   };
+
   /**
    * Get a string representation of the matrix
    * @memberof DenseMatrix
    * @returns {string} str
    */
-
-
   DenseMatrix.prototype.toString = function () {
     return format(this._data);
   };
+
   /**
    * Get a JSON representation of the matrix
    * @memberof DenseMatrix
    * @returns {Object}
    */
-
-
   DenseMatrix.prototype.toJSON = function () {
     return {
       mathjs: 'DenseMatrix',
@@ -673,6 +706,7 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
       datatype: this._datatype
     };
   };
+
   /**
    * Get the kth Matrix diagonal.
    *
@@ -681,17 +715,14 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
    *
    * @returns {Matrix}                     The matrix with the diagonal values.
    */
-
-
   DenseMatrix.prototype.diagonal = function (k) {
     // validate k if any
     if (k) {
       // convert BigNumber to a number
       if (isBigNumber(k)) {
         k = k.toNumber();
-      } // is must be an integer
-
-
+      }
+      // is must be an integer
       if (!isNumber(k) || !isInteger(k)) {
         throw new TypeError('The parameter k must be an integer number');
       }
@@ -699,28 +730,32 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
       // default value
       k = 0;
     }
-
     var kSuper = k > 0 ? k : 0;
-    var kSub = k < 0 ? -k : 0; // rows & columns
+    var kSub = k < 0 ? -k : 0;
 
+    // rows & columns
     var rows = this._size[0];
-    var columns = this._size[1]; // number diagonal values
+    var columns = this._size[1];
 
-    var n = Math.min(rows - kSub, columns - kSuper); // x is a matrix get diagonal from matrix
+    // number diagonal values
+    var n = Math.min(rows - kSub, columns - kSuper);
 
-    var data = []; // loop rows
+    // x is a matrix get diagonal from matrix
+    var data = [];
 
+    // loop rows
     for (var i = 0; i < n; i++) {
       data[i] = this._data[i + kSub][i + kSuper];
-    } // create DenseMatrix
-
+    }
 
+    // create DenseMatrix
     return new DenseMatrix({
-      data: data,
+      data,
       size: [n],
       datatype: this._datatype
     });
   };
+
   /**
    * Create a diagonal matrix.
    *
@@ -733,40 +768,35 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
    *
    * @returns {DenseMatrix}
    */
-
-
   DenseMatrix.diagonal = function (size, value, k, defaultValue) {
     if (!isArray(size)) {
       throw new TypeError('Array expected, size parameter');
     }
-
     if (size.length !== 2) {
       throw new Error('Only two dimensions matrix are supported');
-    } // map size & validate
-
+    }
 
+    // map size & validate
     size = size.map(function (s) {
       // check it is a big number
       if (isBigNumber(s)) {
         // convert it
         s = s.toNumber();
-      } // validate arguments
-
-
+      }
+      // validate arguments
       if (!isNumber(s) || !isInteger(s) || s < 1) {
         throw new Error('Size values must be positive integers');
       }
-
       return s;
-    }); // validate k if any
+    });
 
+    // validate k if any
     if (k) {
       // convert BigNumber to a number
       if (isBigNumber(k)) {
         k = k.toNumber();
-      } // is must be an integer
-
-
+      }
+      // is must be an integer
       if (!isNumber(k) || !isInteger(k)) {
         throw new TypeError('The parameter k must be an integer number');
       }
@@ -774,40 +804,40 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
       // default value
       k = 0;
     }
-
     var kSuper = k > 0 ? k : 0;
-    var kSub = k < 0 ? -k : 0; // rows and columns
+    var kSub = k < 0 ? -k : 0;
 
+    // rows and columns
     var rows = size[0];
-    var columns = size[1]; // number of non-zero items
-
-    var n = Math.min(rows - kSub, columns - kSuper); // value extraction function
+    var columns = size[1];
 
-    var _value; // check value
+    // number of non-zero items
+    var n = Math.min(rows - kSub, columns - kSuper);
 
+    // value extraction function
+    var _value;
 
+    // check value
     if (isArray(value)) {
       // validate array
       if (value.length !== n) {
         // number of values in array must be n
         throw new Error('Invalid value array length');
-      } // define function
-
-
+      }
+      // define function
       _value = function _value(i) {
         // return value @ i
         return value[i];
       };
     } else if (isMatrix(value)) {
       // matrix size
-      var ms = value.size(); // validate matrix
-
+      var ms = value.size();
+      // validate matrix
       if (ms.length !== 1 || ms[0] !== n) {
         // number of values in array must be n
         throw new Error('Invalid matrix length');
-      } // define function
-
-
+      }
+      // define function
       _value = function _value(i) {
         // return value @ i
         return value.get([i]);
@@ -818,33 +848,35 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
         // return value
         return value;
       };
-    } // discover default value if needed
-
+    }
 
+    // discover default value if needed
     if (!defaultValue) {
       // check first value in array
       defaultValue = isBigNumber(_value(0)) ? _value(0).mul(0) // trick to create a BigNumber with value zero
       : 0;
-    } // empty array
-
+    }
 
-    var data = []; // check we need to resize array
+    // empty array
+    var data = [];
 
+    // check we need to resize array
     if (size.length > 0) {
       // resize array
-      data = resize(data, size, defaultValue); // fill diagonal
-
+      data = resize(data, size, defaultValue);
+      // fill diagonal
       for (var d = 0; d < n; d++) {
         data[d + kSub][d + kSuper] = _value(d);
       }
-    } // create DenseMatrix
-
+    }
 
+    // create DenseMatrix
     return new DenseMatrix({
-      data: data,
+      data,
       size: [rows, columns]
     });
   };
+
   /**
    * Generate a matrix from a JSON object
    * @memberof DenseMatrix
@@ -853,11 +885,10 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
    *                       where mathjs is optional
    * @returns {DenseMatrix}
    */
-
-
   DenseMatrix.fromJSON = function (json) {
     return new DenseMatrix(json);
   };
+
   /**
    * Swap rows i and j in Matrix.
    *
@@ -867,28 +898,25 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
    *
    * @return {Matrix}        The matrix reference
    */
-
-
   DenseMatrix.prototype.swapRows = function (i, j) {
     // check index
     if (!isNumber(i) || !isInteger(i) || !isNumber(j) || !isInteger(j)) {
       throw new Error('Row index must be positive integers');
-    } // check dimensions
-
-
+    }
+    // check dimensions
     if (this._size.length !== 2) {
       throw new Error('Only two dimensional matrix is supported');
-    } // validate index
-
-
+    }
+    // validate index
     validateIndex(i, this._size[0]);
-    validateIndex(j, this._size[0]); // swap rows
-
-    DenseMatrix._swapRows(i, j, this._data); // return current instance
-
+    validateIndex(j, this._size[0]);
 
+    // swap rows
+    DenseMatrix._swapRows(i, j, this._data);
+    // return current instance
     return this;
   };
+
   /**
    * Swap rows i and j in Dense Matrix data structure.
    *
@@ -896,37 +924,29 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, (
    * @param {number} j       Matrix row index 2
    * @param {Array} data     Matrix data
    */
-
-
   DenseMatrix._swapRows = function (i, j, data) {
     // swap values i <-> j
     var vi = data[i];
     data[i] = data[j];
     data[j] = vi;
   };
+
   /**
    * Preprocess data, which can be an Array or DenseMatrix with nested Arrays and
-   * Matrices. Replaces all nested Matrices with Arrays
+   * Matrices. Clones all (nested) Arrays, and replaces all nested Matrices with Arrays
    * @memberof DenseMatrix
-   * @param {Array} data
+   * @param {Array | Matrix} data
    * @return {Array} data
    */
-
-
   function preprocess(data) {
-    for (var i = 0, ii = data.length; i < ii; i++) {
-      var elem = data[i];
-
-      if (isArray(elem)) {
-        data[i] = preprocess(elem);
-      } else if (elem && elem.isMatrix === true) {
-        data[i] = preprocess(elem.valueOf());
-      }
+    if (isMatrix(data)) {
+      return preprocess(data.valueOf());
+    }
+    if (isArray(data)) {
+      return data.map(preprocess);
     }
-
     return data;
   }
-
   return DenseMatrix;
 }, {
   isClass: true