mathjs 11.2.1 → 11.3.0

package/lib/cjs/function/arithmetic/multiply.js

@@ -4,26 +4,20 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createMultiply = void 0;
-
 var _factory = require("../../utils/factory.js");
-
 var _is = require("../../utils/is.js");
-
 var _array = require("../../utils/array.js");
-
 var _matAlgo11xS0s = require("../../type/matrix/utils/matAlgo11xS0s.js");
-
 var _matAlgo14xDs = require("../../type/matrix/utils/matAlgo14xDs.js");
-
 var name = 'multiply';
 var dependencies = ['typed', 'matrix', 'addScalar', 'multiplyScalar', 'equalScalar', 'dot'];
 var createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
-      matrix = _ref.matrix,
-      addScalar = _ref.addScalar,
-      multiplyScalar = _ref.multiplyScalar,
-      equalScalar = _ref.equalScalar,
-      dot = _ref.dot;
+    matrix = _ref.matrix,
+    addScalar = _ref.addScalar,
+    multiplyScalar = _ref.multiplyScalar,
+    equalScalar = _ref.equalScalar,
+    dot = _ref.dot;
   var matAlgo11xS0s = (0, _matAlgo11xS0s.createMatAlgo11xS0s)({
     typed: typed,
     equalScalar: equalScalar
@@ -31,7 +25,6 @@ var createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
   var matAlgo14xDs = (0, _matAlgo14xDs.createMatAlgo14xDs)({
     typed: typed
   });
-
   function _validateMatrixDimensions(size1, size2) {
     // check left operand dimensions
     switch (size1.length) {
@@ -44,24 +37,18 @@ var createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
               // throw error
               throw new RangeError('Dimension mismatch in multiplication. Vectors must have the same length');
             }
-
             break;
-
           case 2:
             // Vector x Matrix
             if (size1[0] !== size2[0]) {
               // throw error
               throw new RangeError('Dimension mismatch in multiplication. Vector length (' + size1[0] + ') must match Matrix rows (' + size2[0] + ')');
             }
-
             break;
-
           default:
             throw new Error('Can only multiply a 1 or 2 dimensional matrix (Matrix B has ' + size2.length + ' dimensions)');
         }
-
         break;
-
       case 2:
         // check size2
         switch (size2.length) {
@@ -71,28 +58,23 @@ var createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
               // throw error
               throw new RangeError('Dimension mismatch in multiplication. Matrix columns (' + size1[1] + ') must match Vector length (' + size2[0] + ')');
             }
-
             break;
-
           case 2:
             // Matrix x Matrix
             if (size1[1] !== size2[0]) {
               // throw error
               throw new RangeError('Dimension mismatch in multiplication. Matrix A columns (' + size1[1] + ') must match Matrix B rows (' + size2[0] + ')');
             }
-
             break;
-
           default:
             throw new Error('Can only multiply a 1 or 2 dimensional matrix (Matrix B has ' + size2.length + ' dimensions)');
         }
-
         break;
-
       default:
         throw new Error('Can only multiply a 1 or 2 dimensional matrix (Matrix A has ' + size1.length + ' dimensions)');
     }
   }
+
   /**
    * C = A * B
    *
@@ -101,16 +83,14 @@ var createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
    *
    * @return {number}             Scalar value
    */
-
-
   function _multiplyVectorVector(a, b, n) {
     // check empty vector
     if (n === 0) {
       throw new Error('Cannot multiply two empty vectors');
     }
-
     return dot(a, b);
   }
+
   /**
    * C = A * B
    *
@@ -119,16 +99,14 @@ var createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
    *
    * @return {Matrix}             Dense Vector   (N)
    */
-
-
   function _multiplyVectorMatrix(a, b) {
     // process storage
     if (b.storage() !== 'dense') {
       throw new Error('Support for SparseMatrix not implemented');
     }
-
     return _multiplyVectorDenseMatrix(a, b);
   }
+
   /**
    * C = A * B
    *
@@ -137,57 +115,58 @@ var createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
    *
    * @return {Matrix}             Dense Vector   (N)
    */
-
-
   function _multiplyVectorDenseMatrix(a, b) {
     // a dense
     var adata = a._data;
     var asize = a._size;
-    var adt = a._datatype; // b dense
-
+    var adt = a._datatype;
+    // b dense
     var bdata = b._data;
     var bsize = b._size;
-    var bdt = b._datatype; // rows & columns
-
+    var bdt = b._datatype;
+    // rows & columns
     var alength = asize[0];
-    var bcolumns = bsize[1]; // datatype
-
-    var dt; // addScalar signature to use
+    var bcolumns = bsize[1];
 
-    var af = addScalar; // multiplyScalar signature to use
-
-    var mf = multiplyScalar; // process data types
+    // datatype
+    var dt;
+    // addScalar signature to use
+    var af = addScalar;
+    // multiplyScalar signature to use
+    var mf = multiplyScalar;
 
+    // process data types
     if (adt && bdt && adt === bdt && typeof adt === 'string') {
       // datatype
-      dt = adt; // find signatures that matches (dt, dt)
-
+      dt = adt;
+      // find signatures that matches (dt, dt)
       af = typed.find(addScalar, [dt, dt]);
       mf = typed.find(multiplyScalar, [dt, dt]);
-    } // result
-
+    }
 
-    var c = []; // loop matrix columns
+    // result
+    var c = [];
 
+    // loop matrix columns
     for (var j = 0; j < bcolumns; j++) {
       // sum (do not initialize it with zero)
-      var sum = mf(adata[0], bdata[0][j]); // loop vector
-
+      var sum = mf(adata[0], bdata[0][j]);
+      // loop vector
       for (var i = 1; i < alength; i++) {
         // multiply & accumulate
         sum = af(sum, mf(adata[i], bdata[i][j]));
       }
-
       c[j] = sum;
-    } // return matrix
-
+    }
 
+    // return matrix
     return a.createDenseMatrix({
       data: c,
       size: [bcolumns],
       datatype: dt
     });
   }
+
   /**
    * C = A * B
    *
@@ -196,12 +175,11 @@ var createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
    *
    * @return {Matrix}             Dense Vector   (M)
    */
-
-
   var _multiplyMatrixVector = typed('_multiplyMatrixVector', {
     'DenseMatrix, any': _multiplyDenseMatrixVector,
     'SparseMatrix, any': _multiplySparseMatrixVector
   });
+
   /**
    * C = A * B
    *
@@ -210,14 +188,13 @@ var createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
    *
    * @return {Matrix}             Matrix         (MxC)
    */
-
-
   var _multiplyMatrixMatrix = typed('_multiplyMatrixMatrix', {
     'DenseMatrix, DenseMatrix': _multiplyDenseMatrixDenseMatrix,
     'DenseMatrix, SparseMatrix': _multiplyDenseMatrixSparseMatrix,
     'SparseMatrix, DenseMatrix': _multiplySparseMatrixDenseMatrix,
     'SparseMatrix, SparseMatrix': _multiplySparseMatrixSparseMatrix
   });
+
   /**
    * C = A * B
    *
@@ -226,58 +203,59 @@ var createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
    *
    * @return {Matrix}             Dense Vector (M)
    */
-
-
   function _multiplyDenseMatrixVector(a, b) {
     // a dense
     var adata = a._data;
     var asize = a._size;
-    var adt = a._datatype; // b dense
-
+    var adt = a._datatype;
+    // b dense
     var bdata = b._data;
-    var bdt = b._datatype; // rows & columns
-
+    var bdt = b._datatype;
+    // rows & columns
     var arows = asize[0];
-    var acolumns = asize[1]; // datatype
-
-    var dt; // addScalar signature to use
-
-    var af = addScalar; // multiplyScalar signature to use
+    var acolumns = asize[1];
 
-    var mf = multiplyScalar; // process data types
+    // datatype
+    var dt;
+    // addScalar signature to use
+    var af = addScalar;
+    // multiplyScalar signature to use
+    var mf = multiplyScalar;
 
+    // process data types
     if (adt && bdt && adt === bdt && typeof adt === 'string') {
       // datatype
-      dt = adt; // find signatures that matches (dt, dt)
-
+      dt = adt;
+      // find signatures that matches (dt, dt)
       af = typed.find(addScalar, [dt, dt]);
       mf = typed.find(multiplyScalar, [dt, dt]);
-    } // result
-
+    }
 
-    var c = []; // loop matrix a rows
+    // result
+    var c = [];
 
+    // loop matrix a rows
     for (var i = 0; i < arows; i++) {
       // current row
-      var row = adata[i]; // sum (do not initialize it with zero)
-
-      var sum = mf(row[0], bdata[0]); // loop matrix a columns
-
+      var row = adata[i];
+      // sum (do not initialize it with zero)
+      var sum = mf(row[0], bdata[0]);
+      // loop matrix a columns
       for (var j = 1; j < acolumns; j++) {
         // multiply & accumulate
         sum = af(sum, mf(row[j], bdata[j]));
       }
-
       c[i] = sum;
-    } // return matrix
-
+    }
 
+    // return matrix
     return a.createDenseMatrix({
       data: c,
       size: [arows],
       datatype: dt
     });
   }
+
   /**
    * C = A * B
    *
@@ -286,65 +264,66 @@ var createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
    *
    * @return {Matrix}             DenseMatrix    (MxC)
    */
-
-
   function _multiplyDenseMatrixDenseMatrix(a, b) {
     // a dense
     var adata = a._data;
     var asize = a._size;
-    var adt = a._datatype; // b dense
-
+    var adt = a._datatype;
+    // b dense
     var bdata = b._data;
     var bsize = b._size;
-    var bdt = b._datatype; // rows & columns
-
+    var bdt = b._datatype;
+    // rows & columns
     var arows = asize[0];
     var acolumns = asize[1];
-    var bcolumns = bsize[1]; // datatype
-
-    var dt; // addScalar signature to use
+    var bcolumns = bsize[1];
 
-    var af = addScalar; // multiplyScalar signature to use
-
-    var mf = multiplyScalar; // process data types
+    // datatype
+    var dt;
+    // addScalar signature to use
+    var af = addScalar;
+    // multiplyScalar signature to use
+    var mf = multiplyScalar;
 
+    // process data types
     if (adt && bdt && adt === bdt && typeof adt === 'string') {
       // datatype
-      dt = adt; // find signatures that matches (dt, dt)
-
+      dt = adt;
+      // find signatures that matches (dt, dt)
       af = typed.find(addScalar, [dt, dt]);
       mf = typed.find(multiplyScalar, [dt, dt]);
-    } // result
-
+    }
 
-    var c = []; // loop matrix a rows
+    // result
+    var c = [];
 
+    // loop matrix a rows
     for (var i = 0; i < arows; i++) {
       // current row
-      var row = adata[i]; // initialize row array
-
-      c[i] = []; // loop matrix b columns
-
+      var row = adata[i];
+      // initialize row array
+      c[i] = [];
+      // loop matrix b columns
       for (var j = 0; j < bcolumns; j++) {
         // sum (avoid initializing sum to zero)
-        var sum = mf(row[0], bdata[0][j]); // loop matrix a columns
-
+        var sum = mf(row[0], bdata[0][j]);
+        // loop matrix a columns
         for (var x = 1; x < acolumns; x++) {
           // multiply & accumulate
           sum = af(sum, mf(row[x], bdata[x][j]));
         }
-
         c[i][j] = sum;
       }
-    } // return matrix
-
+    }
 
+    // return matrix
     return a.createDenseMatrix({
       data: c,
       size: [arows, bcolumns],
       datatype: dt
     });
   }
+
   /**
    * C = A * B
    *
@@ -353,95 +332,94 @@ var createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
    *
    * @return {Matrix}             SparseMatrix   (MxC)
    */
-
-
   function _multiplyDenseMatrixSparseMatrix(a, b) {
     // a dense
     var adata = a._data;
     var asize = a._size;
-    var adt = a._datatype; // b sparse
-
+    var adt = a._datatype;
+    // b sparse
     var bvalues = b._values;
     var bindex = b._index;
     var bptr = b._ptr;
     var bsize = b._size;
-    var bdt = b._datatype; // validate b matrix
-
+    var bdt = b._datatype;
+    // validate b matrix
     if (!bvalues) {
       throw new Error('Cannot multiply Dense Matrix times Pattern only Matrix');
-    } // rows & columns
-
-
+    }
+    // rows & columns
     var arows = asize[0];
-    var bcolumns = bsize[1]; // datatype
-
-    var dt; // addScalar signature to use
-
-    var af = addScalar; // multiplyScalar signature to use
-
-    var mf = multiplyScalar; // equalScalar signature to use
-
-    var eq = equalScalar; // zero value
-
-    var zero = 0; // process data types
-
+    var bcolumns = bsize[1];
+
+    // datatype
+    var dt;
+    // addScalar signature to use
+    var af = addScalar;
+    // multiplyScalar signature to use
+    var mf = multiplyScalar;
+    // equalScalar signature to use
+    var eq = equalScalar;
+    // zero value
+    var zero = 0;
+
+    // process data types
     if (adt && bdt && adt === bdt && typeof adt === 'string') {
       // datatype
-      dt = adt; // find signatures that matches (dt, dt)
-
+      dt = adt;
+      // find signatures that matches (dt, dt)
       af = typed.find(addScalar, [dt, dt]);
       mf = typed.find(multiplyScalar, [dt, dt]);
-      eq = typed.find(equalScalar, [dt, dt]); // convert 0 to the same datatype
-
+      eq = typed.find(equalScalar, [dt, dt]);
+      // convert 0 to the same datatype
       zero = typed.convert(0, dt);
-    } // result
-
+    }
 
+    // result
     var cvalues = [];
     var cindex = [];
-    var cptr = []; // c matrix
-
+    var cptr = [];
+    // c matrix
     var c = b.createSparseMatrix({
       values: cvalues,
       index: cindex,
       ptr: cptr,
       size: [arows, bcolumns],
       datatype: dt
-    }); // loop b columns
+    });
 
+    // loop b columns
     for (var jb = 0; jb < bcolumns; jb++) {
       // update ptr
-      cptr[jb] = cindex.length; // indeces in column jb
-
+      cptr[jb] = cindex.length;
+      // indeces in column jb
       var kb0 = bptr[jb];
-      var kb1 = bptr[jb + 1]; // do not process column jb if no data exists
-
+      var kb1 = bptr[jb + 1];
+      // do not process column jb if no data exists
       if (kb1 > kb0) {
         // last row mark processed
-        var last = 0; // loop a rows
-
+        var last = 0;
+        // loop a rows
         for (var i = 0; i < arows; i++) {
           // column mark
-          var mark = i + 1; // C[i, jb]
-
-          var cij = void 0; // values in b column j
-
+          var mark = i + 1;
+          // C[i, jb]
+          var cij = void 0;
+          // values in b column j
           for (var kb = kb0; kb < kb1; kb++) {
             // row
-            var ib = bindex[kb]; // check value has been initialized
-
+            var ib = bindex[kb];
+            // check value has been initialized
             if (last !== mark) {
               // first value in column jb
-              cij = mf(adata[i][ib], bvalues[kb]); // update mark
-
+              cij = mf(adata[i][ib], bvalues[kb]);
+              // update mark
               last = mark;
             } else {
               // accumulate value
               cij = af(cij, mf(adata[i][ib], bvalues[kb]));
             }
-          } // check column has been processed and value != 0
-
-
+          }
+          // check column has been processed and value != 0
           if (last === mark && !eq(cij, zero)) {
             // push row & value
             cindex.push(i);
@@ -449,13 +427,14 @@ var createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
           }
         }
       }
-    } // update ptr
-
-
-    cptr[bcolumns] = cindex.length; // return sparse matrix
+    }
+    // update ptr
+    cptr[bcolumns] = cindex.length;
 
+    // return sparse matrix
     return c;
   }
+
   /**
    * C = A * B
    *
@@ -464,74 +443,74 @@ var createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
    *
    * @return {Matrix}             SparseMatrix    (M, 1)
    */
-
-
   function _multiplySparseMatrixVector(a, b) {
     // a sparse
     var avalues = a._values;
     var aindex = a._index;
     var aptr = a._ptr;
-    var adt = a._datatype; // validate a matrix
-
+    var adt = a._datatype;
+    // validate a matrix
     if (!avalues) {
       throw new Error('Cannot multiply Pattern only Matrix times Dense Matrix');
-    } // b dense
-
-
+    }
+    // b dense
     var bdata = b._data;
-    var bdt = b._datatype; // rows & columns
-
+    var bdt = b._datatype;
+    // rows & columns
     var arows = a._size[0];
-    var brows = b._size[0]; // result
-
+    var brows = b._size[0];
+    // result
     var cvalues = [];
     var cindex = [];
-    var cptr = []; // datatype
-
-    var dt; // addScalar signature to use
-
-    var af = addScalar; // multiplyScalar signature to use
-
-    var mf = multiplyScalar; // equalScalar signature to use
-
-    var eq = equalScalar; // zero value
-
-    var zero = 0; // process data types
-
+    var cptr = [];
+
+    // datatype
+    var dt;
+    // addScalar signature to use
+    var af = addScalar;
+    // multiplyScalar signature to use
+    var mf = multiplyScalar;
+    // equalScalar signature to use
+    var eq = equalScalar;
+    // zero value
+    var zero = 0;
+
+    // process data types
     if (adt && bdt && adt === bdt && typeof adt === 'string') {
       // datatype
-      dt = adt; // find signatures that matches (dt, dt)
-
+      dt = adt;
+      // find signatures that matches (dt, dt)
       af = typed.find(addScalar, [dt, dt]);
       mf = typed.find(multiplyScalar, [dt, dt]);
-      eq = typed.find(equalScalar, [dt, dt]); // convert 0 to the same datatype
-
+      eq = typed.find(equalScalar, [dt, dt]);
+      // convert 0 to the same datatype
       zero = typed.convert(0, dt);
-    } // workspace
-
-
-    var x = []; // vector with marks indicating a value x[i] exists in a given column
-
-    var w = []; // update ptr
+    }
 
-    cptr[0] = 0; // rows in b
+    // workspace
+    var x = [];
+    // vector with marks indicating a value x[i] exists in a given column
+    var w = [];
 
+    // update ptr
+    cptr[0] = 0;
+    // rows in b
     for (var ib = 0; ib < brows; ib++) {
       // b[ib]
-      var vbi = bdata[ib]; // check b[ib] != 0, avoid loops
-
+      var vbi = bdata[ib];
+      // check b[ib] != 0, avoid loops
       if (!eq(vbi, zero)) {
         // A values & index in ib column
         for (var ka0 = aptr[ib], ka1 = aptr[ib + 1], ka = ka0; ka < ka1; ka++) {
           // a row
-          var ia = aindex[ka]; // check value exists in current j
-
+          var ia = aindex[ka];
+          // check value exists in current j
           if (!w[ia]) {
             // ia is new entry in j
-            w[ia] = true; // add i to pattern of C
-
-            cindex.push(ia); // x(ia) = A
-
+            w[ia] = true;
+            // add i to pattern of C
+            cindex.push(ia);
+            // x(ia) = A
             x[ia] = mf(vbi, avalues[ka]);
           } else {
             // i exists in C already
@@ -539,19 +518,18 @@ var createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
           }
         }
       }
-    } // copy values from x to column jb of c
-
-
+    }
+    // copy values from x to column jb of c
     for (var p1 = cindex.length, p = 0; p < p1; p++) {
       // row
-      var ic = cindex[p]; // copy value
-
+      var ic = cindex[p];
+      // copy value
       cvalues[p] = x[ic];
-    } // update ptr
-
-
-    cptr[1] = cindex.length; // return sparse matrix
+    }
+    // update ptr
+    cptr[1] = cindex.length;
 
+    // return sparse matrix
     return a.createSparseMatrix({
       values: cvalues,
       index: cindex,
@@ -560,6 +538,7 @@ var createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
       datatype: dt
     });
   }
+
   /**
    * C = A * B
    *
@@ -568,87 +547,88 @@ var createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
    *
    * @return {Matrix}             SparseMatrix      (MxC)
    */
-
-
   function _multiplySparseMatrixDenseMatrix(a, b) {
     // a sparse
     var avalues = a._values;
     var aindex = a._index;
     var aptr = a._ptr;
-    var adt = a._datatype; // validate a matrix
-
+    var adt = a._datatype;
+    // validate a matrix
     if (!avalues) {
       throw new Error('Cannot multiply Pattern only Matrix times Dense Matrix');
-    } // b dense
-
-
+    }
+    // b dense
     var bdata = b._data;
-    var bdt = b._datatype; // rows & columns
-
+    var bdt = b._datatype;
+    // rows & columns
     var arows = a._size[0];
     var brows = b._size[0];
-    var bcolumns = b._size[1]; // datatype
-
-    var dt; // addScalar signature to use
-
-    var af = addScalar; // multiplyScalar signature to use
-
-    var mf = multiplyScalar; // equalScalar signature to use
-
-    var eq = equalScalar; // zero value
-
-    var zero = 0; // process data types
-
+    var bcolumns = b._size[1];
+
+    // datatype
+    var dt;
+    // addScalar signature to use
+    var af = addScalar;
+    // multiplyScalar signature to use
+    var mf = multiplyScalar;
+    // equalScalar signature to use
+    var eq = equalScalar;
+    // zero value
+    var zero = 0;
+
+    // process data types
     if (adt && bdt && adt === bdt && typeof adt === 'string') {
       // datatype
-      dt = adt; // find signatures that matches (dt, dt)
-
+      dt = adt;
+      // find signatures that matches (dt, dt)
       af = typed.find(addScalar, [dt, dt]);
       mf = typed.find(multiplyScalar, [dt, dt]);
-      eq = typed.find(equalScalar, [dt, dt]); // convert 0 to the same datatype
-
+      eq = typed.find(equalScalar, [dt, dt]);
+      // convert 0 to the same datatype
       zero = typed.convert(0, dt);
-    } // result
-
+    }
 
+    // result
     var cvalues = [];
     var cindex = [];
-    var cptr = []; // c matrix
-
+    var cptr = [];
+    // c matrix
     var c = a.createSparseMatrix({
       values: cvalues,
       index: cindex,
       ptr: cptr,
       size: [arows, bcolumns],
       datatype: dt
-    }); // workspace
-
-    var x = []; // vector with marks indicating a value x[i] exists in a given column
+    });
 
-    var w = []; // loop b columns
+    // workspace
+    var x = [];
+    // vector with marks indicating a value x[i] exists in a given column
+    var w = [];
 
+    // loop b columns
     for (var jb = 0; jb < bcolumns; jb++) {
       // update ptr
-      cptr[jb] = cindex.length; // mark in workspace for current column
-
-      var mark = jb + 1; // rows in jb
-
+      cptr[jb] = cindex.length;
+      // mark in workspace for current column
+      var mark = jb + 1;
+      // rows in jb
       for (var ib = 0; ib < brows; ib++) {
         // b[ib, jb]
-        var vbij = bdata[ib][jb]; // check b[ib, jb] != 0, avoid loops
-
+        var vbij = bdata[ib][jb];
+        // check b[ib, jb] != 0, avoid loops
         if (!eq(vbij, zero)) {
           // A values & index in ib column
           for (var ka0 = aptr[ib], ka1 = aptr[ib + 1], ka = ka0; ka < ka1; ka++) {
             // a row
-            var ia = aindex[ka]; // check value exists in current j
-
+            var ia = aindex[ka];
+            // check value exists in current j
             if (w[ia] !== mark) {
               // ia is new entry in j
-              w[ia] = mark; // add i to pattern of C
-
-              cindex.push(ia); // x(ia) = A
-
+              w[ia] = mark;
+              // add i to pattern of C
+              cindex.push(ia);
+              // x(ia) = A
               x[ia] = mf(vbij, avalues[ka]);
             } else {
               // i exists in C already
@@ -656,22 +636,22 @@ var createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
             }
           }
         }
-      } // copy values from x to column jb of c
-
-
+      }
+      // copy values from x to column jb of c
       for (var p0 = cptr[jb], p1 = cindex.length, p = p0; p < p1; p++) {
         // row
-        var ic = cindex[p]; // copy value
-
+        var ic = cindex[p];
+        // copy value
         cvalues[p] = x[ic];
       }
-    } // update ptr
-
-
-    cptr[bcolumns] = cindex.length; // return sparse matrix
+    }
+    // update ptr
+    cptr[bcolumns] = cindex.length;
 
+    // return sparse matrix
     return c;
   }
+
   /**
    * C = A * B
    *
@@ -680,80 +660,82 @@ var createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
    *
    * @return {Matrix}             SparseMatrix      (MxC)
    */
-
-
   function _multiplySparseMatrixSparseMatrix(a, b) {
     // a sparse
     var avalues = a._values;
     var aindex = a._index;
     var aptr = a._ptr;
-    var adt = a._datatype; // b sparse
-
+    var adt = a._datatype;
+    // b sparse
     var bvalues = b._values;
     var bindex = b._index;
     var bptr = b._ptr;
-    var bdt = b._datatype; // rows & columns
+    var bdt = b._datatype;
 
+    // rows & columns
     var arows = a._size[0];
-    var bcolumns = b._size[1]; // flag indicating both matrices (a & b) contain data
-
-    var values = avalues && bvalues; // datatype
-
-    var dt; // addScalar signature to use
-
-    var af = addScalar; // multiplyScalar signature to use
-
-    var mf = multiplyScalar; // process data types
-
+    var bcolumns = b._size[1];
+    // flag indicating both matrices (a & b) contain data
+    var values = avalues && bvalues;
+
+    // datatype
+    var dt;
+    // addScalar signature to use
+    var af = addScalar;
+    // multiplyScalar signature to use
+    var mf = multiplyScalar;
+
+    // process data types
     if (adt && bdt && adt === bdt && typeof adt === 'string') {
       // datatype
-      dt = adt; // find signatures that matches (dt, dt)
-
+      dt = adt;
+      // find signatures that matches (dt, dt)
       af = typed.find(addScalar, [dt, dt]);
       mf = typed.find(multiplyScalar, [dt, dt]);
-    } // result
-
+    }
 
+    // result
     var cvalues = values ? [] : undefined;
     var cindex = [];
-    var cptr = []; // c matrix
-
+    var cptr = [];
+    // c matrix
     var c = a.createSparseMatrix({
       values: cvalues,
       index: cindex,
       ptr: cptr,
       size: [arows, bcolumns],
       datatype: dt
-    }); // workspace
-
-    var x = values ? [] : undefined; // vector with marks indicating a value x[i] exists in a given column
-
-    var w = []; // variables
-
-    var ka, ka0, ka1, kb, kb0, kb1, ia, ib; // loop b columns
+    });
 
+    // workspace
+    var x = values ? [] : undefined;
+    // vector with marks indicating a value x[i] exists in a given column
+    var w = [];
+    // variables
+    var ka, ka0, ka1, kb, kb0, kb1, ia, ib;
+    // loop b columns
     for (var jb = 0; jb < bcolumns; jb++) {
       // update ptr
-      cptr[jb] = cindex.length; // mark in workspace for current column
-
-      var mark = jb + 1; // B values & index in j
-
+      cptr[jb] = cindex.length;
+      // mark in workspace for current column
+      var mark = jb + 1;
+      // B values & index in j
       for (kb0 = bptr[jb], kb1 = bptr[jb + 1], kb = kb0; kb < kb1; kb++) {
         // b row
-        ib = bindex[kb]; // check we need to process values
-
+        ib = bindex[kb];
+        // check we need to process values
         if (values) {
           // loop values in a[:,ib]
           for (ka0 = aptr[ib], ka1 = aptr[ib + 1], ka = ka0; ka < ka1; ka++) {
             // row
-            ia = aindex[ka]; // check value exists in current j
-
+            ia = aindex[ka];
+            // check value exists in current j
             if (w[ia] !== mark) {
               // ia is new entry in j
-              w[ia] = mark; // add i to pattern of C
-
-              cindex.push(ia); // x(ia) = A
-
+              w[ia] = mark;
+              // add i to pattern of C
+              cindex.push(ia);
+              // x(ia) = A
               x[ia] = mf(bvalues[kb], avalues[ka]);
             } else {
               // i exists in C already
@@ -764,35 +746,35 @@ var createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
           // loop values in a[:,ib]
           for (ka0 = aptr[ib], ka1 = aptr[ib + 1], ka = ka0; ka < ka1; ka++) {
             // row
-            ia = aindex[ka]; // check value exists in current j
-
+            ia = aindex[ka];
+            // check value exists in current j
             if (w[ia] !== mark) {
               // ia is new entry in j
-              w[ia] = mark; // add i to pattern of C
-
+              w[ia] = mark;
+              // add i to pattern of C
               cindex.push(ia);
             }
           }
         }
-      } // check we need to process matrix values (pattern matrix)
-
-
+      }
+      // check we need to process matrix values (pattern matrix)
       if (values) {
         // copy values from x to column jb of c
         for (var p0 = cptr[jb], p1 = cindex.length, p = p0; p < p1; p++) {
           // row
-          var ic = cindex[p]; // copy value
-
+          var ic = cindex[p];
+          // copy value
           cvalues[p] = x[ic];
         }
       }
-    } // update ptr
-
-
-    cptr[bcolumns] = cindex.length; // return sparse matrix
+    }
+    // update ptr
+    cptr[bcolumns] = cindex.length;
 
+    // return sparse matrix
     return c;
   }
+
   /**
    * Multiply two or more values, `x * y`.
    * For matrices, the matrix product is calculated.
@@ -826,47 +808,44 @@ var createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
    * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} y Second value to multiply
    * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} Multiplication of `x` and `y`
    */
-
-
   return typed(name, multiplyScalar, {
     // we extend the signatures of multiplyScalar with signatures dealing with matrices
+
     'Array, Array': typed.referTo('Matrix, Matrix', function (selfMM) {
       return function (x, y) {
         // check dimensions
-        _validateMatrixDimensions((0, _array.arraySize)(x), (0, _array.arraySize)(y)); // use dense matrix implementation
-
-
-        var m = selfMM(matrix(x), matrix(y)); // return array or scalar
+        _validateMatrixDimensions((0, _array.arraySize)(x), (0, _array.arraySize)(y));
 
+        // use dense matrix implementation
+        var m = selfMM(matrix(x), matrix(y));
+        // return array or scalar
         return (0, _is.isMatrix)(m) ? m.valueOf() : m;
       };
     }),
     'Matrix, Matrix': function MatrixMatrix(x, y) {
       // dimensions
       var xsize = x.size();
-      var ysize = y.size(); // check dimensions
-
-      _validateMatrixDimensions(xsize, ysize); // process dimensions
+      var ysize = y.size();
 
+      // check dimensions
+      _validateMatrixDimensions(xsize, ysize);
 
+      // process dimensions
       if (xsize.length === 1) {
         // process y dimensions
         if (ysize.length === 1) {
           // Vector * Vector
           return _multiplyVectorVector(x, y, xsize[0]);
-        } // Vector * Matrix
-
-
+        }
+        // Vector * Matrix
         return _multiplyVectorMatrix(x, y);
-      } // process y dimensions
-
-
+      }
+      // process y dimensions
       if (ysize.length === 1) {
         // Matrix * Vector
         return _multiplyMatrixVector(x, y);
-      } // Matrix * Matrix
-
-
+      }
+      // Matrix * Matrix
       return _multiplyMatrixMatrix(x, y);
     },
     'Matrix, Array': typed.referTo('Matrix,Matrix', function (selfMM) {
@@ -904,11 +883,9 @@ var createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
     'any, any, ...any': typed.referToSelf(function (self) {
       return function (x, y, rest) {
         var result = self(x, y);
-
         for (var i = 0; i < rest.length; i++) {
           result = self(result, rest[i]);
         }
-
         return result;
       };
     })