Incorporated the other features: genericization and autodiff mainly

benches/bs3_vs_dp5.rs

@@ -27,9 +27,8 @@ fn bench_exponential_decay(c: &mut Criterion) {
         let ode = ODE::new(&derivative, 0.0, 10.0, y0, params);
         let bs3 = BS3::new().a_tol(tol).r_tol(tol);
         b.iter(|| {
-            black_box({
-                Problem::new(ode, bs3, controller).solve();
-            });
+            let mut problem = Problem::new(ode, bs3, controller);
+            black_box(problem.solve());
         });
     });
 
@@ -37,9 +36,8 @@ fn bench_exponential_decay(c: &mut Criterion) {
         let ode = ODE::new(&derivative, 0.0, 10.0, y0, params);
         let dp45 = DormandPrince45::new().a_tol(tol).r_tol(tol);
         b.iter(|| {
-            black_box({
-                Problem::new(ode, dp45, controller).solve();
-            });
+            let mut problem = Problem::new(ode, dp45, controller);
+            black_box(problem.solve());
         });
     });
 
@@ -66,9 +64,8 @@ fn bench_harmonic_oscillator(c: &mut Criterion) {
         let ode = ODE::new(&derivative, 0.0, 20.0, y0, ());
         let bs3 = BS3::new().a_tol(tol).r_tol(tol);
         b.iter(|| {
-            black_box({
-                Problem::new(ode, bs3, controller).solve();
-            });
+            let mut problem = Problem::new(ode, bs3, controller);
+            black_box(problem.solve());
         });
     });
 
@@ -76,9 +73,8 @@ fn bench_harmonic_oscillator(c: &mut Criterion) {
         let ode = ODE::new(&derivative, 0.0, 20.0, y0, ());
         let dp45 = DormandPrince45::new().a_tol(tol).r_tol(tol);
         b.iter(|| {
-            black_box({
-                Problem::new(ode, dp45, controller).solve();
-            });
+            let mut problem = Problem::new(ode, dp45, controller);
+            black_box(problem.solve());
         });
     });
 
@@ -109,9 +105,8 @@ fn bench_pendulum(c: &mut Criterion) {
         let ode = ODE::new(&derivative, 0.0, 10.0, y0, params);
         let bs3 = BS3::new().a_tol(tol).r_tol(tol);
         b.iter(|| {
-            black_box({
-                Problem::new(ode, bs3, controller).solve();
-            });
+            let mut problem = Problem::new(ode, bs3, controller);
+            black_box(problem.solve());
         });
     });
 
@@ -119,9 +114,8 @@ fn bench_pendulum(c: &mut Criterion) {
         let ode = ODE::new(&derivative, 0.0, 10.0, y0, params);
         let dp45 = DormandPrince45::new().a_tol(tol).r_tol(tol);
         b.iter(|| {
-            black_box({
-                Problem::new(ode, dp45, controller).solve();
-            });
+            let mut problem = Problem::new(ode, dp45, controller);
+            black_box(problem.solve());
         });
     });
 
@@ -160,9 +154,8 @@ fn bench_orbit_6d(c: &mut Criterion) {
         let ode = ODE::new(&derivative, 0.0, 10000.0, y0, params);
         let bs3 = BS3::new().a_tol(tol).r_tol(tol);
         b.iter(|| {
-            black_box({
-                Problem::new(ode, bs3, controller).solve();
-            });
+            let mut problem = Problem::new(ode, bs3, controller);
+            black_box(problem.solve());
         });
     });
 
@@ -170,9 +163,8 @@ fn bench_orbit_6d(c: &mut Criterion) {
         let ode = ODE::new(&derivative, 0.0, 10000.0, y0, params);
         let dp45 = DormandPrince45::new().a_tol(tol).r_tol(tol);
         b.iter(|| {
-            black_box({
-                Problem::new(ode, dp45, controller).solve();
-            });
+            let mut problem = Problem::new(ode, dp45, controller);
+            black_box(problem.solve());
         });
     });
 
@@ -199,12 +191,10 @@ fn bench_interpolation(c: &mut Criterion) {
         let ode = ODE::new(&derivative, 0.0, 5.0, y0, ());
         let bs3 = BS3::new().a_tol(tol).r_tol(tol);
         b.iter(|| {
-            black_box({
-                let mut problem = Problem::new(ode, bs3, controller);
-                let solution = problem.solve();
-                // Interpolate at 100 points
-                let _: Vec<_> = (0..100).map(|i| solution.interpolate(i as f64 * 0.05)).collect();
-            });
+            let mut problem = Problem::new(ode, bs3, controller);
+            let solution = problem.solve();
+            // Interpolate at 100 points
+            black_box((0..100).map(|i| solution.interpolate(i as f64 * 0.05)).collect::<Vec<_>>());
         });
     });
 
@@ -213,12 +203,10 @@ fn bench_interpolation(c: &mut Criterion) {
         let ode = ODE::new(&derivative, 0.0, 5.0, y0, ());
         let dp45 = DormandPrince45::new().a_tol(tol).r_tol(tol);
         b.iter(|| {
-            black_box({
-                let mut problem = Problem::new(ode, dp45, controller);
-                let solution = problem.solve();
-                // Interpolate at 100 points
-                let _: Vec<_> = (0..100).map(|i| solution.interpolate(i as f64 * 0.05)).collect();
-            });
+            let mut problem = Problem::new(ode, dp45, controller);
+            let solution = problem.solve();
+            // Interpolate at 100 points
+            black_box((0..100).map(|i| solution.interpolate(i as f64 * 0.05)).collect::<Vec<_>>());
         });
     });
 
@@ -245,9 +233,8 @@ fn bench_tolerance_scaling(c: &mut Criterion) {
             let ode = ODE::new(&derivative, 0.0, 10.0, y0, ());
             let bs3 = BS3::new().a_tol(tol).r_tol(tol);
             b.iter(|| {
-                black_box({
-                    Problem::new(ode, bs3, controller).solve();
-                });
+                let mut problem = Problem::new(ode, bs3, controller);
+                black_box(problem.solve());
             });
         });
 
@@ -255,9 +242,8 @@ fn bench_tolerance_scaling(c: &mut Criterion) {
             let ode = ODE::new(&derivative, 0.0, 10.0, y0, ());
             let dp45 = DormandPrince45::new().a_tol(tol).r_tol(tol);
             b.iter(|| {
-                black_box({
-                    Problem::new(ode, dp45, controller).solve();
-                });
+                let mut problem = Problem::new(ode, dp45, controller);
+                black_box(problem.solve());
             });
         });
     }

benches/orbit.rs

@@ -29,9 +29,8 @@ fn bench_orbit(c: &mut Criterion) {
 
     c.bench_function("bench_orbit", |b| {
         b.iter(|| {
-            std::hint::black_box({
-                Problem::new(ode, dp45, controller).solve();
-            });
+            let mut problem = Problem::new(ode, dp45, controller);
+            std::hint::black_box(problem.solve());
         });
     });
 }

benches/simple_1d.rs

@@ -20,9 +20,8 @@ fn bench_simple_1d(c: &mut Criterion) {
 
     c.bench_function("bench_simple_1d", |b| {
         b.iter(|| {
-            std::hint::black_box({
-                Problem::new(ode, dp45, controller).solve();
-            });
+            let mut problem = Problem::new(ode, dp45, controller);
+            std::hint::black_box(problem.solve());
         });
     });
 }
@@ -44,11 +43,13 @@ fn bench_interpolation_1d(c: &mut Criterion) {
 
     c.bench_function("bench_interpolation_1d", |b| {
         b.iter(|| {
-            std::hint::black_box({
-                let mut problem = Problem::new(ode, dp45, controller);
-                let solution = problem.solve();
-                let _ = (0..100).map(|t| solution.interpolate(t as f64 * 0.1)[0]);
-            });
+            let mut problem = Problem::new(ode, dp45, controller);
+            let solution = problem.solve();
+            std::hint::black_box(
+                (0..100)
+                    .map(|t| solution.interpolate(t as f64 * 0.1)[0])
+                    .sum::<f64>(),
+            );
         });
     });
 }

benches/vern7_comparison.rs

@@ -28,9 +28,8 @@ fn bench_exponential_tight_tol(c: &mut Criterion) {
         let ode = ODE::new(&derivative, 0.0, 4.0, y0, ());
         let bs3 = BS3::new().a_tol(tol).r_tol(tol);
         b.iter(|| {
-            black_box({
-                Problem::new(ode, bs3, controller).solve();
-            });
+            let mut problem = Problem::new(ode, bs3, controller);
+            black_box(problem.solve());
         });
     });
 
@@ -38,9 +37,8 @@ fn bench_exponential_tight_tol(c: &mut Criterion) {
         let ode = ODE::new(&derivative, 0.0, 4.0, y0, ());
         let dp45 = DormandPrince45::new().a_tol(tol).r_tol(tol);
         b.iter(|| {
-            black_box({
-                Problem::new(ode, dp45, controller).solve();
-            });
+            let mut problem = Problem::new(ode, dp45, controller);
+            black_box(problem.solve());
         });
     });
 
@@ -48,9 +46,8 @@ fn bench_exponential_tight_tol(c: &mut Criterion) {
         let ode = ODE::new(&derivative, 0.0, 4.0, y0, ());
         let vern7 = Vern7::new().a_tol(tol).r_tol(tol);
         b.iter(|| {
-            black_box({
-                Problem::new(ode, vern7, controller).solve();
-            });
+            let mut problem = Problem::new(ode, vern7, controller);
+            black_box(problem.solve());
         });
     });
 
@@ -77,9 +74,8 @@ fn bench_harmonic_oscillator_tight_tol(c: &mut Criterion) {
         let ode = ODE::new(&derivative, 0.0, 20.0, y0, ());
         let bs3 = BS3::new().a_tol(tol).r_tol(tol);
         b.iter(|| {
-            black_box({
-                Problem::new(ode, bs3, controller).solve();
-            });
+            let mut problem = Problem::new(ode, bs3, controller);
+            black_box(problem.solve());
         });
     });
 
@@ -87,9 +83,8 @@ fn bench_harmonic_oscillator_tight_tol(c: &mut Criterion) {
         let ode = ODE::new(&derivative, 0.0, 20.0, y0, ());
         let dp45 = DormandPrince45::new().a_tol(tol).r_tol(tol);
         b.iter(|| {
-            black_box({
-                Problem::new(ode, dp45, controller).solve();
-            });
+            let mut problem = Problem::new(ode, dp45, controller);
+            black_box(problem.solve());
         });
     });
 
@@ -97,9 +92,8 @@ fn bench_harmonic_oscillator_tight_tol(c: &mut Criterion) {
         let ode = ODE::new(&derivative, 0.0, 20.0, y0, ());
         let vern7 = Vern7::new().a_tol(tol).r_tol(tol);
         b.iter(|| {
-            black_box({
-                Problem::new(ode, vern7, controller).solve();
-            });
+            let mut problem = Problem::new(ode, vern7, controller);
+            black_box(problem.solve());
         });
     });
 
@@ -138,9 +132,8 @@ fn bench_orbit_tight_tol(c: &mut Criterion) {
         let ode = ODE::new(&derivative, 0.0, 10000.0, y0, params);
         let dp45 = DormandPrince45::new().a_tol(tol).r_tol(tol);
         b.iter(|| {
-            black_box({
-                Problem::new(ode, dp45, controller).solve();
-            });
+            let mut problem = Problem::new(ode, dp45, controller);
+            black_box(problem.solve());
         });
     });
 
@@ -148,9 +141,8 @@ fn bench_orbit_tight_tol(c: &mut Criterion) {
         let ode = ODE::new(&derivative, 0.0, 10000.0, y0, params);
         let vern7 = Vern7::new().a_tol(tol).r_tol(tol);
         b.iter(|| {
-            black_box({
-                Problem::new(ode, vern7, controller).solve();
-            });
+            let mut problem = Problem::new(ode, vern7, controller);
+            black_box(problem.solve());
         });
     });
 
@@ -175,27 +167,23 @@ fn bench_vern7_interpolation(c: &mut Criterion) {
     // Vern7 with interpolation (should compute extra stages lazily)
     group.bench_function("vern7_with_interpolation", |b| {
         b.iter(|| {
-            black_box({
-                let ode = ODE::new(&derivative, 0.0, 5.0, y0, ());
-                let vern7 = Vern7::new().a_tol(tol).r_tol(tol);
-                let mut problem = Problem::new(ode, vern7, controller);
-                let solution = problem.solve();
-                // Interpolate at 100 points - first one computes extra stages
-                let _: Vec<_> = (0..100).map(|i| solution.interpolate(i as f64 * 0.05)).collect();
-            });
+            let ode = ODE::new(&derivative, 0.0, 5.0, y0, ());
+            let vern7 = Vern7::new().a_tol(tol).r_tol(tol);
+            let mut problem = Problem::new(ode, vern7, controller);
+            let solution = problem.solve();
+            // Interpolate at 100 points - first one computes extra stages
+            black_box((0..100).map(|i| solution.interpolate(i as f64 * 0.05)).collect::<Vec<_>>());
         });
     });
 
     // DP5 with interpolation for comparison
     group.bench_function("dp5_with_interpolation", |b| {
         b.iter(|| {
-            black_box({
-                let ode = ODE::new(&derivative, 0.0, 5.0, y0, ());
-                let dp45 = DormandPrince45::new().a_tol(tol).r_tol(tol);
-                let mut problem = Problem::new(ode, dp45, controller);
-                let solution = problem.solve();
-                let _: Vec<_> = (0..100).map(|i| solution.interpolate(i as f64 * 0.05)).collect();
-            });
+            let ode = ODE::new(&derivative, 0.0, 5.0, y0, ());
+            let dp45 = DormandPrince45::new().a_tol(tol).r_tol(tol);
+            let mut problem = Problem::new(ode, dp45, controller);
+            let solution = problem.solve();
+            black_box((0..100).map(|i| solution.interpolate(i as f64 * 0.05)).collect::<Vec<_>>());
         });
     });
 
@@ -223,9 +211,8 @@ fn bench_tolerance_scaling_vern7(c: &mut Criterion) {
             let ode = ODE::new(&derivative, 0.0, 10.0, y0, ());
             let dp45 = DormandPrince45::new().a_tol(tol).r_tol(tol);
             b.iter(|| {
-                black_box({
-                    Problem::new(ode, dp45, controller).solve();
-                });
+                let mut problem = Problem::new(ode, dp45, controller);
+                black_box(problem.solve());
             });
         });
 
@@ -233,9 +220,8 @@ fn bench_tolerance_scaling_vern7(c: &mut Criterion) {
             let ode = ODE::new(&derivative, 0.0, 10.0, y0, ());
             let vern7 = Vern7::new().a_tol(tol).r_tol(tol);
             b.iter(|| {
-                black_box({
-                    Problem::new(ode, vern7, controller).solve();
-                });
+                let mut problem = Problem::new(ode, vern7, controller);
+                black_box(problem.solve());
             });
         });
     }