chore: use mitota

Author: jobo322

benchmark/benchmark.js

@@ -0,0 +1,48 @@
+import { run, bench, lineplot, do_not_optimize } from 'mitata';
+import { SparseMatrix } from '../src/index.js';
+import { randomSparseMatrix } from './utils/randomSparseMatrix.js';
+import { Matrix } from 'ml-matrix';
+import { SparseMatrix as SparseMatrixOld } from './class/SparseMatrixOld.js';
+import { randomMatrix } from './utils/randomMatrix.js';
+const density = 0.01; // Fixed density for this comparison;
+const min = 32;
+const max = 128;
+// Prepare matrices once
+
+lineplot(() => {
+  bench('Sparse.mmul($size)', function* (ctx) {
+    const size = ctx.get('size');
+
+    // Prepare matrices once
+    const A = new SparseMatrix(randomMatrix(size, size, density));
+    const B = new SparseMatrix(randomMatrix(size, size, density));
+    // Benchmark the multiplication
+    yield () => do_not_optimize(A.mmul(B));
+  }).range('size', min, max, 2); // 16, 32, 64, 128, 256
+
+  bench('SparseOld.mmul($size)', function* (ctx) {
+    const size = ctx.get('size');
+    const A = randomMatrix(size, size, density);
+    const B = randomMatrix(size, size, density);
+    const AOld = new SparseMatrixOld(A);
+    const BOld = new SparseMatrixOld(B);
+
+    // Benchmark the multiplication
+    yield () => do_not_optimize(AOld.mmul(BOld));
+  }).range('size', min, max, 2);
+
+  bench('Dense.mmul($size)', function* (ctx) {
+    const size = ctx.get('size');
+
+    // Prepare matrices once
+    const A = randomMatrix(size, size, density);
+    const B = randomMatrix(size, size, density);
+    const ADense = new Matrix(A);
+    const BDense = new Matrix(B);
+
+    // Benchmark the multiplication
+    yield () => do_not_optimize(ADense.mmul(BDense));
+  }).range('size', min, max, 2);
+});
+
+await run();

benchmark/benchmarkLinePlot.js

@@ -0,0 +1,45 @@
+import { run, bench, group, do_not_optimize } from 'mitata';
+import { Matrix } from 'ml-matrix';
+import { SparseMatrix as SparseMatrixOld } from './class/SparseMatrixOld2.js';
+import fs from 'fs';
+import { randomSparseMatrix } from './utils/randomSparseMatrix.js';
+
+const sizes = [64, 128, 256];
+const densities = [0.01, 0.015, 0.02, 0.025, 0.03];
+const results = [];
+
+for (const density of densities) {
+  for (const size of sizes) {
+    const A = randomSparseMatrix(size, size, density);
+    const B = randomSparseMatrix(size, size, density);
+    let denseA = A.to2DArray();
+    let denseB = B.to2DArray();
+    const AOld = new SparseMatrixOld(denseA);
+    const BOld = new SparseMatrixOld(denseB);
+    denseA = new Matrix(denseA);
+    denseB = new Matrix(denseB);
+
+    // Warm up
+    A.mmul(B);
+
+    let mmulNewAvg, mmulAvg, denseAvg;
+
+    group(`size:${size}-density:${density}`, () => {
+      bench('mmulNew', () => {
+        do_not_optimize(A.mmul(B));
+      }); //.gc('inner');
+      bench('mmul', () => {
+        do_not_optimize(AOld.mmul(BOld));
+      }); //.gc('inner');
+      bench('denseMatrix', () => {
+        do_not_optimize(denseA.mmul(denseB));
+      }); //.gc('inner');
+    });
+
+    // mitata will handle timing and reporting
+    // You can extract results from mitata's output or use the save() function
+  }
+}
+
+await run({ silent: false });
+// await save({ file: './benchmark/mitata_results.json', format: 'json' });

benchmark/benchmarkMitata.js

@@ -1383,4 +1383,4 @@ export class SparseMatrix {
 SparseMatrix.prototype.klass = 'Matrix';
 
 SparseMatrix.identity = SparseMatrix.eye;
-SparseMatrix.prototype.tensorProduct = SparseMatrix.prototype.kroneckerProduct;
+SparseMatrix.prototype.tensorProduct = SparseMatrix.prototype.kroneckerProduct;