Make heuristics usable as components

examples/bmf.rs

@@ -1,19 +1,30 @@
-use mahf::heuristics::pso;
-use mahf::{framework, problems::bmf::BenchmarkFunction};
+use mahf::prelude::*;
+
+type P = problems::bmf::BenchmarkFunction;
 
 fn main() -> anyhow::Result<()> {
-    let problem = BenchmarkFunction::sphere(30);
-    let config = pso::pso(100, 1., 1., 1., 1., 500);
+    let problem = P::sphere(30);
+    let config = pso::real_pso(
+        pso::RealProblemParameters {
+            num_particles: 100,
+            a: 1.0,
+            b: 1.0,
+            c: 1.0,
+            v_max: 1.0,
+        },
+        termination::FixedIterations::new(500),
+        tracking::Logger::default(),
+    );
 
     let state = framework::run(&problem, &config, None);
 
     println!(
         "Found Fitness: {:?}",
-        state.best_objective_value::<BenchmarkFunction>().unwrap(),
+        state.best_objective_value::<P>().unwrap()
     );
     println!(
         "Found Individual: {:?}",
-        state.best_individual::<BenchmarkFunction>().unwrap(),
+        state.best_individual::<P>().unwrap(),
     );
     println!("Global Optimum: {}", problem.known_optimum());
 

examples/coco.rs

@@ -1,14 +1,11 @@
-use mahf::{
-    heuristics::iwo,
-    operators::termination,
-    problems::coco_bound::{suits, CocoInstance},
-    tracking::{self, trigger, LogSet},
-};
+use mahf::prelude::*;
+use problems::coco_bound::{suits, CocoInstance};
+use tracking::{functions, trigger};
 
 fn main() -> anyhow::Result<()> {
     let output = "data/coco/iwo";
-    let config = iwo::iwo(
-        iwo::Parameters {
+    let config = iwo::real_iwo(
+        iwo::RealProblemParameters {
             initial_population_size: 5,
             max_population_size: 20,
             min_number_of_seeds: 0,
@@ -21,9 +18,9 @@ fn main() -> anyhow::Result<()> {
         tracking::Logger::builder()
             .log_common_sets()
             .log_set(
-                LogSet::new()
+                tracking::LogSet::new()
                     .with_trigger(trigger::Iteration::new(50))
-                    .with_logger(tracking::functions::best_individual::<CocoInstance>),
+                    .with_logger(functions::best_individual::<CocoInstance>),
             )
             .build(),
     );

examples/tsp.rs

@@ -1,19 +1,28 @@
-use mahf::heuristics::aco;
-use mahf::{framework, problems};
+use mahf::prelude::*;
+
+type P = problems::tsp::SymmetricTsp;
 
 fn main() -> anyhow::Result<()> {
     let problem = problems::tsp::Instances::BERLIN52.load();
-    let tau0 = 1. / problem.best_fitness().unwrap();
-    let config = aco::min_max_ant_system(20, 1., 1., tau0, 0.1, 1., 0.1, 500);
 
-    let state = framework::run(&problem, &config, None);
+    let config = ils::permutation_iterated_local_search(
+        ils::PermutationProblemParameters {
+            local_search_params: ls::PermutationProblemParameters {
+                n_neighbors: 100,
+                pm: 0.9,
+                n_swap: 10,
+            },
+            local_search_termination: termination::FixedIterations::new(100),
+        },
+        termination::FixedIterations::new(10),
+        tracking::Logger::default(),
+    )
+    .into_builder()
+    .assert(|state| state.population_stack::<P>().current().len() == 1)
+    .single_objective_summary()
+    .build();
 
-    println!(
-        "Found Solution: {:?}",
-        state
-            .best_objective_value::<problems::tsp::SymmetricTsp>()
-            .unwrap()
-    );
+    framework::run(&problem, &config, None);
 
     Ok(())
 }

param-study/src/instances/iwo.rs

@@ -31,8 +31,8 @@ pub fn run(setup: &Setup, args: &mut ArgsIter) {
 
     let problem = BenchmarkFunction::try_from(setup.instance.as_str()).unwrap();
 
-    let config = iwo::iwo(
-        iwo::Parameters {
+    let config = iwo::real_iwo(
+        iwo::RealProblemParameters {
             initial_population_size: params.initial_population_size,
             max_population_size: params.max_population_size,
             min_number_of_seeds: params.min_number_of_seeds,

param-study/src/instances/pso.rs

@@ -4,7 +4,9 @@ use mahf::{
     float_eq::float_eq,
     framework::{self, Random},
     heuristics::pso,
+    operators::termination,
     problems::bmf::BenchmarkFunction,
+    tracking,
 };
 
 use crate::{
@@ -25,13 +27,16 @@ pub fn run(setup: &Setup, args: &mut ArgsIter) {
 
     let problem = BenchmarkFunction::try_from(setup.instance.as_str()).unwrap();
 
-    let config = pso::pso(
-        params.population_size,
-        params.a,
-        params.b,
-        params.c,
-        params.v_max,
-        setup.cutoff_length,
+    let config = pso::real_pso(
+        pso::RealProblemParameters {
+            num_particles: params.population_size,
+            a: params.a,
+            b: params.b,
+            c: params.c,
+            v_max: params.v_max,
+        },
+        termination::FixedIterations::new(setup.cutoff_length),
+        tracking::Logger::default(),
     );
 
     let rng = Random::seeded(setup.seed);

src/framework/configuration.rs

@@ -2,8 +2,10 @@ use crate::{
     framework::{
         components::{Block, Branch, Component, Loop, Scope},
         conditions::Condition,
+        state,
     },
-    problems::Problem,
+    operators,
+    problems::{MultiObjectiveProblem, Problem, SingleObjectiveProblem},
 };
 
 pub struct Configuration<P: Problem>(Box<dyn Component<P>>);
@@ -20,6 +22,14 @@ impl<P: Problem> Configuration<P> {
     pub fn heuristic(&self) -> &dyn Component<P> {
         self.0.as_ref()
     }
+
+    pub fn into_inner(self) -> Box<dyn Component<P>> {
+        self.0
+    }
+
+    pub fn into_builder(self) -> ConfigurationBuilder<P> {
+        ConfigurationBuilder::new().do_(self.0)
+    }
 }
 
 impl<P: Problem> From<Configuration<P>> for Box<dyn Component<P>> {
@@ -32,6 +42,7 @@ pub struct ConfigurationBuilder<P: Problem> {
     components: Vec<Box<dyn Component<P>>>,
 }
 
+// Basic functionality
 impl<P: Problem> ConfigurationBuilder<P> {
     fn new() -> Self {
         Self {
@@ -44,6 +55,14 @@ impl<P: Problem> ConfigurationBuilder<P> {
         self
     }
 
+    pub fn do_optional_(self, component: Option<Box<dyn Component<P>>>) -> Self {
+        if let Some(component) = component {
+            self.do_(component)
+        } else {
+            self
+        }
+    }
+
     pub fn while_(
         self,
         condition: Box<dyn Condition<P>>,
@@ -88,4 +107,49 @@ impl<P: Problem> ConfigurationBuilder<P> {
     pub fn build(self) -> Configuration<P> {
         Configuration::new(Block::new(self.components))
     }
+
+    pub fn build_component(self) -> Box<dyn Component<P>> {
+        Block::new(self.components)
+    }
+}
+
+// Convenience methods
+impl<P: Problem> ConfigurationBuilder<P> {
+    /// Asserts the condition on [State][state::State].
+    ///
+    /// Uses the [Debug][operators::misc::Debug] component internally.
+    #[track_caller]
+    pub fn assert(self, assert: impl Fn(&state::State) -> bool + Send + Sync + 'static) -> Self {
+        self.debug(move |_problem, state| assert!(assert(state)))
+    }
+
+    /// Constructs a [Debug][operators::misc::Debug] component with the given behaviour.
+    pub fn debug(self, behaviour: impl Fn(&P, &mut state::State) + Send + Sync + 'static) -> Self {
+        self.do_(operators::misc::Debug::new(behaviour))
+    }
+
+    pub fn evaluate_sequential(self) -> Self {
+        self.do_(operators::evaluation::SequentialEvaluator::new())
+    }
+}
+
+impl<P: SingleObjectiveProblem> ConfigurationBuilder<P> {
+    pub fn update_best_individual(self) -> Self {
+        self.do_(operators::evaluation::UpdateBestIndividual::new())
+    }
+}
+
+impl<P: SingleObjectiveProblem> ConfigurationBuilder<P>
+where
+    P::Encoding: std::fmt::Debug,
+{
+    pub fn single_objective_summary(self) -> Self {
+        self.do_(operators::misc::PrintSingleObjectiveSummary::new())
+    }
+}
+
+impl<P: MultiObjectiveProblem> ConfigurationBuilder<P> {
+    pub fn update_pareto_front(self) -> Self {
+        self.do_(operators::evaluation::UpdateParetoFront::new())
+    }
 }