Merge pull request #58 from denehoffman/boxed_update

Remove Clone requirement on generics for algorithms that store a `LineSearch`

Author: denehoffman

.github/workflows/coverage.yml

@@ -14,7 +14,7 @@ jobs:
       - name: Install cargo-llvm-cov
         uses: taiki-e/install-action@cargo-llvm-cov
       - name: Generate code coverage
-        run: cargo llvm-cov --all-features --workspace --lcov --output-path lcov.info
+        run: cargo llvm-cov --workspace --lcov --output-path lcov.info
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v3
         with:

README.md

@@ -74,7 +74,7 @@ use ganesh::algorithms::NelderMead;
 fn main() -> Result<(), Infallible> {
     let problem = Rosenbrock { n: 2 };
     let nm = NelderMead::default();
-    let mut m = Minimizer::new(&nm, 2);
+    let mut m = Minimizer::new(Box::new(nm), 2);
     let x0 = &[2.0, 2.0];
     m.minimize(&problem, x0, &mut ())?;
     println!("{}", m.status);

benches/bfgs_benchmark.rs

@@ -9,7 +9,7 @@ fn bfgs_benchmark(c: &mut Criterion) {
         group.bench_with_input(BenchmarkId::new("Rosenbrock", n), &n, |b, ndim| {
             let problem = Rosenbrock { n: *ndim };
             let nm = BFGS::default();
-            let mut m = Minimizer::new(&nm, *ndim).with_max_steps(10_000_000);
+            let mut m = Minimizer::new(Box::new(nm), *ndim).with_max_steps(10_000_000);
             let x0 = vec![5.0; *ndim];
             b.iter(|| {
                 m.minimize(&problem, &x0, &mut ()).unwrap();

benches/lbfgs_benchmark.rs

@@ -9,7 +9,7 @@ fn lbfgs_benchmark(c: &mut Criterion) {
         group.bench_with_input(BenchmarkId::new("Rosenbrock", n), &n, |b, ndim| {
             let problem = Rosenbrock { n: *ndim };
             let nm = LBFGS::default();
-            let mut m = Minimizer::new(&nm, *ndim).with_max_steps(10_000_000);
+            let mut m = Minimizer::new(Box::new(nm), *ndim).with_max_steps(10_000_000);
             let x0 = vec![5.0; *ndim];
             b.iter(|| {
                 m.minimize(&problem, &x0, &mut ()).unwrap();

benches/lbfgsb_benchmark.rs

@@ -9,7 +9,7 @@ fn lbfgsb_benchmark(c: &mut Criterion) {
         group.bench_with_input(BenchmarkId::new("Rosenbrock", n), &n, |b, ndim| {
             let problem = Rosenbrock { n: *ndim };
             let nm = LBFGSB::default();
-            let mut m = Minimizer::new(&nm, *ndim).with_max_steps(10_000_000);
+            let mut m = Minimizer::new(Box::new(nm), *ndim).with_max_steps(10_000_000);
             let x0 = vec![5.0; *ndim];
             b.iter(|| {
                 m.minimize(&problem, &x0, &mut ()).unwrap();

benches/nelder_mead_benchmark.rs

@@ -9,7 +9,7 @@ fn nelder_mead_benchmark(c: &mut Criterion) {
         group.bench_with_input(BenchmarkId::new("Rosenbrock", n), &n, |b, ndim| {
             let problem = Rosenbrock { n: *ndim };
             let nm = NelderMead::default();
-            let mut m = Minimizer::new(&nm, *ndim).with_max_steps(10_000_000);
+            let mut m = Minimizer::new(Box::new(nm), *ndim).with_max_steps(10_000_000);
             let x0 = vec![5.0; *ndim];
             b.iter(|| {
                 m.minimize(&problem, &x0, &mut ()).unwrap();
@@ -22,7 +22,7 @@ fn nelder_mead_benchmark(c: &mut Criterion) {
             |b, ndim| {
                 let problem = Rosenbrock { n: *ndim };
                 let nm = NelderMead::default().with_adaptive(n);
-                let mut m = Minimizer::new(&nm, *ndim).with_max_steps(10_000_000);
+                let mut m = Minimizer::new(Box::new(nm), *ndim).with_max_steps(10_000_000);
                 let x0 = vec![5.0; *ndim];
                 b.iter(|| {
                     m.minimize(&problem, &x0, &mut ()).unwrap();

examples/multivariate_normal_ess/main.rs

@@ -51,7 +51,7 @@ fn main() -> Result<(), Box<dyn Error>> {
         .build();
 
     // Create a new Sampler
-    let mut s = Sampler::new(&a, x0).with_observer(aco.clone());
+    let mut s = Sampler::new(Box::new(a), x0).with_observer(aco.clone());
 
     // Run a maximum of 1000 steps of the MCMC algorithm
     s.sample(&problem, &mut cov_inv, 1000)?;

src/algorithms/bfgs.rs

@@ -133,11 +133,7 @@ impl<U, E> BFGS<U, E> {
     }
 }
 
-impl<U, E> Algorithm<U, E> for BFGS<U, E>
-where
-    U: Clone,
-    E: Clone,
-{
+impl<U, E> Algorithm<U, E> for BFGS<U, E> {
     fn initialize(
         &mut self,
         func: &dyn Function<U, E>,
@@ -240,7 +236,7 @@ mod tests {
     #[test]
     fn test_bfgs() -> Result<(), Infallible> {
         let algo = BFGS::default();
-        let mut m = Minimizer::new(&algo, 2).with_max_steps(10000);
+        let mut m = Minimizer::new(Box::new(algo), 2).with_max_steps(10000);
         let problem = Rosenbrock { n: 2 };
         m.minimize(&problem, &[-2.0, 2.0], &mut ())?;
         assert!(m.status.converged);

src/algorithms/lbfgs.rs

@@ -154,11 +154,7 @@ impl<U, E> LBFGS<U, E> {
     }
 }
 
-impl<U, E> Algorithm<U, E> for LBFGS<U, E>
-where
-    U: Clone,
-    E: Clone,
-{
+impl<U, E> Algorithm<U, E> for LBFGS<U, E> {
     fn initialize(
         &mut self,
         func: &dyn Function<U, E>,
@@ -267,7 +263,7 @@ mod tests {
     #[test]
     fn test_lbfgs() -> Result<(), Infallible> {
         let algo = LBFGS::default();
-        let mut m = Minimizer::new(&algo, 2);
+        let mut m = Minimizer::new(Box::new(algo), 2);
         let problem = Rosenbrock { n: 2 };
         m.minimize(&problem, &[-2.0, 2.0], &mut ())?;
         assert!(m.status.converged);

src/algorithms/lbfgsb.rs

@@ -349,11 +349,7 @@ impl<U, E> LBFGSB<U, E> {
     }
 }
 
-impl<U, E> Algorithm<U, E> for LBFGSB<U, E>
-where
-    U: Clone,
-    E: Clone,
-{
+impl<U, E> Algorithm<U, E> for LBFGSB<U, E> {
     fn initialize(
         &mut self,
         func: &dyn Function<U, E>,
@@ -495,7 +491,7 @@ mod tests {
     #[test]
     fn test_lbfgsb() -> Result<(), Infallible> {
         let algo = LBFGSB::default();
-        let mut m = Minimizer::new(&algo, 2);
+        let mut m = Minimizer::new(Box::new(algo), 2);
         let problem = Rosenbrock { n: 2 };
         m.minimize(&problem, &[-2.0, 2.0], &mut ())?;
         assert!(m.status.converged);
@@ -521,7 +517,8 @@ mod tests {
     #[test]
     fn test_bounded_lbfgsb() -> Result<(), Infallible> {
         let algo = LBFGSB::default();
-        let mut m = Minimizer::new(&algo, 2).with_bounds(Some(vec![(-4.0, 4.0), (-4.0, 4.0)]));
+        let mut m =
+            Minimizer::new(Box::new(algo), 2).with_bounds(Some(vec![(-4.0, 4.0), (-4.0, 4.0)]));
         let problem = Rosenbrock { n: 2 };
         m.minimize(&problem, &[-2.0, 2.0], &mut ())?;
         assert!(m.status.converged);

src/algorithms/mcmc/mod.rs

@@ -4,7 +4,6 @@ use std::{
     sync::Arc,
 };
 
-use dyn_clone::DynClone;
 use fastrand::Rng;
 use nalgebra::{Complex, DVector};
 use parking_lot::RwLock;
@@ -384,7 +383,7 @@ pub fn integrated_autocorrelation_times(
 /// This trait is implemented for the MCMC algorithms found in the
 /// [`algorithms::mcmc`](crate::algorithms::mcmc) module, and contains
 /// all the methods needed to be run by a [`Sampler`].
-pub trait MCMCAlgorithm<U, E>: DynClone {
+pub trait MCMCAlgorithm<U, E> {
     /// Any setup work done before the main steps of the algorithm should be done here.
     ///
     /// # Errors
@@ -443,7 +442,6 @@ pub trait MCMCAlgorithm<U, E>: DynClone {
         Ok(())
     }
 }
-dyn_clone::clone_trait_object!(<U, E> MCMCAlgorithm<U, E>);
 
 /// A trait which holds a [`callback`](`MCMCObserver::callback`) function that can be used to check an
 /// [`MCMCAlgorithm`]'s [`Ensemble`] during sampling.
@@ -463,22 +461,9 @@ pub struct Sampler<U, E> {
 }
 
 impl<U, E> Sampler<U, E> {
-    /// Creates a new [`Sampler`] with the given [`MCMCAlgorithm`] and `dimension` set to the number
-    /// of free parameters in the minimization problem.
-    pub fn new<M: MCMCAlgorithm<U, E> + 'static>(mcmc: &M, x0: Vec<DVector<Float>>) -> Self {
-        Self {
-            ensemble: Ensemble::new(x0),
-            mcmc_algorithm: Box::new(dyn_clone::clone(mcmc)),
-            bounds: None,
-            observers: Vec::default(),
-        }
-    }
     /// Creates a new [`Sampler`] with the given (boxed) [`MCMCAlgorithm`] and `dimension` set to the number
     /// of free parameters in the minimization problem.
-    pub fn new_from_box(
-        mcmc_algorithm: Box<dyn MCMCAlgorithm<U, E>>,
-        x0: Vec<DVector<Float>>,
-    ) -> Self {
+    pub fn new(mcmc_algorithm: Box<dyn MCMCAlgorithm<U, E>>, x0: Vec<DVector<Float>>) -> Self {
         Self {
             ensemble: Ensemble::new(x0),
             mcmc_algorithm,
@@ -489,14 +474,6 @@ impl<U, E> Sampler<U, E> {
     fn reset(&mut self) {
         self.ensemble.reset();
     }
-    /// Set the [`MCMCAlgorithm`] used by the [`Sampler`].
-    pub fn with_mcmc_algorithm<M: MCMCAlgorithm<U, E> + 'static>(
-        mut self,
-        mcmc_algorithm: &M,
-    ) -> Self {
-        self.mcmc_algorithm = Box::new(dyn_clone::clone(mcmc_algorithm));
-        self
-    }
     /// Adds a single [`MCMCObserver`] to the [`Sampler`].
     pub fn with_observer(mut self, observer: Arc<RwLock<dyn MCMCObserver<U>>>) -> Self {
         self.observers.push(observer);

src/algorithms/nelder_mead.rs

@@ -731,7 +731,7 @@ mod tests {
     #[test]
     fn test_nelder_mead() -> Result<(), Infallible> {
         let algo = NelderMead::default();
-        let mut m = Minimizer::new(&algo, 2);
+        let mut m = Minimizer::new(Box::new(algo), 2);
         let problem = Rosenbrock { n: 2 };
         m.minimize(&problem, &[-2.0, 2.0], &mut ())?;
         assert!(m.status.converged);
@@ -757,7 +757,8 @@ mod tests {
     #[test]
     fn test_bounded_nelder_mead() -> Result<(), Infallible> {
         let algo = NelderMead::default();
-        let mut m = Minimizer::new(&algo, 2).with_bounds(Some(vec![(-4.0, 4.0), (-4.0, 4.0)]));
+        let mut m =
+            Minimizer::new(Box::new(algo), 2).with_bounds(Some(vec![(-4.0, 4.0), (-4.0, 4.0)]));
         let problem = Rosenbrock { n: 2 };
         m.minimize(&problem, &[-2.0, 2.0], &mut ())?;
         assert!(m.status.converged);
@@ -783,7 +784,7 @@ mod tests {
     #[test]
     fn test_adaptive_nelder_mead() -> Result<(), Infallible> {
         let algo = NelderMead::default().with_adaptive(2);
-        let mut m = Minimizer::new(&algo, 2);
+        let mut m = Minimizer::new(Box::new(algo), 2);
         let problem = Rosenbrock { n: 2 };
         m.minimize(&problem, &[-2.0, 2.0], &mut ())?;
         assert!(m.status.converged);

src/lib.rs

@@ -60,7 +60,7 @@
 //! fn main() -> Result<(), Infallible> {
 //!     let problem = Rosenbrock { n: 2 };
 //!     let nm = NelderMead::default();
-//!     let mut m = Minimizer::new(&nm, 2);
+//!     let mut m = Minimizer::new(Box::new(nm), 2);
 //!     let x0 = &[2.0, 2.0];
 //!     m.minimize(&problem, x0, &mut ())?;
 //!     println!("{}", m.status);
@@ -183,7 +183,6 @@ use std::{
     },
 };
 
-use dyn_clone::DynClone;
 use fastrand::Rng;
 use fastrand_contrib::RngExt;
 use lazy_static::lazy_static;
@@ -733,7 +732,7 @@ impl Display for Status {
 ///
 /// This trait is implemented for the algorithms found in the [`algorithms`] module, and contains
 /// all the methods needed to be run by a [`Minimizer`].
-pub trait Algorithm<U, E>: DynClone {
+pub trait Algorithm<U, E> {
     /// Any setup work done before the main steps of the algorithm should be done here.
     ///
     /// # Errors
@@ -795,7 +794,6 @@ pub trait Algorithm<U, E>: DynClone {
         Ok(())
     }
 }
-dyn_clone::clone_trait_object!(<U, E> Algorithm<U, E>);
 
 /// A trait which holds a [`callback`](`Observer::callback`) function that can be used to check an
 /// [`Algorithm`]'s [`Status`] during a minimization.
@@ -824,21 +822,9 @@ impl<U, E> Display for Minimizer<U, E> {
 
 impl<U, E> Minimizer<U, E> {
     const DEFAULT_MAX_STEPS: usize = 4000;
-    /// Creates a new [`Minimizer`] with the given [`Algorithm`] and `dimension` set to the number
-    /// of free parameters in the minimization problem.
-    pub fn new<A: Algorithm<U, E> + 'static>(algorithm: &A, dimension: usize) -> Self {
-        Self {
-            status: Status::default(),
-            algorithm: Box::new(dyn_clone::clone(algorithm)),
-            bounds: None,
-            max_steps: Self::DEFAULT_MAX_STEPS,
-            observers: Vec::default(),
-            dimension,
-        }
-    }
     /// Creates a new [`Minimizer`] with the given (boxed) [`Algorithm`] and `dimension` set to the number
     /// of free parameters in the minimization problem.
-    pub fn new_from_box(algorithm: Box<dyn Algorithm<U, E>>, dimension: usize) -> Self {
+    pub fn new(algorithm: Box<dyn Algorithm<U, E>>, dimension: usize) -> Self {
         Self {
             status: Status::default(),
             algorithm,
@@ -855,11 +841,6 @@ impl<U, E> Minimizer<U, E> {
         };
         self.status = new_status;
     }
-    /// Set the [`Algorithm`] used by the [`Minimizer`].
-    pub fn with_algorithm<A: Algorithm<U, E> + 'static>(mut self, algorithm: &A) -> Self {
-        self.algorithm = Box::new(dyn_clone::clone(algorithm));
-        self
-    }
     /// Set the maximum number of steps to perform before failure (default: 4000).
     pub const fn with_max_steps(mut self, max_steps: usize) -> Self {
         self.max_steps = max_steps;
@@ -998,14 +979,13 @@ impl<U, E> Minimizer<U, E> {
 mod tests {
     use std::convert::Infallible;
 
-    use crate::{algorithms::LBFGSB, Algorithm, Minimizer};
+    use crate::{algorithms::LBFGSB, Minimizer};
 
     #[test]
     #[allow(unused_variables)]
-    fn test_minimizer_constructors() {
+    fn test_minimizer_constructor() {
+        #[allow(clippy::box_default)]
         let algo: LBFGSB<(), Infallible> = LBFGSB::default();
-        let minimizer = Minimizer::new(&algo, 5);
-        let algo_boxed: Box<dyn Algorithm<(), Infallible>> = Box::new(algo);
-        let minimizer_from_box = Minimizer::new_from_box(algo_boxed, 5);
+        let minimizer = Minimizer::new(Box::new(algo), 5);
     }
 }

src/observers.rs

@@ -22,7 +22,7 @@ use crate::{
 /// let problem = Rosenbrock { n: 2 };
 /// let nm = NelderMead::default();
 /// let obs = DebugObserver::build();
-/// let mut m = Minimizer::new(&nm, 2).with_observer(obs);
+/// let mut m = Minimizer::new(Box::new(nm), 2).with_observer(obs);
 /// m.minimize(&problem, &[2.3, 3.4], &mut ()).unwrap();
 /// // ^ This will print debug messages for each step
 /// assert!(m.status.converged);
@@ -60,7 +60,7 @@ impl<U: Debug> Observer<U> for DebugObserver {
 /// let x0 = (0..5).map(|_| DVector::from_fn(2, |_, _| rng.normal(1.0, 4.0))).collect();
 /// let ess = ESS::new([ESSMove::gaussian(0.1), ESSMove::differential(0.9)], rng);
 /// let obs = DebugMCMCObserver::build();
-/// let mut sampler = Sampler::new(&ess, x0).with_observer(obs);
+/// let mut sampler = Sampler::new(Box::new(ess), x0).with_observer(obs);
 /// sampler.sample(&problem, &mut (), 10).unwrap();
 /// // ^ This will print debug messages for each step
 /// assert!(sampler.ensemble.dimension() == (5, 10, 2));
@@ -103,7 +103,7 @@ impl<U: Debug> MCMCObserver<U> for DebugMCMCObserver {
 /// let x0 = (0..5).map(|_| DVector::from_fn(2, |_, _| rng.normal(1.0, 4.0))).collect();
 /// let ess = ESS::new([ESSMove::gaussian(0.1), ESSMove::differential(0.9)], rng);
 /// let obs = AutocorrelationObserver::default().with_n_check(20).build();
-/// let mut sampler = Sampler::new(&ess, x0).with_observer(obs);
+/// let mut sampler = Sampler::new(Box::new(ess), x0).with_observer(obs);
 /// sampler.sample(&problem, &mut (), 100).unwrap();
 /// // ^ This will print autocorrelation messages for every 20 steps
 /// assert!(sampler.ensemble.dimension() == (5, 100, 2));