Added a benchmark

src/examples/benchmarks/mod.rs

@@ -5,7 +5,7 @@ use crate::sketch::Sketch;
 pub mod stairs_with_lines_benchmark;
 
 pub trait BenchmarkFactory {
-    fn new_benchmark(n: usize) -> Box<dyn Benchmark>;
+    fn new_benchmark(&self, n: usize) -> Box<dyn Benchmark>;
 }
 
 pub trait Benchmark {
@@ -15,15 +15,47 @@ pub trait Benchmark {
 
 #[cfg(test)]
 mod tests {
-    use crate::solvers::gradient_based_solver::GradientBasedSolver;
+    use crate::solvers::{
+        bfgs_solver::BFGSSolver, gradient_based_solver::GradientBasedSolver, Solver,
+    };
 
-    use super::stairs_with_lines_benchmark::StairsWithLinesBenchmarkFactory;
+    use super::{stairs_with_lines_benchmark::StairsWithLinesBenchmarkFactory, BenchmarkFactory};
 
     #[ignore]
     #[test]
-    // Run the benchmark manually with `cargo test --release test_benchmark -- --ignored`
+    // Run the benchmark manually with `cargo test --release test_benchmark -- --ignored --nocapture`
     pub fn test_benchmark() {
-        let benchmarks = vec![StairsWithLinesBenchmarkFactory];
-        let solvers = vec![GradientBasedSolver::new()];
+        let benchmarks: Vec<(&str, Box<dyn BenchmarkFactory>)> = vec![(
+            "StairsWithLinesBenchmarkFactory",
+            Box::new(StairsWithLinesBenchmarkFactory),
+        )];
+        let solvers: Vec<(&str, Box<dyn Solver>)> = vec![
+            ("GradientBasedSolver", Box::new(GradientBasedSolver::new())),
+            ("BFGSSolver         ", Box::new(BFGSSolver::new())),
+        ];
+
+        for (benchmark_name, benchmark) in benchmarks.iter() {
+            println!("Benchmark: {}", benchmark_name);
+            for n in &[3, 5, 10, 30, 50, 100, 300] {
+                for (solver_name, solver) in &solvers {
+                    // Measure the time it takes to solve the benchmark
+                    let benchmark = benchmark.new_benchmark(*n);
+                    let sketch = benchmark.get_sketch();
+                    let start = std::time::Instant::now();
+                    solver.solve(sketch.clone()).unwrap();
+                    let duration = start.elapsed();
+                    let solved = benchmark.check(1e-6);
+                    let error = sketch.borrow_mut().get_loss();
+                    println!(
+                        "n: {},\tsolver: {},\tsolved: {},\terror: {:.2},\tduration: {}ms",
+                        n,
+                        solver_name,
+                        solved,
+                        error,
+                        duration.as_millis()
+                    );
+                }
+            }
+        }
     }
 }

src/examples/benchmarks/stairs_with_lines_benchmark.rs

@@ -23,7 +23,7 @@ use super::{Benchmark, BenchmarkFactory};
 pub struct StairsWithLinesBenchmarkFactory;
 
 impl BenchmarkFactory for StairsWithLinesBenchmarkFactory {
-    fn new_benchmark(n: usize) -> Box<dyn Benchmark> {
+    fn new_benchmark(&self, n: usize) -> Box<dyn Benchmark> {
         let sketch = Rc::new(RefCell::new(Sketch::new()));
 
         let mut point_references = Vec::new();