rustfmt

Author: msarehn

src/lib.rs

@@ -126,10 +126,10 @@ pub use crate::mode::Mode;
 pub use crate::objective_function::{ObjectiveFunction, ParallelObjectiveFunction};
 pub use crate::options::CMAESOptions;
 pub use crate::parameters::Weights;
-pub use crate::sampling::Constraints;
-pub use crate::sampling::Bounds;
 #[cfg(feature = "plotters")]
 pub use crate::plotting::PlotOptions;
+pub use crate::sampling::Bounds;
+pub use crate::sampling::Constraints;
 pub use crate::termination::TerminationReason;
 
 use std::f64;

src/options.rs

@@ -200,7 +200,7 @@ impl CMAESOptions {
     /// Changes the bounds from the defalt value. Vector length must match the number of dimensions.
     /// Convenience method for constraints().
     pub fn bounds(mut self, lower: Vec<f64>, upper: Vec<f64>) -> Self {
-        self.constraints = Some(Box::new(Bounds{lower, upper}));
+        self.constraints = Some(Box::new(Bounds { lower, upper }));
         self
     }
 

src/restart/mod.rs

@@ -317,7 +317,9 @@ impl Restarter {
             let seed = self.rng.gen();
 
             // Apply default configuration (may be overridden by individual restart strategies)
-            let mut options = self.default_options.clone()
+            let mut options = self
+                .default_options
+                .clone()
                 .initial_mean(initial_mean)
                 .mode(self.mode)
                 .parallel_update(self.parallel_update)

src/restart/options.rs

@@ -4,8 +4,7 @@
 use std::ops::RangeInclusive;
 use std::time::Duration;
 
-
-use super::{DEFAULT_INITIAL_STEP_SIZE, RestartStrategy, Restarter};
+use super::{RestartStrategy, Restarter, DEFAULT_INITIAL_STEP_SIZE};
 use crate::{CMAESOptions, Mode};
 
 /// Represents invalid options for a `Restarter`.

src/sampling.rs

@@ -11,7 +11,7 @@ use crate::mode::Mode;
 use crate::state::State;
 use crate::{ObjectiveFunction, ParallelObjectiveFunction};
 
-pub trait Constraints : Sync + std::fmt::Debug {
+pub trait Constraints: Sync + std::fmt::Debug {
     fn meets_constraints(&self, x: &DVector<f64>) -> bool;
     fn clone_box(&self) -> Box<dyn Constraints>;
 }
@@ -58,7 +58,14 @@ pub struct Sampler<F> {
 }
 
 impl<F> Sampler<F> {
-    pub fn new(dim: usize, constraints: Option<Box<dyn Constraints>>, max_resamples: Option<usize>, population_size: usize, objective_function: F, rng_seed: u64) -> Self {
+    pub fn new(
+        dim: usize,
+        constraints: Option<Box<dyn Constraints>>,
+        max_resamples: Option<usize>,
+        population_size: usize,
+        objective_function: F,
+        rng_seed: u64,
+    ) -> Self {
         Self {
             dim,
             constraints,
@@ -102,11 +109,17 @@ impl<F> Sampler<F> {
                     };
 
                     if parallel_update {
-                        z.into_par_iter().map(transform).filter(ok_constraints).collect()
+                        z.into_par_iter()
+                            .map(transform)
+                            .filter(ok_constraints)
+                            .collect()
                     } else {
-                        z.into_iter().map(transform).filter(ok_constraints).collect()
+                        z.into_iter()
+                            .map(transform)
+                            .filter(ok_constraints)
+                            .collect()
                     }
-                },
+                }
                 None => {
                     if parallel_update {
                         z.into_par_iter().map(transform).collect()
@@ -139,7 +152,6 @@ impl<F> Sampler<F> {
             i += 1;
         }
 
-
         let mut points = evaluate_points(y, &mut self.objective_function)?;
 
         self.function_evals += points.len();
@@ -285,7 +297,14 @@ mod tests {
     fn test_sample() {
         let dim = 10;
         let population_size = 12;
-        let mut sampler = Sampler::new(dim, None, None, population_size, Box::new(|_: &DVector<f64>| 0.0), 1);
+        let mut sampler = Sampler::new(
+            dim,
+            None,
+            None,
+            population_size,
+            Box::new(|_: &DVector<f64>| 0.0),
+            1,
+        );
         let state = State::new(vec![0.0; dim].into(), 2.0);
 
         let n = 5;
@@ -323,17 +342,33 @@ mod tests {
 
         // No resampling: Value should be out-of-bounds
         {
-            let mut sampler = Sampler::new(dim, Some(Box::new(bounds.clone())), Some(0), population_size, objective_function, 1);
+            let mut sampler = Sampler::new(
+                dim,
+                Some(Box::new(bounds.clone())),
+                Some(0),
+                population_size,
+                objective_function,
+                1,
+            );
             let state = State::new(vec![0.0; dim].into(), 2.0);
             let individuals = sampler.sample(&state, Mode::Minimize, false).unwrap();
 
-            assert!(   individuals[0].point[0] < bounds.lower[0]
-                    || individuals[0].point[0] > bounds.upper[0]);
+            assert!(
+                individuals[0].point[0] < bounds.lower[0]
+                    || individuals[0].point[0] > bounds.upper[0]
+            );
         }
 
         // With limited resampling: Value should be in bounds
         {
-            let mut sampler = Sampler::new(dim, Some(Box::new(bounds.clone())), Some(10), population_size, objective_function, 1);
+            let mut sampler = Sampler::new(
+                dim,
+                Some(Box::new(bounds.clone())),
+                Some(10),
+                population_size,
+                objective_function,
+                1,
+            );
             let state = State::new(vec![0.0; dim].into(), 2.0);
             let individuals = sampler.sample(&state, Mode::Minimize, false).unwrap();
 
@@ -343,7 +378,14 @@ mod tests {
 
         // With unlimited resampling: Value should be in bounds
         {
-            let mut sampler = Sampler::new(dim, Some(Box::new(bounds.clone())), None, population_size, objective_function, 1);
+            let mut sampler = Sampler::new(
+                dim,
+                Some(Box::new(bounds.clone())),
+                None,
+                population_size,
+                objective_function,
+                1,
+            );
             let state = State::new(vec![0.0; dim].into(), 2.0);
             let individuals = sampler.sample(&state, Mode::Minimize, false).unwrap();