fixup: Generalize Bounds as Constraints (3/?)

Author: msarehn

src/lib.rs

@@ -126,6 +126,7 @@ 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;
@@ -252,7 +253,7 @@ impl<F> CMAES<F> {
         // Initialize point sampler
         let sampler = Sampler::new(
             dimensions,
-            options.bounds,
+            options.constraints,
             options.max_resamples,
             options.population_size,
             objective_function,

src/options.rs

@@ -7,6 +7,7 @@ use std::time::Duration;
 use crate::mode::Mode;
 use crate::parameters::Weights;
 use crate::sampling::Bounds;
+use crate::sampling::Constraints;
 #[cfg(feature = "plotters")]
 use crate::PlotOptions;
 use crate::CMAES;
@@ -53,9 +54,9 @@ pub struct CMAESOptions {
     /// [`BIPOP`][crate::restart::BIPOP] restart strategies (see the [`restart`][crate::restart]
     /// module).
     pub population_size: usize,
-    /// The bounds within which to search. Resamples until all samples are in bounds or
+    /// The constraints for the search. Resamples until all samples satisfy the constraints or
     /// `max_resamples` are hit. Default value is `None`.
-    pub bounds: Option<Bounds>,
+    pub constraints: Option<Box<dyn Constraints>>,
     /// How many times to resample points in order to stay inside `bounds`.
     /// `None` disables the limit. Defaults to 10.
     pub max_resamples: Option<usize>,
@@ -149,7 +150,7 @@ impl CMAESOptions {
             initial_mean,
             initial_step_size,
             population_size: 4 + (3.0 * (dimensions as f64).ln()).floor() as usize,
-            bounds: None,
+            constraints: None,
             max_resamples: Some(10),
             weights: Weights::Negative,
             parallel_update: false,
@@ -197,8 +198,15 @@ 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.bounds = Some(Bounds{lower, upper});
+        self.constraints = Some(Box::new(Bounds{lower, upper}));
+        self
+    }
+
+    /// Changes the constraints from the defalt value.
+    pub fn constraints(mut self, constraints: Box<dyn Constraints>) -> Self {
+        self.constraints = Some(constraints);
         self
     }
 

src/sampling.rs

@@ -11,8 +11,15 @@ use crate::mode::Mode;
 use crate::state::State;
 use crate::{ObjectiveFunction, ParallelObjectiveFunction};
 
-pub trait Constraints : Sync {
+pub trait Constraints : Sync + std::fmt::Debug {
     fn meets_constraints(&self, x: &DVector<f64>) -> bool;
+    fn clone_box(&self) -> Box<dyn Constraints>;
+}
+
+impl Clone for Box<dyn Constraints> {
+    fn clone(&self) -> Box<dyn Constraints> {
+        self.clone_box()
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -25,16 +32,20 @@ impl Constraints for Bounds {
     fn meets_constraints(&self, x: &DVector<f64>) -> bool {
         (0..x.len()).all(|i| x[i] >= self.lower[i] && x[i] <= self.upper[i])
     }
+
+    fn clone_box(&self) -> Box<dyn Constraints> {
+        Box::new(self.clone())
+    }
 }
 
 /// A type for sampling and evaluating points from the distribution for each generation
 pub struct Sampler<F> {
     /// Number of dimensions to sample from
     dim: usize,
-    /// If set, resamples until all points are within bounds
+    /// If set, resamples until all points satisfy the constraints
     constraints: Option<Box<dyn Constraints>>,
     /// The maximum number of resamples.
-    /// If this limit is hit, uses points even if they are outside the bounds
+    /// If this limit is hit, uses points even if they violate the constraints
     max_resamples: Option<usize>,
     /// Number of points to sample each generation
     population_size: usize,
@@ -47,10 +58,10 @@ pub struct Sampler<F> {
 }
 
 impl<F> Sampler<F> {
-    pub fn new(dim: usize, bounds: 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: bounds,
+            constraints,
             max_resamples,
             population_size,
             rng: ChaCha12Rng::seed_from_u64(rng_seed),
@@ -85,15 +96,15 @@ impl<F> Sampler<F> {
 
             match constraints {
                 Some(constraints) => {
-                    let in_bounds = |yk: &DVector<f64>| {
+                    let ok_constraints = |yk: &DVector<f64>| {
                         let point = to_point(&yk, state.mean(), state.sigma());
                         constraints.meets_constraints(&point)
                     };
 
                     if parallel_update {
-                        z.into_par_iter().map(transform).filter(in_bounds).collect()
+                        z.into_par_iter().map(transform).filter(ok_constraints).collect()
                     } else {
-                        z.into_iter().map(transform).filter(in_bounds).collect()
+                        z.into_iter().map(transform).filter(ok_constraints).collect()
                     }
                 },
                 None => {
@@ -115,14 +126,14 @@ impl<F> Sampler<F> {
                 break;
             }
 
-            let mut bounds = self.constraints.as_ref().map(|x| x.as_ref());
+            let mut constraints = self.constraints.as_ref().map(|x| x.as_ref());
             if let Some(max) = self.max_resamples {
                 if i >= max {
-                    bounds = None;
+                    constraints = None;
                 }
             }
 
-            let mut new_samps: Vec<_> = sample(remain, bounds);
+            let mut new_samps: Vec<_> = sample(remain, constraints);
             y.append(&mut new_samps);
 
             i += 1;