evolve 0.4.0

A generic, composable genetic algorithm framework for Rust
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

//! Termination conditions for the algorithm.
//!
//! Defines the [`TerminationCondition`] trait and provides [`MaxGenerations`],
//! which stops the algorithm after a set number of generations.

use crate::core::state::State;

/// Determines when the algorithm should stop running.
///
/// # Examples
///
/// ```
/// use evolve::core::{population::Population, state::State};
/// use evolve::termination::{MaxGenerations, TerminationCondition};
///
/// let tc = MaxGenerations::new(100);
/// let state = State::<(), ()>::new(Population::new(), 99);
/// assert!(!tc.should_terminate(&state));
///
/// let state = State::<(), ()>::new(Population::new(), 100);
/// assert!(tc.should_terminate(&state));
/// ```
pub trait TerminationCondition<G, F> {
    /// Returns `true` if the algorithm should stop.
    fn should_terminate(&self, state: &State<G, F>) -> bool;
}

/// Terminates the algorithm once the generation count reaches the given limit.
#[derive(Debug, Clone, Copy)]
pub struct MaxGenerations(usize);

impl MaxGenerations {
    /// Creates a new `MaxGenerations` struct.
    pub fn new(max_generations: usize) -> Self {
        Self(max_generations)
    }
}

impl<G, F> TerminationCondition<G, F> for MaxGenerations {
    fn should_terminate(&self, state: &State<G, F>) -> bool {
        state.generation() >= self.0
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use crate::core::{population::Population, state::State};

    #[test]
    fn terminates_at_max_generation() {
        let tc = MaxGenerations::new(10);
        let state = State::<(), ()>::new(Population::new(), 10);
        assert!(tc.should_terminate(&state));
    }

    #[test]
    fn terminates_past_max_generation() {
        let tc = MaxGenerations::new(10);
        let state = State::<(), ()>::new(Population::new(), 15);
        assert!(tc.should_terminate(&state));
    }

    #[test]
    fn does_not_terminate_before_max() {
        let tc = MaxGenerations::new(10);
        let state = State::<(), ()>::new(Population::new(), 9);
        assert!(!tc.should_terminate(&state));
    }
}