mathjs 12.4.2 → 13.0.0

package/lib/cjs/type/matrix/SparseMatrix.js

@@ -1,11 +1,9 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createSparseMatrixClass = void 0;
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 var _is = require("../../utils/is.js");
 var _number = require("../../utils/number.js");
 var _string = require("../../utils/string.js");
@@ -14,12 +12,14 @@ var _array = require("../../utils/array.js");
 var _factory = require("../../utils/factory.js");
 var _DimensionError = require("../../error/DimensionError.js");
 var _function = require("../../utils/function.js");
-var name = 'SparseMatrix';
-var dependencies = ['typed', 'equalScalar', 'Matrix'];
-var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    equalScalar = _ref.equalScalar,
-    Matrix = _ref.Matrix;
+const name = 'SparseMatrix';
+const dependencies = ['typed', 'equalScalar', 'Matrix'];
+const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    equalScalar,
+    Matrix
+  } = _ref;
   /**
    * Sparse Matrix implementation. This type implements
    * a [Compressed Column Storage](https://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_column_(CSC_or_CCS))
@@ -79,13 +79,13 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
     matrix._ptr = [];
     matrix._datatype = datatype;
     // discover rows & columns, do not use math.size() to avoid looping array twice
-    var rows = data.length;
-    var columns = 0;
+    const rows = data.length;
+    let columns = 0;
 
     // equal signature to use
-    var eq = equalScalar;
+    let eq = equalScalar;
     // zero value
-    var zero = 0;
+    let zero = 0;
     if ((0, _is.isString)(datatype)) {
       // find signature that matches (datatype, datatype)
       eq = typed.find(equalScalar, [datatype, datatype]) || equalScalar;
@@ -96,14 +96,14 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
     // check we have rows (empty array)
     if (rows > 0) {
       // column index
-      var j = 0;
+      let j = 0;
       do {
         // store pointer to values index
         matrix._ptr.push(matrix._index.length);
         // loop rows
-        for (var i = 0; i < rows; i++) {
+        for (let i = 0; i < rows; i++) {
           // current row
-          var row = data[i];
+          const row = data[i];
           // check row is an array
           if ((0, _is.isArray)(row)) {
             // update columns if needed (only on first column)
@@ -113,7 +113,7 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
             // check row has column
             if (j < row.length) {
               // value
-              var v = row[j];
+              const v = row[j];
               // check value != 0
               if (!eq(v, zero)) {
                 // store value
@@ -224,8 +224,8 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
    */
   SparseMatrix.prototype.density = function () {
     // rows & columns
-    var rows = this._size[0];
-    var columns = this._size[1];
+    const rows = this._size[0];
+    const columns = this._size[1];
     // calculate density
     return rows !== 0 && columns !== 0 ? this._index.length / (rows * columns) : 0;
   };
@@ -268,40 +268,40 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
     if (!(0, _is.isIndex)(idx)) {
       throw new TypeError('Invalid index');
     }
-    var isScalar = idx.isScalar();
+    const isScalar = idx.isScalar();
     if (isScalar) {
       // return a scalar
       return matrix.get(idx.min());
     }
     // validate dimensions
-    var size = idx.size();
+    const size = idx.size();
     if (size.length !== matrix._size.length) {
       throw new _DimensionError.DimensionError(size.length, matrix._size.length);
     }
 
     // vars
-    var i, ii, k, kk;
+    let i, ii, k, kk;
 
     // validate if any of the ranges in the index is out of range
-    var min = idx.min();
-    var max = idx.max();
+    const min = idx.min();
+    const max = idx.max();
     for (i = 0, ii = matrix._size.length; i < ii; i++) {
       (0, _array.validateIndex)(min[i], matrix._size[i]);
       (0, _array.validateIndex)(max[i], matrix._size[i]);
     }
 
     // matrix arrays
-    var mvalues = matrix._values;
-    var mindex = matrix._index;
-    var mptr = matrix._ptr;
+    const mvalues = matrix._values;
+    const mindex = matrix._index;
+    const mptr = matrix._ptr;
 
     // rows & columns dimensions for result matrix
-    var rows = idx.dimension(0);
-    var columns = idx.dimension(1);
+    const rows = idx.dimension(0);
+    const columns = idx.dimension(1);
 
     // workspace & permutation vector
-    var w = [];
-    var pv = [];
+    const w = [];
+    const pv = [];
 
     // loop rows in resulting matrix
     rows.forEach(function (i, r) {
@@ -312,9 +312,9 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
     });
 
     // result matrix arrays
-    var values = mvalues ? [] : undefined;
-    var index = [];
-    var ptr = [];
+    const values = mvalues ? [] : undefined;
+    const index = [];
+    const ptr = [];
 
     // loop columns in result matrix
     columns.forEach(function (j) {
@@ -340,10 +340,10 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
 
     // return matrix
     return new SparseMatrix({
-      values: values,
-      index: index,
-      ptr: ptr,
-      size: size,
+      values,
+      index,
+      ptr,
+      size,
       datatype: matrix._datatype
     });
   }
@@ -354,11 +354,11 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
     }
 
     // get index size and check whether the index contains a single value
-    var iSize = index.size();
-    var isScalar = index.isScalar();
+    const iSize = index.size();
+    const isScalar = index.isScalar();
 
     // calculate the size of the submatrix, and convert it into an Array if needed
-    var sSize;
+    let sSize;
     if ((0, _is.isMatrix)(submatrix)) {
       // submatrix size
       sSize = submatrix.size();
@@ -386,8 +386,8 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
       // check submatrix and index have the same dimensions
       if (sSize.length < iSize.length) {
         // calculate number of missing outer dimensions
-        var i = 0;
-        var outer = 0;
+        let i = 0;
+        let outer = 0;
         while (iSize[i] === 1 && sSize[i] === 1) {
           i++;
         }
@@ -407,15 +407,15 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
       // insert the sub matrix
       if (iSize.length === 1) {
         // if the replacement index only has 1 dimension, go trough each one and set its value
-        var range = index.dimension(0);
+        const range = index.dimension(0);
         range.forEach(function (dataIndex, subIndex) {
           (0, _array.validateIndex)(dataIndex);
           matrix.set([dataIndex, 0], submatrix[subIndex[0]], defaultValue);
         });
       } else {
         // if the replacement index has 2 dimensions, go through each one and set the value in the correct index
-        var firstDimensionRange = index.dimension(0);
-        var secondDimensionRange = index.dimension(1);
+        const firstDimensionRange = index.dimension(0);
+        const secondDimensionRange = index.dimension(1);
         firstDimensionRange.forEach(function (firstDataIndex, firstSubIndex) {
           (0, _array.validateIndex)(firstDataIndex);
           secondDimensionRange.forEach(function (secondDataIndex, secondSubIndex) {
@@ -448,15 +448,15 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
     }
 
     // row and column
-    var i = index[0];
-    var j = index[1];
+    const i = index[0];
+    const j = index[1];
 
     // check i, j are valid
     (0, _array.validateIndex)(i, this._size[0]);
     (0, _array.validateIndex)(j, this._size[1]);
 
     // find value index
-    var k = _getValueIndex(i, this._ptr[j], this._ptr[j + 1], this._index);
+    const k = _getValueIndex(i, this._ptr[j], this._ptr[j + 1], this._index);
     // check k is prior to next column k and it is in the correct row
     if (k < this._ptr[j + 1] && this._index[k] === i) {
       return this._values[k];
@@ -488,17 +488,17 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
     }
 
     // row and column
-    var i = index[0];
-    var j = index[1];
+    const i = index[0];
+    const j = index[1];
 
     // rows & columns
-    var rows = this._size[0];
-    var columns = this._size[1];
+    let rows = this._size[0];
+    let columns = this._size[1];
 
     // equal signature to use
-    var eq = equalScalar;
+    let eq = equalScalar;
     // zero value
-    var zero = 0;
+    let zero = 0;
     if ((0, _is.isString)(this._datatype)) {
       // find signature that matches (datatype, datatype)
       eq = typed.find(equalScalar, [this._datatype, this._datatype]) || equalScalar;
@@ -520,7 +520,7 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
     (0, _array.validateIndex)(j, columns);
 
     // find value index
-    var k = _getValueIndex(i, this._ptr[j], this._ptr[j + 1], this._index);
+    const k = _getValueIndex(i, this._ptr[j], this._ptr[j + 1], this._index);
     // check k is prior to next column k and it is in the correct row
     if (k < this._ptr[j + 1] && this._index[k] === i) {
       // check value != 0
@@ -545,7 +545,7 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
       return bottom;
     }
     // loop rows [top, bottom[
-    for (var r = top; r < bottom; r++) {
+    for (let r = top; r < bottom; r++) {
       // check we found value index
       if (index[r] === i) {
         return r;
@@ -559,7 +559,7 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
     values.splice(k, 1);
     index.splice(k, 1);
     // update pointers
-    for (var x = j + 1; x < ptr.length; x++) {
+    for (let x = j + 1; x < ptr.length; x++) {
       ptr[x]--;
     }
   }
@@ -569,7 +569,7 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
     // update row for k
     index.splice(k, 0, i);
     // update column pointers
-    for (var x = j + 1; x < ptr.length; x++) {
+    for (let x = j + 1; x < ptr.length; x++) {
       ptr[x]++;
     }
   }
@@ -596,7 +596,7 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
     }
 
     // SparseMatrix input is always 2d, flatten this into 1d if it's indeed a vector
-    var sizeArray = size.valueOf().map(function (value) {
+    const sizeArray = size.valueOf().map(value => {
       return Array.isArray(value) && value.length === 1 ? value[0] : value;
     });
     if (sizeArray.length !== 2) {
@@ -611,18 +611,18 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
     });
 
     // matrix to resize
-    var m = copy ? this.clone() : this;
+    const m = copy ? this.clone() : this;
     // resize matrix
     return _resize(m, sizeArray[0], sizeArray[1], defaultValue);
   };
   function _resize(matrix, rows, columns, defaultValue) {
     // value to insert at the time of growing matrix
-    var value = defaultValue || 0;
+    let value = defaultValue || 0;
 
     // equal signature to use
-    var eq = equalScalar;
+    let eq = equalScalar;
     // zero value
-    var zero = 0;
+    let zero = 0;
     if ((0, _is.isString)(matrix._datatype)) {
       // find signature that matches (datatype, datatype)
       eq = typed.find(equalScalar, [matrix._datatype, matrix._datatype]) || equalScalar;
@@ -633,12 +633,12 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
     }
 
     // should we insert the value?
-    var ins = !eq(value, zero);
+    const ins = !eq(value, zero);
 
     // old columns and rows
-    var r = matrix._size[0];
-    var c = matrix._size[1];
-    var i, j, k;
+    const r = matrix._size[0];
+    let c = matrix._size[1];
+    let i, j, k;
 
     // check we need to increase columns
     if (columns > c) {
@@ -674,7 +674,7 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
       // check we have to insert values
       if (ins) {
         // inserts
-        var n = 0;
+        let n = 0;
         // loop columns
         for (j = 0; j < c; j++) {
           // update matrix._ptr for current column
@@ -682,7 +682,7 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
           // where to insert matrix._values
           k = matrix._ptr[j + 1] + n;
           // pointer
-          var p = 0;
+          let p = 0;
           // loop new rows, initialize pointer
           for (i = r; i < rows; i++, p++) {
             // add value
@@ -698,14 +698,14 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
       }
     } else if (rows < r) {
       // deletes
-      var d = 0;
+      let d = 0;
       // loop columns
       for (j = 0; j < c; j++) {
         // update matrix._ptr for current column
         matrix._ptr[j] = matrix._ptr[j] - d;
         // where matrix._values start for next column
-        var k0 = matrix._ptr[j];
-        var k1 = matrix._ptr[j + 1] - d;
+        const k0 = matrix._ptr[j];
+        const k1 = matrix._ptr[j + 1] - d;
         // loop matrix._index
         for (k = k0; k < k1; k++) {
           // row
@@ -762,9 +762,9 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
         throw new TypeError('Invalid size, must contain positive integers or -1 ' + '(size: ' + (0, _string.format)(sizes) + ')');
       }
     });
-    var currentLength = this._size[0] * this._size[1];
+    const currentLength = this._size[0] * this._size[1];
     sizes = (0, _array.processSizesWildcard)(sizes, currentLength);
-    var newLength = sizes[0] * sizes[1];
+    const newLength = sizes[0] * sizes[1];
 
     // m * n must not change
     if (currentLength !== newLength) {
@@ -772,7 +772,7 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
     }
 
     // matrix to reshape
-    var m = copy ? this.clone() : this;
+    const m = copy ? this.clone() : this;
 
     // return unchanged if the same shape
     if (this._size[0] === sizes[0] && this._size[1] === sizes[1]) {
@@ -780,26 +780,26 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
     }
 
     // Convert to COO format (generate a column index)
-    var colIndex = [];
-    for (var i = 0; i < m._ptr.length; i++) {
-      for (var j = 0; j < m._ptr[i + 1] - m._ptr[i]; j++) {
+    const colIndex = [];
+    for (let i = 0; i < m._ptr.length; i++) {
+      for (let j = 0; j < m._ptr[i + 1] - m._ptr[i]; j++) {
         colIndex.push(i);
       }
     }
 
     // Clone the values array
-    var values = m._values.slice();
+    const values = m._values.slice();
 
     // Clone the row index array
-    var rowIndex = m._index.slice();
+    const rowIndex = m._index.slice();
 
     // Transform the (row, column) indices
-    for (var _i = 0; _i < m._index.length; _i++) {
-      var r1 = rowIndex[_i];
-      var c1 = colIndex[_i];
-      var flat = r1 * m._size[1] + c1;
-      colIndex[_i] = flat % sizes[1];
-      rowIndex[_i] = Math.floor(flat / sizes[1]);
+    for (let i = 0; i < m._index.length; i++) {
+      const r1 = rowIndex[i];
+      const c1 = colIndex[i];
+      const flat = r1 * m._size[1] + c1;
+      colIndex[i] = flat % sizes[1];
+      rowIndex[i] = Math.floor(flat / sizes[1]);
     }
 
     // Now reshaping is supposed to preserve the row-major order, BUT these sparse matrices are stored
@@ -813,18 +813,18 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
     m._index.length = 0;
     m._ptr.length = sizes[1] + 1;
     m._size = sizes.slice();
-    for (var _i2 = 0; _i2 < m._ptr.length; _i2++) {
-      m._ptr[_i2] = 0;
+    for (let i = 0; i < m._ptr.length; i++) {
+      m._ptr[i] = 0;
     }
 
     // 2. Re-insert all elements in the proper order (simplified code from SparseMatrix.prototype.set)
     // This step is probably the most time-consuming
-    for (var h = 0; h < values.length; h++) {
-      var _i3 = rowIndex[h];
-      var _j = colIndex[h];
-      var v = values[h];
-      var k = _getValueIndex(_i3, m._ptr[_j], m._ptr[_j + 1], m._index);
-      _insert(k, _i3, _j, v, m._values, m._index, m._ptr);
+    for (let h = 0; h < values.length; h++) {
+      const i = rowIndex[h];
+      const j = colIndex[h];
+      const v = values[h];
+      const k = _getValueIndex(i, m._ptr[j], m._ptr[j + 1], m._index);
+      _insert(k, i, j, v, m._values, m._index, m._ptr);
     }
 
     // The value indices are inserted out of order, but apparently that's... still OK?
@@ -838,7 +838,7 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
    * @return {SparseMatrix} clone
    */
   SparseMatrix.prototype.clone = function () {
-    var m = new SparseMatrix({
+    const m = new SparseMatrix({
       values: this._values ? (0, _object.clone)(this._values) : undefined,
       index: (0, _object.clone)(this._index),
       ptr: (0, _object.clone)(this._ptr),
@@ -874,13 +874,13 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
       throw new Error('Cannot invoke map on a Pattern only matrix');
     }
     // matrix instance
-    var me = this;
+    const me = this;
     // rows and columns
-    var rows = this._size[0];
-    var columns = this._size[1];
+    const rows = this._size[0];
+    const columns = this._size[1];
     // invoke callback
-    var args = (0, _function.maxArgumentCount)(callback);
-    var invoke = function invoke(v, i, j) {
+    const args = (0, _function.maxArgumentCount)(callback);
+    const invoke = function (v, i, j) {
       // invoke callback
       if (args === 1) return callback(v);
       if (args === 2) return callback(v, [i, j]);
@@ -896,14 +896,14 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
    */
   function _map(matrix, minRow, maxRow, minColumn, maxColumn, callback, skipZeros) {
     // result arrays
-    var values = [];
-    var index = [];
-    var ptr = [];
+    const values = [];
+    const index = [];
+    const ptr = [];
 
     // equal signature to use
-    var eq = equalScalar;
+    let eq = equalScalar;
     // zero value
-    var zero = 0;
+    let zero = 0;
     if ((0, _is.isString)(matrix._datatype)) {
       // find signature that matches (datatype, datatype)
       eq = typed.find(equalScalar, [matrix._datatype, matrix._datatype]) || equalScalar;
@@ -912,7 +912,7 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
     }
 
     // invoke callback
-    var invoke = function invoke(v, x, y) {
+    const invoke = function (v, x, y) {
       // invoke callback
       v = callback(v, x, y);
       // check value != 0
@@ -924,17 +924,17 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
       }
     };
     // loop columns
-    for (var j = minColumn; j <= maxColumn; j++) {
+    for (let j = minColumn; j <= maxColumn; j++) {
       // store pointer to values index
       ptr.push(values.length);
       // k0 <= k < k1 where k0 = _ptr[j] && k1 = _ptr[j+1]
-      var k0 = matrix._ptr[j];
-      var k1 = matrix._ptr[j + 1];
+      const k0 = matrix._ptr[j];
+      const k1 = matrix._ptr[j + 1];
       if (skipZeros) {
         // loop k within [k0, k1[
-        for (var k = k0; k < k1; k++) {
+        for (let k = k0; k < k1; k++) {
           // row index
-          var i = matrix._index[k];
+          const i = matrix._index[k];
           // check i is in range
           if (i >= minRow && i <= maxRow) {
             // value @ k
@@ -943,17 +943,17 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
         }
       } else {
         // create a cache holding all defined values
-        var _values = {};
-        for (var _k = k0; _k < k1; _k++) {
-          var _i4 = matrix._index[_k];
-          _values[_i4] = matrix._values[_k];
+        const values = {};
+        for (let k = k0; k < k1; k++) {
+          const i = matrix._index[k];
+          values[i] = matrix._values[k];
         }
 
         // loop over all rows (indexes can be unordered so we can't use that),
         // and either read the value or zero
-        for (var _i5 = minRow; _i5 <= maxRow; _i5++) {
-          var value = _i5 in _values ? _values[_i5] : 0;
-          invoke(value, _i5 - minRow, j - minColumn);
+        for (let i = minRow; i <= maxRow; i++) {
+          const value = i in values ? values[i] : 0;
+          invoke(value, i - minRow, j - minColumn);
         }
       }
     }
@@ -962,9 +962,9 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
     ptr.push(values.length);
     // return sparse matrix
     return new SparseMatrix({
-      values: values,
-      index: index,
-      ptr: ptr,
+      values,
+      index,
+      ptr,
       size: [maxRow - minRow + 1, maxColumn - minColumn + 1]
     });
   }
@@ -985,37 +985,37 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
       throw new Error('Cannot invoke forEach on a Pattern only matrix');
     }
     // matrix instance
-    var me = this;
+    const me = this;
     // rows and columns
-    var rows = this._size[0];
-    var columns = this._size[1];
+    const rows = this._size[0];
+    const columns = this._size[1];
     // loop columns
-    for (var j = 0; j < columns; j++) {
+    for (let j = 0; j < columns; j++) {
       // k0 <= k < k1 where k0 = _ptr[j] && k1 = _ptr[j+1]
-      var k0 = this._ptr[j];
-      var k1 = this._ptr[j + 1];
+      const k0 = this._ptr[j];
+      const k1 = this._ptr[j + 1];
       if (skipZeros) {
         // loop k within [k0, k1[
-        for (var k = k0; k < k1; k++) {
+        for (let k = k0; k < k1; k++) {
           // row index
-          var i = this._index[k];
+          const i = this._index[k];
 
           // value @ k
           callback(this._values[k], [i, j], me);
         }
       } else {
         // create a cache holding all defined values
-        var values = {};
-        for (var _k2 = k0; _k2 < k1; _k2++) {
-          var _i6 = this._index[_k2];
-          values[_i6] = this._values[_k2];
+        const values = {};
+        for (let k = k0; k < k1; k++) {
+          const i = this._index[k];
+          values[i] = this._values[k];
         }
 
         // loop over all rows (indexes can be unordered so we can't use that),
         // and either read the value or zero
-        for (var _i7 = 0; _i7 < rows; _i7++) {
-          var value = _i7 in values ? values[_i7] : 0;
-          callback(value, [_i7, j], me);
+        for (let i = 0; i < rows; i++) {
+          const value = i in values ? values[i] : 0;
+          callback(value, [i, j], me);
         }
       }
     }
@@ -1025,53 +1025,24 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
    * Iterate over the matrix elements, skipping zeros
    * @return {Iterable<{ value, index: number[] }>}
    */
-  SparseMatrix.prototype[Symbol.iterator] = /*#__PURE__*/_regenerator["default"].mark(function _callee() {
-    var columns, j, k0, k1, k, i;
-    return _regenerator["default"].wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          if (this._values) {
-            _context.next = 2;
-            break;
-          }
-          throw new Error('Cannot iterate a Pattern only matrix');
-        case 2:
-          columns = this._size[1];
-          j = 0;
-        case 4:
-          if (!(j < columns)) {
-            _context.next = 18;
-            break;
-          }
-          k0 = this._ptr[j];
-          k1 = this._ptr[j + 1];
-          k = k0;
-        case 8:
-          if (!(k < k1)) {
-            _context.next = 15;
-            break;
-          }
-          // row index
-          i = this._index[k];
-          _context.next = 12;
-          return {
-            value: this._values[k],
-            index: [i, j]
-          };
-        case 12:
-          k++;
-          _context.next = 8;
-          break;
-        case 15:
-          j++;
-          _context.next = 4;
-          break;
-        case 18:
-        case "end":
-          return _context.stop();
+  SparseMatrix.prototype[Symbol.iterator] = function* () {
+    if (!this._values) {
+      throw new Error('Cannot iterate a Pattern only matrix');
+    }
+    const columns = this._size[1];
+    for (let j = 0; j < columns; j++) {
+      const k0 = this._ptr[j];
+      const k1 = this._ptr[j + 1];
+      for (let k = k0; k < k1; k++) {
+        // row index
+        const i = this._index[k];
+        yield {
+          value: this._values[k],
+          index: [i, j]
+        };
       }
-    }, _callee, this);
-  });
+    }
+  };
 
   /**
    * Create an Array with a copy of the data of the SparseMatrix
@@ -1092,12 +1063,12 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
   };
   function _toArray(values, index, ptr, size, copy) {
     // rows and columns
-    var rows = size[0];
-    var columns = size[1];
+    const rows = size[0];
+    const columns = size[1];
     // result
-    var a = [];
+    const a = [];
     // vars
-    var i, j;
+    let i, j;
     // initialize array
     for (i = 0; i < rows; i++) {
       a[i] = [];
@@ -1109,10 +1080,10 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
     // loop columns
     for (j = 0; j < columns; j++) {
       // k0 <= k < k1 where k0 = _ptr[j] && k1 = _ptr[j+1]
-      var k0 = ptr[j];
-      var k1 = ptr[j + 1];
+      const k0 = ptr[j];
+      const k1 = ptr[j + 1];
       // loop k within [k0, k1[
-      for (var k = k0; k < k1; k++) {
+      for (let k = k0; k < k1; k++) {
         // row index
         i = index[k];
         // set value (use one for pattern matrix)
@@ -1133,21 +1104,21 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
    */
   SparseMatrix.prototype.format = function (options) {
     // rows and columns
-    var rows = this._size[0];
-    var columns = this._size[1];
+    const rows = this._size[0];
+    const columns = this._size[1];
     // density
-    var density = this.density();
+    const density = this.density();
     // rows & columns
-    var str = 'Sparse Matrix [' + (0, _string.format)(rows, options) + ' x ' + (0, _string.format)(columns, options) + '] density: ' + (0, _string.format)(density, options) + '\n';
+    let str = 'Sparse Matrix [' + (0, _string.format)(rows, options) + ' x ' + (0, _string.format)(columns, options) + '] density: ' + (0, _string.format)(density, options) + '\n';
     // loop columns
-    for (var j = 0; j < columns; j++) {
+    for (let j = 0; j < columns; j++) {
       // k0 <= k < k1 where k0 = _ptr[j] && k1 = _ptr[j+1]
-      var k0 = this._ptr[j];
-      var k1 = this._ptr[j + 1];
+      const k0 = this._ptr[j];
+      const k1 = this._ptr[j + 1];
       // loop k within [k0, k1[
-      for (var k = k0; k < k1; k++) {
+      for (let k = k0; k < k1; k++) {
         // row index
-        var i = this._index[k];
+        const i = this._index[k];
         // append value
         str += '\n    (' + (0, _string.format)(i, options) + ', ' + (0, _string.format)(j, options) + ') ==> ' + (this._values ? (0, _string.format)(this._values[k], options) : 'X');
       }
@@ -1203,31 +1174,31 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
       // default value
       k = 0;
     }
-    var kSuper = k > 0 ? k : 0;
-    var kSub = k < 0 ? -k : 0;
+    const kSuper = k > 0 ? k : 0;
+    const kSub = k < 0 ? -k : 0;
 
     // rows & columns
-    var rows = this._size[0];
-    var columns = this._size[1];
+    const rows = this._size[0];
+    const columns = this._size[1];
 
     // number diagonal values
-    var n = Math.min(rows - kSub, columns - kSuper);
+    const n = Math.min(rows - kSub, columns - kSuper);
 
     // diagonal arrays
-    var values = [];
-    var index = [];
-    var ptr = [];
+    const values = [];
+    const index = [];
+    const ptr = [];
     // initial ptr value
     ptr[0] = 0;
     // loop columns
-    for (var j = kSuper; j < columns && values.length < n; j++) {
+    for (let j = kSuper; j < columns && values.length < n; j++) {
       // k0 <= k < k1 where k0 = _ptr[j] && k1 = _ptr[j+1]
-      var k0 = this._ptr[j];
-      var k1 = this._ptr[j + 1];
+      const k0 = this._ptr[j];
+      const k1 = this._ptr[j + 1];
       // loop x within [k0, k1[
-      for (var x = k0; x < k1; x++) {
+      for (let x = k0; x < k1; x++) {
         // row index
-        var i = this._index[x];
+        const i = this._index[x];
         // check row
         if (i === j - kSuper + kSub) {
           // value on this column
@@ -1243,9 +1214,9 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
     ptr.push(values.length);
     // return matrix
     return new SparseMatrix({
-      values: values,
-      index: index,
-      ptr: ptr,
+      values,
+      index,
+      ptr,
       size: [n, 1]
     });
   };
@@ -1312,27 +1283,27 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
     }
 
     // equal signature to use
-    var eq = equalScalar;
+    let eq = equalScalar;
     // zero value
-    var zero = 0;
+    let zero = 0;
     if ((0, _is.isString)(datatype)) {
       // find signature that matches (datatype, datatype)
       eq = typed.find(equalScalar, [datatype, datatype]) || equalScalar;
       // convert 0 to the same datatype
       zero = typed.convert(0, datatype);
     }
-    var kSuper = k > 0 ? k : 0;
-    var kSub = k < 0 ? -k : 0;
+    const kSuper = k > 0 ? k : 0;
+    const kSub = k < 0 ? -k : 0;
 
     // rows and columns
-    var rows = size[0];
-    var columns = size[1];
+    const rows = size[0];
+    const columns = size[1];
 
     // number of non-zero items
-    var n = Math.min(rows - kSub, columns - kSuper);
+    const n = Math.min(rows - kSub, columns - kSuper);
 
     // value extraction function
-    var _value;
+    let _value;
 
     // check value
     if ((0, _is.isArray)(value)) {
@@ -1342,46 +1313,46 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
         throw new Error('Invalid value array length');
       }
       // define function
-      _value = function _value(i) {
+      _value = function (i) {
         // return value @ i
         return value[i];
       };
     } else if ((0, _is.isMatrix)(value)) {
       // matrix size
-      var ms = value.size();
+      const 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
-      _value = function _value(i) {
+      _value = function (i) {
         // return value @ i
         return value.get([i]);
       };
     } else {
       // define function
-      _value = function _value() {
+      _value = function () {
         // return value
         return value;
       };
     }
 
     // create arrays
-    var values = [];
-    var index = [];
-    var ptr = [];
+    const values = [];
+    const index = [];
+    const ptr = [];
 
     // loop items
-    for (var j = 0; j < columns; j++) {
+    for (let j = 0; j < columns; j++) {
       // number of rows with value
       ptr.push(values.length);
       // diagonal index
-      var i = j - kSuper;
+      const i = j - kSuper;
       // check we need to set diagonal value
       if (i >= 0 && i < n) {
         // get value @ i
-        var v = _value(i);
+        const v = _value(i);
         // check for zero
         if (!eq(v, zero)) {
           // column
@@ -1395,9 +1366,9 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
     ptr.push(values.length);
     // create SparseMatrix
     return new SparseMatrix({
-      values: values,
-      index: index,
-      ptr: ptr,
+      values,
+      index,
+      ptr,
       size: [rows, columns]
     });
   };
@@ -1441,10 +1412,10 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
    */
   SparseMatrix._forEachRow = function (j, values, index, ptr, callback) {
     // indeces for column j
-    var k0 = ptr[j];
-    var k1 = ptr[j + 1];
+    const k0 = ptr[j];
+    const k1 = ptr[j + 1];
     // loop
-    for (var k = k0; k < k1; k++) {
+    for (let k = k0; k < k1; k++) {
       // invoke callback
       callback(index[k], values[k]);
     }
@@ -1462,19 +1433,19 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
    */
   SparseMatrix._swapRows = function (x, y, columns, values, index, ptr) {
     // loop columns
-    for (var j = 0; j < columns; j++) {
+    for (let j = 0; j < columns; j++) {
       // k0 <= k < k1 where k0 = _ptr[j] && k1 = _ptr[j+1]
-      var k0 = ptr[j];
-      var k1 = ptr[j + 1];
+      const k0 = ptr[j];
+      const k1 = ptr[j + 1];
       // find value index @ x
-      var kx = _getValueIndex(x, k0, k1, index);
+      const kx = _getValueIndex(x, k0, k1, index);
       // find value index @ x
-      var ky = _getValueIndex(y, k0, k1, index);
+      const ky = _getValueIndex(y, k0, k1, index);
       // check both rows exist in matrix
       if (kx < k1 && ky < k1 && index[kx] === x && index[ky] === y) {
         // swap values (check for pattern matrix)
         if (values) {
-          var v = values[kx];
+          const v = values[kx];
           values[kx] = values[ky];
           values[ky] = v;
         }
@@ -1484,7 +1455,7 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
       // check x row exist & no y row
       if (kx < k1 && index[kx] === x && (ky >= k1 || index[ky] !== y)) {
         // value @ x (check for pattern matrix)
-        var vx = values ? values[kx] : undefined;
+        const vx = values ? values[kx] : undefined;
         // insert value @ y
         index.splice(ky, 0, y);
         if (values) {
@@ -1501,7 +1472,7 @@ var createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ */(
       // check y row exist & no x row
       if (ky < k1 && index[ky] === y && (kx >= k1 || index[kx] !== x)) {
         // value @ y (check for pattern matrix)
-        var vy = values ? values[ky] : undefined;
+        const vy = values ? values[ky] : undefined;
         // insert value @ x
         index.splice(kx, 0, x);
         if (values) {