mahf 0.1.0

A framework for modular construction and evaluation of metaheuristics.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

//! Recombine multiple solutions (also called crossover).

use crate::{
    component::{AnyComponent, ExecResult},
    population::{IntoIndividuals, IntoSolutions},
    state::random::Random,
    Problem, State,
};

pub mod common;
pub mod de;
pub mod functional;

pub use common::{ArithmeticCrossover, CycleCrossover, NPointCrossover, UniformCrossover};

/// Represents either no, one, or two elements.
pub enum OptionalPair<T> {
    /// No element.
    None,
    /// A single element.
    Single(T),
    /// Two elements.
    Both([T; 2]),
}

impl<T> OptionalPair<T> {
    /// Constructs the optional pair from the array `ts` with `both` deciding if to use both or
    /// only a single element.
    pub fn from_pair(ts: [T; 2], both: bool) -> Self {
        if both {
            Self::Both(ts)
        } else {
            let [t, _] = ts;
            Self::Single(t)
        }
    }
}

/// Trait for representing a component that recombines multiple solutions.
pub trait Recombination<P: Problem>: AnyComponent {
    fn recombine(
        &self,
        parent1: &P::Encoding,
        parent2: &P::Encoding,
        rng: &mut Random,
    ) -> OptionalPair<P::Encoding>;
}

/// A default implementation of [`Component::execute`] for types implementing [`Recombination`].
///
/// [`Component::execute`]: crate::Component::execute
pub fn recombination<P, T>(component: &T, _problem: &P, state: &mut State<P>) -> ExecResult<()>
where
    P: Problem,
    T: Recombination<P>,
{
    let mut populations = state.populations_mut();
    let mut rng = state.random_mut();

    let solutions = populations.pop().into_solutions();
    let mut population = Vec::new();

    for chunk in solutions.chunks(2) {
        match chunk {
            [parent1, parent2] => {
                let children = component.recombine(parent1, parent2, &mut rng);
                match children {
                    OptionalPair::None => {
                        population.push(parent1.clone());
                        population.push(parent2.clone());
                    }
                    OptionalPair::Single(child) => {
                        population.push(child);
                    }
                    OptionalPair::Both([child1, child2]) => {
                        population.push(child1);
                        population.push(child2);
                    }
                }
            }
            [remainder] => population.push(remainder.clone()),
            _ => unreachable!(),
        }
    }

    populations.push(population.into_individuals());
    Ok(())
}