feat: move internal specialized matrix multiplication as pure functions

Author: jobo322

src/index.js

@@ -1,6 +1,9 @@
 import HashTable from 'ml-hash-table';
 
 import { cooToCsr } from './utils/cooToCsr.js';
+import { mmulLowDensity } from './utils/mmulLowDensity.js';
+import { mmulMediumDensity } from './utils/mmulMediumDensity.js';
+import { mmulSmall } from './utils/mmulSmall.js';
 
 /** @typedef {(row: number, column: number, value: number) => void} WithEachNonZeroCallback */
 /** @typedef {(row: number, column: number, value: number) => number | false} ForEachNonZeroCallback */
@@ -170,117 +173,16 @@ export class SparseMatrix {
         'Number of columns of left matrix are not equal to number of rows of right matrix.',
       );
     }
+
     if (this.cardinality < 42 && other.cardinality < 42) {
-      return this._mmulSmall(other);
+      return mmulSmall(this, other);
     } else if (other.rows > 100 && other.cardinality < 100) {
-      return this._mmulLowDensity(other);
+      return mmulLowDensity(this, other);
     }
-    return this._mmulMediumDensity(other);
-  }
-
-  /**
-   * Matrix multiplication optimized for very small matrices (both cardinalities < 42).
-   *
-   * @private
-   * @param {SparseMatrix} other - The right-hand side matrix to multiply with.
-   * @returns {SparseMatrix} - The resulting matrix after multiplication.
-   */
-  _mmulSmall(other) {
-    const m = this.rows;
-    const p = other.columns;
-    const {
-      columns: otherCols,
-      rows: otherRows,
-      values: otherValues,
-    } = other.getNonZeros();
-
-    const nbOtherActive = otherCols.length;
-    const result = new SparseMatrix(m, p);
-    this.withEachNonZero((i, j, v1) => {
-      for (let o = 0; o < nbOtherActive; o++) {
-        if (j === otherRows[o]) {
-          const l = otherCols[o];
-          result.set(i, l, result.get(i, l) + otherValues[o] * v1);
-        }
-      }
-    });
-    return result;
-  }
-
-  /**
-   * Matrix multiplication optimized for low-density right-hand side matrices (other.rows > 100 and other.cardinality < 100).
-   *
-   * @private
-   * @param {SparseMatrix} other - The right-hand side matrix to multiply with.
-   * @returns {SparseMatrix} - The resulting matrix after multiplication.
-   */
-  _mmulLowDensity(other) {
-    const m = this.rows;
-    const p = other.columns;
-    const {
-      columns: otherCols,
-      rows: otherRows,
-      values: otherValues,
-    } = other.getNonZeros();
-    const {
-      columns: thisCols,
-      rows: thisRows,
-      values: thisValues,
-    } = this.getNonZeros();
 
-    const result = new SparseMatrix(m, p);
-    const nbOtherActive = otherCols.length;
-    const nbThisActive = thisCols.length;
-    for (let t = 0; t < nbThisActive; t++) {
-      const i = thisRows[t];
-      const j = thisCols[t];
-      for (let o = 0; o < nbOtherActive; o++) {
-        if (j === otherRows[o]) {
-          const l = otherCols[o];
-          result.set(i, l, result.get(i, l) + otherValues[o] * thisValues[t]);
-        }
-      }
-    }
-    // console.log(result.cardinality);
-    return result;
+    return mmulMediumDensity(this, other);
   }
 
-  /**
-   * Matrix multiplication for medium-density matrices using CSR format for the right-hand side.
-   *
-   * @private
-   * @param {SparseMatrix} other - The right-hand side matrix to multiply with.
-   * @returns {SparseMatrix} - The resulting matrix after multiplication.
-   */
-  _mmulMediumDensity(other) {
-    const {
-      columns: thisCols,
-      rows: thisRows,
-      values: thisValues,
-    } = this.getNonZeros();
-    const {
-      columns: otherCols,
-      rows: otherRows,
-      values: otherValues,
-    } = other.getNonZeros({ csr: true });
-
-    const m = this.rows;
-    const p = other.columns;
-    const result = new SparseMatrix(m, p);
-    const nbThisActive = thisCols.length;
-    for (let t = 0; t < nbThisActive; t++) {
-      const i = thisRows[t];
-      const j = thisCols[t];
-      const oStart = otherRows[j];
-      const oEnd = otherRows[j + 1];
-      for (let k = oStart; k < oEnd; k++) {
-        const l = otherCols[k];
-        result.set(i, l, result.get(i, l) + otherValues[k] * thisValues[t]);
-      }
-    }
-
-    return result;
-  }
   /**
    * @param {SparseMatrix} other
    * @returns {SparseMatrix}

src/utils/mmulLowDensity.js

@@ -0,0 +1,41 @@
+import { SparseMatrix } from '../index.js';
+
+/**
+ * Multiplies two sparse matrices, optimized for cases where the right-hand side matrix
+ * has low density (number of rows > 100 and cardinality < 100).
+ *
+ * @private
+ * @param {SparseMatrix} left - The left-hand side matrix.
+ * @param {SparseMatrix} right - The right-hand side matrix to multiply with.
+ * @returns {SparseMatrix} The resulting matrix after multiplication.
+ */
+export function mmulLowDensity(left, right) {
+  const {
+    columns: otherCols,
+    rows: otherRows,
+    values: otherValues,
+  } = right.getNonZeros();
+  const {
+    columns: thisCols,
+    rows: thisRows,
+    values: thisValues,
+  } = left.getNonZeros();
+
+  const m = left.rows;
+  const p = right.columns;
+  const output = new SparseMatrix(m, p);
+
+  const nbOtherActive = otherCols.length;
+  const nbThisActive = thisCols.length;
+  for (let t = 0; t < nbThisActive; t++) {
+    const i = thisRows[t];
+    const j = thisCols[t];
+    for (let o = 0; o < nbOtherActive; o++) {
+      if (j === otherRows[o]) {
+        const l = otherCols[o];
+        output.set(i, l, output.get(i, l) + otherValues[o] * thisValues[t]);
+      }
+    }
+  }
+  return output;
+}

src/utils/mmulMediumDensity.js

@@ -0,0 +1,41 @@
+import { SparseMatrix } from '../index.js';
+
+/**
+ * Multiplies two sparse matrices where the right-hand side matrix is of medium density.
+ * Uses CSR format for the right-hand side for efficient multiplication.
+ *
+ * @private
+ * @param {SparseMatrix} left - The left-hand side matrix.
+ * @param {SparseMatrix} right - The right-hand side matrix to multiply with (in CSR format).
+ * @returns {SparseMatrix} The resulting matrix after multiplication.
+ */
+
+export function mmulMediumDensity(left, right) {
+  const m = left.rows;
+  const p = right.columns;
+  const result = new SparseMatrix(m, p);
+  const {
+    columns: thisCols,
+    rows: thisRows,
+    values: thisValues,
+  } = left.getNonZeros();
+  const {
+    columns: otherCols,
+    rows: otherRows,
+    values: otherValues,
+  } = right.getNonZeros({ csr: true });
+
+  const nbThisActive = thisCols.length;
+  for (let t = 0; t < nbThisActive; t++) {
+    const i = thisRows[t];
+    const j = thisCols[t];
+    const oStart = otherRows[j];
+    const oEnd = otherRows[j + 1];
+    for (let k = oStart; k < oEnd; k++) {
+      const l = otherCols[k];
+      result.set(i, l, result.get(i, l) + otherValues[k] * thisValues[t]);
+    }
+  }
+
+  return result;
+}

src/utils/mmulSmall.js

@@ -0,0 +1,33 @@
+import { SparseMatrix } from '../index.js';
+
+/**
+ * Multiplies two very small sparse matrices (both with cardinalities < 42).
+ *
+ * @private
+ * @param {SparseMatrix} left - The left-hand side matrix.
+ * @param {SparseMatrix} right - The right-hand side matrix to multiply with.
+ * @returns {SparseMatrix} The resulting matrix after multiplication.
+ */
+export function mmulSmall(left, right) {
+  const {
+    columns: otherCols,
+    rows: otherRows,
+    values: otherValues,
+  } = right.getNonZeros();
+
+  const nbOtherActive = otherCols.length;
+
+  const m = left.rows;
+  const p = right.columns;
+  const output = new SparseMatrix(m, p);
+
+  left.withEachNonZero((i, j, v1) => {
+    for (let o = 0; o < nbOtherActive; o++) {
+      if (j === otherRows[o]) {
+        const l = otherCols[o];
+        output.set(i, l, output.get(i, l) + otherValues[o] * v1);
+      }
+    }
+  });
+  return output;
+}