feat: change functions to references to avoid cloning any underlying function data

Author: denehoffman

benches/rosenbrock_benchmark.rs

@@ -9,15 +9,15 @@ fn rosenbrock_benchmark(c: &mut Criterion) {
             let x0 = vec![5.0; *ndim];
             b.iter(|| {
                 let rb = Rosenbrock { n };
-                let mut m = NelderMead::new(rb, &x0, Some(NelderMeadOptions::builder().build()));
+                let mut m = NelderMead::new(&rb, &x0, Some(NelderMeadOptions::builder().build()));
                 minimize!(m, 1000000).unwrap();
             });
         });
         group.bench_with_input(BenchmarkId::new("Adaptive", n), &n, |b, ndim| {
             let x0 = vec![5.0; *ndim];
             b.iter(|| {
                 let rb = Rosenbrock { n };
-                let mut m = NelderMead::new(rb, &x0, Some(NelderMeadOptions::adaptive(n).build()));
+                let mut m = NelderMead::new(&rb, &x0, Some(NelderMeadOptions::adaptive(n).build()));
                 minimize!(m, 1000000).unwrap();
             });
         });

src/algorithms/gradient_descent.rs

@@ -27,11 +27,11 @@ pub struct GradientDescentOptions<F: Field> {
 ///
 /// This method will terminate if $`|f(\vec{x}_{i}) - f(\vec{x}_{i-1})|`$ is smaller than
 /// [`GradientDescentOptions::tolerance`].
-pub struct GradientDescent<F, A, E>
+pub struct GradientDescent<'f, F, A, E>
 where
     F: Field,
 {
-    function: Box<dyn Function<F, A, E>>,
+    function: &'f dyn Function<F, A, E>,
     options: GradientDescentOptions<F>,
     x: Vec<F>,
     fx: F,
@@ -40,19 +40,19 @@ where
     fx_best: F,
     current_step: usize,
 }
-impl<F, A, E> GradientDescent<F, A, E>
+impl<'f, F, A, E> GradientDescent<'f, F, A, E>
 where
     F: Field,
 {
     /// Create a new Gradient Descent optimizer from a struct which implements [`Function`], an initial
     /// starting point `x0`, and some options.
     pub fn new<Func: Function<F, A, E> + 'static>(
-        function: Func,
+        function: &'f Func,
         x0: &[F],
         options: Option<GradientDescentOptions<F>>,
     ) -> Self {
         Self {
-            function: Box::new(function),
+            function,
             options: options.unwrap_or_else(|| GradientDescentOptions::builder().build()),
             x: x0.to_vec(),
             fx: F::NAN,
@@ -64,7 +64,7 @@ where
     }
 }
 
-impl<F, A, E> Minimizer<F, A, E> for GradientDescent<F, A, E>
+impl<'f, F, A, E> Minimizer<F, A, E> for GradientDescent<'f, F, A, E>
 where
     F: Field,
 {

src/algorithms/nelder_mead.rs

@@ -100,11 +100,11 @@ impl<F: Field> NelderMeadOptions<F> {
 /// See [`NelderMeadOptions`] to set the values of $`\alpha`$, $`\gamma`$, $`\rho_i`$, $`\rho_o`$,
 /// and $`\sigma`$.
 ///
-pub struct NelderMead<F, A, E>
+pub struct NelderMead<'f, F, A, E>
 where
     F: Field,
 {
-    function: Box<dyn Function<F, A, E>>,
+    function: &'f dyn Function<F, A, E>,
     options: NelderMeadOptions<F>,
     simplex_x: Vec<Vec<F>>,
     simplex_fx: Vec<F>,
@@ -116,22 +116,22 @@ where
     n_simplex: usize,
     current_step: usize,
 }
-impl<F, A, E> NelderMead<F, A, E>
+impl<'f, F, A, E> NelderMead<'f, F, A, E>
 where
     F: Field,
 {
     /// Create a new Nelder-Mead optimizer from a struct which implements [`Function`], an initial
     /// starting point `x0`, and some options.
     pub fn new<Func: Function<F, A, E> + 'static>(
-        function: Func,
+        function: &'f Func,
         x0: &[F],
         options: Option<NelderMeadOptions<F>>,
     ) -> Self {
         let n_simplex = x0.len() + 1;
         let options = options.unwrap_or_else(|| NelderMeadOptions::builder().build());
         let simplex_size = options.simplex_size;
         Self {
-            function: Box::new(function),
+            function,
             options,
             simplex_x: Self::construct_simplex(x0, n_simplex, simplex_size),
             simplex_fx: vec![F::NAN; n_simplex],
@@ -267,7 +267,7 @@ pub struct NelderMeadMessage<F> {
     pub sstd: F,
 }
 
-impl<F, A, E> Minimizer<F, A, E> for NelderMead<F, A, E>
+impl<'f, F, A, E> Minimizer<F, A, E> for NelderMead<'f, F, A, E>
 where
     F: Field,
 {

src/algorithms/newton.rs

@@ -31,11 +31,11 @@ pub struct NewtonOptions<F: Field> {
 ///
 /// This method will terminate if either [`NewtonOptions::max_iters`] steps are performed or if
 /// $`|f(\vec{x}_{i}) - f(\vec{x}_{i-1})|`$ is smaller than [`NewtonOptions::tolerance`].
-pub struct Newton<F, A, E>
+pub struct Newton<'f, F, A, E>
 where
     F: Field,
 {
-    function: Box<dyn Function<F, A, E>>,
+    function: &'f dyn Function<F, A, E>,
     options: NewtonOptions<F>,
     x: Vec<F>,
     fx: F,
@@ -45,19 +45,19 @@ where
     current_step: usize,
     singular_hessian: bool,
 }
-impl<F, A, E> Newton<F, A, E>
+impl<'f, F, A, E> Newton<'f, F, A, E>
 where
     F: Field,
 {
     /// Create a new Newton optimizer from a struct which implements [`Function`], an initial
     /// starting point `x0`, and some options.
     pub fn new<Func: Function<F, A, E> + 'static>(
-        function: Func,
+        function: &'f Func,
         x0: &[F],
         options: Option<NewtonOptions<F>>,
     ) -> Self {
         Self {
-            function: Box::new(function),
+            function,
             options: options.unwrap_or_else(|| NewtonOptions::builder().build()),
             x: x0.to_vec(),
             fx: F::NAN,
@@ -70,7 +70,7 @@ where
     }
 }
 
-impl<F, A, E> Minimizer<F, A, E> for Newton<F, A, E>
+impl<'f, F, A, E> Minimizer<F, A, E> for Newton<'f, F, A, E>
 where
     F: Field,
 {