feat:node-modules

node_modules/mathjs/lib/cjs/function/arithmetic/multiply.js

@@ -0,0 +1,886 @@
+"use strict";
+
+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");
+const name = 'multiply';
+const dependencies = ['typed', 'matrix', 'addScalar', 'multiplyScalar', 'equalScalar', 'dot'];
+const createMultiply = exports.createMultiply = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    addScalar,
+    multiplyScalar,
+    equalScalar,
+    dot
+  } = _ref;
+  const matAlgo11xS0s = (0, _matAlgo11xS0s.createMatAlgo11xS0s)({
+    typed,
+    equalScalar
+  });
+  const matAlgo14xDs = (0, _matAlgo14xDs.createMatAlgo14xDs)({
+    typed
+  });
+  function _validateMatrixDimensions(size1, size2) {
+    // check left operand dimensions
+    switch (size1.length) {
+      case 1:
+        // check size2
+        switch (size2.length) {
+          case 1:
+            // Vector x Vector
+            if (size1[0] !== size2[0]) {
+              // 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) {
+          case 1:
+            // Matrix x Vector
+            if (size1[1] !== size2[0]) {
+              // 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
+   *
+   * @param {Matrix} a            Dense Vector   (N)
+   * @param {Matrix} b            Dense Vector   (N)
+   *
+   * @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
+   *
+   * @param {Matrix} a            Dense Vector   (M)
+   * @param {Matrix} b            Matrix         (MxN)
+   *
+   * @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
+   *
+   * @param {Matrix} a            Dense Vector   (M)
+   * @param {Matrix} b            Dense Matrix   (MxN)
+   *
+   * @return {Matrix}             Dense Vector   (N)
+   */
+  function _multiplyVectorDenseMatrix(a, b) {
+    // a dense
+    const adata = a._data;
+    const asize = a._size;
+    const adt = a._datatype || a.getDataType();
+    // b dense
+    const bdata = b._data;
+    const bsize = b._size;
+    const bdt = b._datatype || b.getDataType();
+    // rows & columns
+    const alength = asize[0];
+    const bcolumns = bsize[1];
+
+    // datatype
+    let dt;
+    // addScalar signature to use
+    let af = addScalar;
+    // multiplyScalar signature to use
+    let mf = multiplyScalar;
+
+    // process data types
+    if (adt && bdt && adt === bdt && typeof adt === 'string' && adt !== 'mixed') {
+      // datatype
+      dt = adt;
+      // find signatures that matches (dt, dt)
+      af = typed.find(addScalar, [dt, dt]);
+      mf = typed.find(multiplyScalar, [dt, dt]);
+    }
+
+    // result
+    const c = [];
+
+    // loop matrix columns
+    for (let j = 0; j < bcolumns; j++) {
+      // sum (do not initialize it with zero)
+      let sum = mf(adata[0], bdata[0][j]);
+      // loop vector
+      for (let i = 1; i < alength; i++) {
+        // multiply & accumulate
+        sum = af(sum, mf(adata[i], bdata[i][j]));
+      }
+      c[j] = sum;
+    }
+
+    // return matrix
+    return a.createDenseMatrix({
+      data: c,
+      size: [bcolumns],
+      datatype: adt === a._datatype && bdt === b._datatype ? dt : undefined
+    });
+  }
+
+  /**
+   * C = A * B
+   *
+   * @param {Matrix} a            Matrix         (MxN)
+   * @param {Matrix} b            Dense Vector   (N)
+   *
+   * @return {Matrix}             Dense Vector   (M)
+   */
+  const _multiplyMatrixVector = typed('_multiplyMatrixVector', {
+    'DenseMatrix, any': _multiplyDenseMatrixVector,
+    'SparseMatrix, any': _multiplySparseMatrixVector
+  });
+
+  /**
+   * C = A * B
+   *
+   * @param {Matrix} a            Matrix         (MxN)
+   * @param {Matrix} b            Matrix         (NxC)
+   *
+   * @return {Matrix}             Matrix         (MxC)
+   */
+  const _multiplyMatrixMatrix = typed('_multiplyMatrixMatrix', {
+    'DenseMatrix, DenseMatrix': _multiplyDenseMatrixDenseMatrix,
+    'DenseMatrix, SparseMatrix': _multiplyDenseMatrixSparseMatrix,
+    'SparseMatrix, DenseMatrix': _multiplySparseMatrixDenseMatrix,
+    'SparseMatrix, SparseMatrix': _multiplySparseMatrixSparseMatrix
+  });
+
+  /**
+   * C = A * B
+   *
+   * @param {Matrix} a            DenseMatrix  (MxN)
+   * @param {Matrix} b            Dense Vector (N)
+   *
+   * @return {Matrix}             Dense Vector (M)
+   */
+  function _multiplyDenseMatrixVector(a, b) {
+    // a dense
+    const adata = a._data;
+    const asize = a._size;
+    const adt = a._datatype || a.getDataType();
+    // b dense
+    const bdata = b._data;
+    const bdt = b._datatype || b.getDataType();
+    // rows & columns
+    const arows = asize[0];
+    const acolumns = asize[1];
+
+    // datatype
+    let dt;
+    // addScalar signature to use
+    let af = addScalar;
+    // multiplyScalar signature to use
+    let mf = multiplyScalar;
+
+    // process data types
+    if (adt && bdt && adt === bdt && typeof adt === 'string' && adt !== 'mixed') {
+      // datatype
+      dt = adt;
+      // find signatures that matches (dt, dt)
+      af = typed.find(addScalar, [dt, dt]);
+      mf = typed.find(multiplyScalar, [dt, dt]);
+    }
+
+    // result
+    const c = [];
+
+    // loop matrix a rows
+    for (let i = 0; i < arows; i++) {
+      // current row
+      const row = adata[i];
+      // sum (do not initialize it with zero)
+      let sum = mf(row[0], bdata[0]);
+      // loop matrix a columns
+      for (let j = 1; j < acolumns; j++) {
+        // multiply & accumulate
+        sum = af(sum, mf(row[j], bdata[j]));
+      }
+      c[i] = sum;
+    }
+
+    // return matrix
+    return a.createDenseMatrix({
+      data: c,
+      size: [arows],
+      datatype: adt === a._datatype && bdt === b._datatype ? dt : undefined
+    });
+  }
+
+  /**
+   * C = A * B
+   *
+   * @param {Matrix} a            DenseMatrix    (MxN)
+   * @param {Matrix} b            DenseMatrix    (NxC)
+   *
+   * @return {Matrix}             DenseMatrix    (MxC)
+   */
+  function _multiplyDenseMatrixDenseMatrix(a, b) {
+    // getDataType()
+    // a dense
+    const adata = a._data;
+    const asize = a._size;
+    const adt = a._datatype || a.getDataType();
+    // b dense
+    const bdata = b._data;
+    const bsize = b._size;
+    const bdt = b._datatype || b.getDataType();
+    // rows & columns
+    const arows = asize[0];
+    const acolumns = asize[1];
+    const bcolumns = bsize[1];
+
+    // datatype
+    let dt;
+    // addScalar signature to use
+    let af = addScalar;
+    // multiplyScalar signature to use
+    let mf = multiplyScalar;
+
+    // process data types
+    if (adt && bdt && adt === bdt && typeof adt === 'string' && adt !== 'mixed' && adt !== 'mixed') {
+      // datatype
+      dt = adt;
+      // find signatures that matches (dt, dt)
+      af = typed.find(addScalar, [dt, dt]);
+      mf = typed.find(multiplyScalar, [dt, dt]);
+    }
+
+    // result
+    const c = [];
+
+    // loop matrix a rows
+    for (let i = 0; i < arows; i++) {
+      // current row
+      const row = adata[i];
+      // initialize row array
+      c[i] = [];
+      // loop matrix b columns
+      for (let j = 0; j < bcolumns; j++) {
+        // sum (avoid initializing sum to zero)
+        let sum = mf(row[0], bdata[0][j]);
+        // loop matrix a columns
+        for (let x = 1; x < acolumns; x++) {
+          // multiply & accumulate
+          sum = af(sum, mf(row[x], bdata[x][j]));
+        }
+        c[i][j] = sum;
+      }
+    }
+
+    // return matrix
+    return a.createDenseMatrix({
+      data: c,
+      size: [arows, bcolumns],
+      datatype: adt === a._datatype && bdt === b._datatype ? dt : undefined
+    });
+  }
+
+  /**
+   * C = A * B
+   *
+   * @param {Matrix} a            DenseMatrix    (MxN)
+   * @param {Matrix} b            SparseMatrix   (NxC)
+   *
+   * @return {Matrix}             SparseMatrix   (MxC)
+   */
+  function _multiplyDenseMatrixSparseMatrix(a, b) {
+    // a dense
+    const adata = a._data;
+    const asize = a._size;
+    const adt = a._datatype || a.getDataType();
+    // b sparse
+    const bvalues = b._values;
+    const bindex = b._index;
+    const bptr = b._ptr;
+    const bsize = b._size;
+    const bdt = b._datatype || b._data === undefined ? b._datatype : b.getDataType();
+    // validate b matrix
+    if (!bvalues) {
+      throw new Error('Cannot multiply Dense Matrix times Pattern only Matrix');
+    }
+    // rows & columns
+    const arows = asize[0];
+    const bcolumns = bsize[1];
+
+    // datatype
+    let dt;
+    // addScalar signature to use
+    let af = addScalar;
+    // multiplyScalar signature to use
+    let mf = multiplyScalar;
+    // equalScalar signature to use
+    let eq = equalScalar;
+    // zero value
+    let zero = 0;
+
+    // process data types
+    if (adt && bdt && adt === bdt && typeof adt === 'string' && adt !== 'mixed') {
+      // datatype
+      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
+      zero = typed.convert(0, dt);
+    }
+
+    // result
+    const cvalues = [];
+    const cindex = [];
+    const cptr = [];
+    // c matrix
+    const c = b.createSparseMatrix({
+      values: cvalues,
+      index: cindex,
+      ptr: cptr,
+      size: [arows, bcolumns],
+      datatype: adt === a._datatype && bdt === b._datatype ? dt : undefined
+    });
+
+    // loop b columns
+    for (let jb = 0; jb < bcolumns; jb++) {
+      // update ptr
+      cptr[jb] = cindex.length;
+      // indeces in column jb
+      const kb0 = bptr[jb];
+      const kb1 = bptr[jb + 1];
+      // do not process column jb if no data exists
+      if (kb1 > kb0) {
+        // last row mark processed
+        let last = 0;
+        // loop a rows
+        for (let i = 0; i < arows; i++) {
+          // column mark
+          const mark = i + 1;
+          // C[i, jb]
+          let cij;
+          // values in b column j
+          for (let kb = kb0; kb < kb1; kb++) {
+            // row
+            const 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
+              last = mark;
+            } else {
+              // accumulate value
+              cij = af(cij, mf(adata[i][ib], bvalues[kb]));
+            }
+          }
+          // check column has been processed and value != 0
+          if (last === mark && !eq(cij, zero)) {
+            // push row & value
+            cindex.push(i);
+            cvalues.push(cij);
+          }
+        }
+      }
+    }
+    // update ptr
+    cptr[bcolumns] = cindex.length;
+
+    // return sparse matrix
+    return c;
+  }
+
+  /**
+   * C = A * B
+   *
+   * @param {Matrix} a            SparseMatrix    (MxN)
+   * @param {Matrix} b            Dense Vector (N)
+   *
+   * @return {Matrix}             SparseMatrix    (M, 1)
+   */
+  function _multiplySparseMatrixVector(a, b) {
+    // a sparse
+    const avalues = a._values;
+    const aindex = a._index;
+    const aptr = a._ptr;
+    const adt = a._datatype || a._data === undefined ? a._datatype : a.getDataType();
+    // validate a matrix
+    if (!avalues) {
+      throw new Error('Cannot multiply Pattern only Matrix times Dense Matrix');
+    }
+    // b dense
+    const bdata = b._data;
+    const bdt = b._datatype || b.getDataType();
+    // rows & columns
+    const arows = a._size[0];
+    const brows = b._size[0];
+    // result
+    const cvalues = [];
+    const cindex = [];
+    const cptr = [];
+
+    // datatype
+    let dt;
+    // addScalar signature to use
+    let af = addScalar;
+    // multiplyScalar signature to use
+    let mf = multiplyScalar;
+    // equalScalar signature to use
+    let eq = equalScalar;
+    // zero value
+    let zero = 0;
+
+    // process data types
+    if (adt && bdt && adt === bdt && typeof adt === 'string' && adt !== 'mixed') {
+      // datatype
+      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
+      zero = typed.convert(0, dt);
+    }
+
+    // workspace
+    const x = [];
+    // vector with marks indicating a value x[i] exists in a given column
+    const w = [];
+
+    // update ptr
+    cptr[0] = 0;
+    // rows in b
+    for (let ib = 0; ib < brows; ib++) {
+      // b[ib]
+      const vbi = bdata[ib];
+      // check b[ib] != 0, avoid loops
+      if (!eq(vbi, zero)) {
+        // A values & index in ib column
+        for (let ka0 = aptr[ib], ka1 = aptr[ib + 1], ka = ka0; ka < ka1; ka++) {
+          // a row
+          const 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
+            x[ia] = mf(vbi, avalues[ka]);
+          } else {
+            // i exists in C already
+            x[ia] = af(x[ia], mf(vbi, avalues[ka]));
+          }
+        }
+      }
+    }
+    // copy values from x to column jb of c
+    for (let p1 = cindex.length, p = 0; p < p1; p++) {
+      // row
+      const ic = cindex[p];
+      // copy value
+      cvalues[p] = x[ic];
+    }
+    // update ptr
+    cptr[1] = cindex.length;
+
+    // matrix to return
+    return a.createSparseMatrix({
+      values: cvalues,
+      index: cindex,
+      ptr: cptr,
+      size: [arows, 1],
+      datatype: adt === a._datatype && bdt === b._datatype ? dt : undefined
+    });
+  }
+
+  /**
+   * C = A * B
+   *
+   * @param {Matrix} a            SparseMatrix      (MxN)
+   * @param {Matrix} b            DenseMatrix       (NxC)
+   *
+   * @return {Matrix}             SparseMatrix      (MxC)
+   */
+  function _multiplySparseMatrixDenseMatrix(a, b) {
+    // a sparse
+    const avalues = a._values;
+    const aindex = a._index;
+    const aptr = a._ptr;
+    const adt = a._datatype || a._data === undefined ? a._datatype : a.getDataType();
+    // validate a matrix
+    if (!avalues) {
+      throw new Error('Cannot multiply Pattern only Matrix times Dense Matrix');
+    }
+    // b dense
+    const bdata = b._data;
+    const bdt = b._datatype || b.getDataType();
+    // rows & columns
+    const arows = a._size[0];
+    const brows = b._size[0];
+    const bcolumns = b._size[1];
+
+    // datatype
+    let dt;
+    // addScalar signature to use
+    let af = addScalar;
+    // multiplyScalar signature to use
+    let mf = multiplyScalar;
+    // equalScalar signature to use
+    let eq = equalScalar;
+    // zero value
+    let zero = 0;
+
+    // process data types
+    if (adt && bdt && adt === bdt && typeof adt === 'string' && adt !== 'mixed') {
+      // datatype
+      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
+      zero = typed.convert(0, dt);
+    }
+
+    // result
+    const cvalues = [];
+    const cindex = [];
+    const cptr = [];
+    // c matrix
+    const c = a.createSparseMatrix({
+      values: cvalues,
+      index: cindex,
+      ptr: cptr,
+      size: [arows, bcolumns],
+      datatype: adt === a._datatype && bdt === b._datatype ? dt : undefined
+    });
+
+    // workspace
+    const x = [];
+    // vector with marks indicating a value x[i] exists in a given column
+    const w = [];
+
+    // loop b columns
+    for (let jb = 0; jb < bcolumns; jb++) {
+      // update ptr
+      cptr[jb] = cindex.length;
+      // mark in workspace for current column
+      const mark = jb + 1;
+      // rows in jb
+      for (let ib = 0; ib < brows; ib++) {
+        // b[ib, jb]
+        const vbij = bdata[ib][jb];
+        // check b[ib, jb] != 0, avoid loops
+        if (!eq(vbij, zero)) {
+          // A values & index in ib column
+          for (let ka0 = aptr[ib], ka1 = aptr[ib + 1], ka = ka0; ka < ka1; ka++) {
+            // a row
+            const 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
+              x[ia] = mf(vbij, avalues[ka]);
+            } else {
+              // i exists in C already
+              x[ia] = af(x[ia], mf(vbij, avalues[ka]));
+            }
+          }
+        }
+      }
+      // copy values from x to column jb of c
+      for (let p0 = cptr[jb], p1 = cindex.length, p = p0; p < p1; p++) {
+        // row
+        const ic = cindex[p];
+        // copy value
+        cvalues[p] = x[ic];
+      }
+    }
+    // update ptr
+    cptr[bcolumns] = cindex.length;
+
+    // return sparse matrix
+    return c;
+  }
+
+  /**
+   * C = A * B
+   *
+   * @param {Matrix} a            SparseMatrix      (MxN)
+   * @param {Matrix} b            SparseMatrix      (NxC)
+   *
+   * @return {Matrix}             SparseMatrix      (MxC)
+   */
+  function _multiplySparseMatrixSparseMatrix(a, b) {
+    // a sparse
+    const avalues = a._values;
+    const aindex = a._index;
+    const aptr = a._ptr;
+    const adt = a._datatype || a._data === undefined ? a._datatype : a.getDataType();
+    // b sparse
+    const bvalues = b._values;
+    const bindex = b._index;
+    const bptr = b._ptr;
+    const bdt = b._datatype || b._data === undefined ? b._datatype : b.getDataType();
+
+    // rows & columns
+    const arows = a._size[0];
+    const bcolumns = b._size[1];
+    // flag indicating both matrices (a & b) contain data
+    const values = avalues && bvalues;
+
+    // datatype
+    let dt;
+    // addScalar signature to use
+    let af = addScalar;
+    // multiplyScalar signature to use
+    let mf = multiplyScalar;
+
+    // process data types
+    if (adt && bdt && adt === bdt && typeof adt === 'string' && adt !== 'mixed') {
+      // datatype
+      dt = adt;
+      // find signatures that matches (dt, dt)
+      af = typed.find(addScalar, [dt, dt]);
+      mf = typed.find(multiplyScalar, [dt, dt]);
+    }
+
+    // result
+    const cvalues = values ? [] : undefined;
+    const cindex = [];
+    const cptr = [];
+    // c matrix
+    const c = a.createSparseMatrix({
+      values: cvalues,
+      index: cindex,
+      ptr: cptr,
+      size: [arows, bcolumns],
+      datatype: adt === a._datatype && bdt === b._datatype ? dt : undefined
+    });
+
+    // workspace
+    const x = values ? [] : undefined;
+    // vector with marks indicating a value x[i] exists in a given column
+    const w = [];
+    // variables
+    let ka, ka0, ka1, kb, kb0, kb1, ia, ib;
+    // loop b columns
+    for (let jb = 0; jb < bcolumns; jb++) {
+      // update ptr
+      cptr[jb] = cindex.length;
+      // mark in workspace for current column
+      const 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
+        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
+            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
+              x[ia] = mf(bvalues[kb], avalues[ka]);
+            } else {
+              // i exists in C already
+              x[ia] = af(x[ia], mf(bvalues[kb], avalues[ka]));
+            }
+          }
+        } else {
+          // 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
+            if (w[ia] !== mark) {
+              // ia is new entry in j
+              w[ia] = mark;
+              // add i to pattern of C
+              cindex.push(ia);
+            }
+          }
+        }
+      }
+      // check we need to process matrix values (pattern matrix)
+      if (values) {
+        // copy values from x to column jb of c
+        for (let p0 = cptr[jb], p1 = cindex.length, p = p0; p < p1; p++) {
+          // row
+          const ic = cindex[p];
+          // copy value
+          cvalues[p] = x[ic];
+        }
+      }
+    }
+    // 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.
+   *
+   * Syntax:
+   *
+   *    math.multiply(x, y)
+   *    math.multiply(x, y, z, ...)
+   *
+   * Examples:
+   *
+   *    math.multiply(4, 5.2)        // returns number 20.8
+   *    math.multiply(2, 3, 4)       // returns number 24
+   *
+   *    const a = math.complex(2, 3)
+   *    const b = math.complex(4, 1)
+   *    math.multiply(a, b)          // returns Complex 5 + 14i
+   *
+   *    const c = [[1, 2], [4, 3]]
+   *    const d = [[1, 2, 3], [3, -4, 7]]
+   *    math.multiply(c, d)          // returns Array [[7, -6, 17], [13, -4, 33]]
+   *
+   *    const e = math.unit('2.1 km')
+   *    math.multiply(3, e)          // returns Unit 6.3 km
+   *
+   * See also:
+   *
+   *    divide, prod, cross, dot
+   *
+   * @param  {number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix} x First value to multiply
+   * @param  {number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix} y Second value to multiply
+   * @return {number | BigNumber | bigint | 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', selfMM => (x, y) => {
+      // check dimensions
+      _validateMatrixDimensions((0, _array.arraySize)(x), (0, _array.arraySize)(y));
+
+      // use dense matrix implementation
+      const m = selfMM(matrix(x), matrix(y));
+      // return array or scalar
+      return (0, _is.isMatrix)(m) ? m.valueOf() : m;
+    }),
+    'Matrix, Matrix': function (x, y) {
+      // dimensions
+      const xsize = x.size();
+      const 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
+        return _multiplyVectorMatrix(x, y);
+      }
+      // process y dimensions
+      if (ysize.length === 1) {
+        // Matrix * Vector
+        return _multiplyMatrixVector(x, y);
+      }
+      // Matrix * Matrix
+      return _multiplyMatrixMatrix(x, y);
+    },
+    'Matrix, Array': typed.referTo('Matrix,Matrix', selfMM => (x, y) => selfMM(x, matrix(y))),
+    'Array, Matrix': typed.referToSelf(self => (x, y) => {
+      // use Matrix * Matrix implementation
+      return self(matrix(x, y.storage()), y);
+    }),
+    'SparseMatrix, any': function (x, y) {
+      return matAlgo11xS0s(x, y, multiplyScalar, false);
+    },
+    'DenseMatrix, any': function (x, y) {
+      return matAlgo14xDs(x, y, multiplyScalar, false);
+    },
+    'any, SparseMatrix': function (x, y) {
+      return matAlgo11xS0s(y, x, multiplyScalar, true);
+    },
+    'any, DenseMatrix': function (x, y) {
+      return matAlgo14xDs(y, x, multiplyScalar, true);
+    },
+    'Array, any': function (x, y) {
+      // use matrix implementation
+      return matAlgo14xDs(matrix(x), y, multiplyScalar, false).valueOf();
+    },
+    'any, Array': function (x, y) {
+      // use matrix implementation
+      return matAlgo14xDs(matrix(y), x, multiplyScalar, true).valueOf();
+    },
+    'any, any': multiplyScalar,
+    'any, any, ...any': typed.referToSelf(self => (x, y, rest) => {
+      let result = self(x, y);
+      for (let i = 0; i < rest.length; i++) {
+        result = self(result, rest[i]);
+      }
+      return result;
+    })
+  });
+});