Add benchmarks for matrix and frame operations including multiplication, summation, product, application along axes, and transposition

benches/benchmarks.rs

@@ -109,6 +109,47 @@ fn matrix_operations_benchmark(c: &mut Criterion, sizes: &[usize]) {
                 let _result = &ma / 2.0;
             });
         });
+        c.bench_function(
+            &format!("matrix matrix_multiply ({}x{})", size, size),
+            |b| {
+                b.iter(|| {
+                    let _result = ma.matrix_mul(&ma);
+                });
+            },
+        );
+        c.bench_function(&format!("matrix sum_horizontal ({}x{})", size, size), |b| {
+            b.iter(|| {
+                let _result = ma.sum_horizontal();
+            });
+        });
+        c.bench_function(&format!("matrix sum_vertical ({}x{})", size, size), |b| {
+            b.iter(|| {
+                let _result = ma.sum_vertical();
+            });
+        });
+        c.bench_function(
+            &format!("matrix prod_horizontal ({}x{})", size, size),
+            |b| {
+                b.iter(|| {
+                    let _result = ma.prod_horizontal();
+                });
+            },
+        );
+        c.bench_function(&format!("matrix prod_vertical ({}x{})", size, size), |b| {
+            b.iter(|| {
+                let _result = ma.prod_vertical();
+            });
+        });
+        c.bench_function(&format!("matrix apply_axis ({}x{})", size, size), |b| {
+            b.iter(|| {
+                let _result = ma.apply_axis(0, |col| col.iter().sum::<f64>());
+            });
+        });
+        c.bench_function(&format!("matrix transpose ({}x{})", size, size), |b| {
+            b.iter(|| {
+                let _result = ma.transpose();
+            });
+        });
     }
 
     for &size in sizes {
@@ -187,6 +228,12 @@ fn benchmark_frame_operations(c: &mut Criterion, sizes: &[usize]) {
             });
         });
 
+        c.bench_function(&format!("frame matrix_multiply ({}x{})", size, size), |b| {
+            b.iter(|| {
+                let _result = fa.matrix_mul(&fb);
+            });
+        });
+
         c.bench_function(&format!("frame sum_horizontal ({}x{})", size, size), |b| {
             b.iter(|| {
                 let _result = fa.sum_horizontal();
@@ -207,6 +254,16 @@ fn benchmark_frame_operations(c: &mut Criterion, sizes: &[usize]) {
                 let _result = fa.prod_vertical();
             });
         });
+        c.bench_function(&format!("frame apply_axis ({}x{})", size, size), |b| {
+            b.iter(|| {
+                let _result = fa.apply_axis(0, |col| col.iter().sum::<f64>());
+            });
+        });
+        c.bench_function(&format!("frame transpose ({}x{})", size, size), |b| {
+            b.iter(|| {
+                let _result = fa.transpose();
+            });
+        });
     }
 }
 

src/frame/base.rs

@@ -471,6 +471,12 @@ impl<T: Clone + PartialEq> Frame<T> {
         deleted_data
     }
 
+
+    /// Returns a new `Matrix` that is the transpose of the current frame's matrix.
+    pub fn transpose(&mut self) -> Matrix<T> {
+        self.matrix.transpose()
+    }
+
     /// Sorts columns alphabetically by name, preserving data associations.
     pub fn sort_columns(&mut self) {
         let n = self.column_names.len();