Struct Configuration 

pub struct Configuration<P: Problem>(/* private fields */);

A (meta)heuristic configuration.

A grouping of components is called a metaheuristic configuration, and the Configuration struct provides useful abstractions for dealing with them.

A configuration therefore fully specifies a metaheuristic algorithm, with all its components and parameters.

Application

Applying a Configuration to a problem is as simple as calling its optimize method with the problem and an evaluator as argument. The method returns the State after execution, enabling inspection of any custom state, including the final population, or the best individual found.

It is also possible to pre-initialize the State before execution using the optimize_with method, e.g. to set the random number seed or customize what state should be logged at runtime.

Building Configurations

Because an object-oriented approach to specifying control flow is not very intuitive, Configuration also exposes a simple and idiomatic way to construct metaheuristics through Rust’s builder pattern.

See Configuration::builder for more information.

Serialization

For the purpose of easily identifying which experiment was done with which components and parameters, it is serializable (but not deserializable).

Implementations

impl<P: Problem> Configuration<P>

pub fn new(heuristic: Box<dyn Component<P>>) -> Self

Constructs a Configuration from some heuristic components.

Use Configuration::builder for a more convenient construction.

pub fn builder() -> ConfigurationBuilder<P>

Creates a builder for constructing a Configuration.

The builder exposes familiar control flow methods like do_, while_, if_, and if_else_ along with shortcut methods to construct other often-used components.

Examples

Constructing a simple genetic algorithm using the builder syntax:

use mahf::prelude::*;

let ga = Configuration::builder()
    .do_(initialization::RandomSpread::new(population_size))
    .evaluate()
    .update_best_individual()
    .while_(conditions::LessThanN::iterations(n), |builder| {
        builder
            .do_(selection::Tournament::new(num_selected, size))
            .do_(recombination::ArithmeticCrossover::new_insert_both(1.))
            .do_(mutation::NormalMutation::new(std_dev, rm))
            .evaluate()
            .update_best_individual()
            .do_(replacement::MuPlusLambda::new(max_population_size))
    })
    .build();

pub fn heuristic(&self) -> &dyn Component<P>

Returns a reference to the root Component.

pub fn into_inner(self) -> Box<dyn Component<P>>

Consumes the Configuration, returning the root Component.

pub fn into_builder(self) -> ConfigurationBuilder<P>

Creates a builder pre-initialized with the root Component.

pub fn to_ron(&self, path: impl AsRef<Path>) -> ExecResult<()>

Serializes the Configuration into the file at path using ron.

Examples

use mahf::Configuration;

let config = Configuration::builder()/* ... */.build();
config.to_ron("path/to/ron")?;

pub fn run(&self, problem: &P, state: &mut State<'_, P>) -> ExecResult<()>

Runs the Configuration on the problem using a given State.

Note that the caller is responsible for initializing state properly.

pub fn optimize<'a, T>( &self, problem: &P, evaluator: T, ) -> ExecResult<State<'a, P>>

where T: Evaluate<Problem = P> + 'a,

Runs the heuristic Configuration on the given problem, returning the final State after execution of the heuristic.

Initialization

The state is pre-initialized with Populations and Log.

The random generator defaults to a randomly seeded RNG (Random::default).

The evaluator is inserted wrapped inside an Evaluator with the Global identifier.

For initializing the state with custom state, e.g. a fixed random seed, see optimize_with.

Examples

Optimizing some problem with a sequential evaluator:

use mahf::{problems::Sequential, Configuration};

let config = Configuration::builder()
    /* configuration definition */
    .build();
let state = config.optimize(&problem, Sequential::new());

pub fn optimize_with<'a>( &self, problem: &P, init_state: impl FnOnce(&mut State<'a, P>) -> ExecResult<()>, ) -> ExecResult<State<'a, P>>

Runs the heuristic Configuration on the given problem, initializing the State beforehand with a custom function, returning the final State after execution of the heuristic.

Initialization

The state is pre-initialized with Populations and Log.

If no random generator is inserted in init_state, it will default to a randomly seeded RNG (Random::default).

Note that the evaluator has to be inserted manually into the State, using e.g. {State::insert_evaluator, State::insert_evaluator_as}.

Examples

Optimizing some problem with a sequential evaluator and a random seed of 42:

use mahf::{identifier::Global, problems::Sequential, Configuration, Random};

let config = Configuration::builder()/* ... */.build();
let state = config.optimize_with(&problem, |state| {
    state.insert_evaluator(Sequential::new());
    state.insert(Random::new(42));
    Ok(())
});

Trait Implementations

impl<P: Clone + Problem> Clone for Configuration<P>

fn clone(&self) -> Configuration<P>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<P: Problem> From<Box<dyn Component<P>>> for Configuration<P>

fn from(heuristic: Box<dyn Component<P>>) -> Self

Converts to this type from the input type.