optlib 0.1.0

The optimization algorithms realized in Rust. In given time optlib realized genetic algorithm only.
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

//! The module with structs for `StopChecker` traits.

use super::*;

/// Genetic algorithm will be stopped after specified generation (iteration).
pub struct MaxIterations {
    max_iter: usize,
}

impl MaxIterations {
    /// Constructor
    ///
    /// # Parameters
    /// * `max_iter` - how many iterations (generations) will run genetic algorithm.
    pub fn new(max_iter: usize) -> Self {
        MaxIterations { max_iter }
    }
}

impl<T: Clone> StopChecker<T> for MaxIterations {
    fn can_stop(&mut self, population: &Population<T>) -> bool {
        population.get_iteration() >= self.max_iter
    }
}

/// Genetic algorithm will be stopped if goal function of the best individual does not change.
pub struct GoalNotChange {
    max_iter: usize,
    delta: f64,

    old_goal: f64,
    change_iter: usize,
}

impl GoalNotChange {
    /// Constructor.
    ///
    /// # Parameters
    /// * `max_iter` - how many iterations (generations) the value of goal function of the best
    /// individual may not change.
    /// * `delta` - small value. The change of goal function is not considered if the change less
    /// of `delta`.
    pub fn new(max_iter: usize, delta: f64) -> Self {
        GoalNotChange {
            max_iter,
            delta,
            old_goal: f64::MAX,
            change_iter: 0,
        }
    }
}

impl<T: Clone> StopChecker<T> for GoalNotChange {
    fn can_stop(&mut self, population: &Population<T>) -> bool {
        match population.get_best() {
            None => false,
            Some(individual) => {
                let best_goal = individual.get_goal();
                let delta = (best_goal - self.old_goal).abs();
                if delta > self.delta {
                    self.old_goal = best_goal;
                    self.change_iter = population.get_iteration();
                }

                (population.get_iteration() - self.change_iter) > self.max_iter
            }
        }
    }
}

/// Stop genetic algorithm if value of the goal function less of than threshold.
pub struct Threshold {
    threshold: f64,
}

impl Threshold {
    /// Constructor.
    ///
    /// # Parameters
    /// * `threshold` - min value of the goal function
    pub fn new(threshold: f64) -> Self {
        Self { threshold }
    }
}

impl<T: Clone> StopChecker<T> for Threshold {
    fn can_stop(&mut self, population: &Population<T>) -> bool {
        match population.get_best() {
            None => false,
            Some(individual) => individual.get_goal() <= self.threshold,
        }
    }
}

/// Stop genetic algorithm if ANY of stop checker returns true
pub struct CompositeAny<T: Clone> {
    stop_checkers: Vec<Box<dyn StopChecker<T>>>,
}

impl<T: Clone> CompositeAny<T> {
    /// Constructor
    pub fn new(stop_checkers: Vec<Box<dyn StopChecker<T>>>) -> Self {
        assert!(stop_checkers.len() != 0);
        Self { stop_checkers }
    }
}

impl<T: Clone> StopChecker<T> for CompositeAny<T> {
    fn can_stop(&mut self, population: &Population<T>) -> bool {
        for checker in &mut self.stop_checkers {
            if checker.can_stop(population) {
                return true
            }
        }

        false
    }
}

/// Stop genetic algorithm if ALL stop checkers returns true
pub struct CompositeAll<T: Clone> {
    stop_checkers: Vec<Box<dyn StopChecker<T>>>,
}

impl<T: Clone> CompositeAll<T> {
    /// Constructor
    pub fn new(stop_checkers: Vec<Box<dyn StopChecker<T>>>) -> Self {
        assert!(stop_checkers.len() != 0);
        Self { stop_checkers }
    }
}

impl<T: Clone> StopChecker<T> for CompositeAll<T> {
    fn can_stop(&mut self, population: &Population<T>) -> bool {
        for checker in &mut self.stop_checkers {
            if !checker.can_stop(population) {
                return false
            }
        }

        true
    }
}