optlib 0.2.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

use crate::particleswarm::PostMove;

use num::Float;

pub struct NonePostMove {}

impl NonePostMove {
    pub fn new() -> Self {
        Self {}
    }
}

impl<T> PostMove<T> for NonePostMove {
    fn post_move(&self, _coordinates: &mut Vec<T>) {}
}

pub struct MoveToBoundary<T> {
    intervals: Vec<(T, T)>,
}

impl<T> MoveToBoundary<T> {
    pub fn new(intervals: Vec<(T, T)>) -> Self {
        Self { intervals }
    }
}

impl<T: Float> PostMove<T> for MoveToBoundary<T> {
    fn post_move(&self, coordinates: &mut Vec<T>) {
        assert_eq!(coordinates.len(), self.intervals.len());

        for i in 0..coordinates.len() {
            if !coordinates[i].is_finite() {
                coordinates[i] = self.intervals[i].0;
            }

            if coordinates[i] < self.intervals[i].0 {
                coordinates[i] = self.intervals[i].0;
            }

            if coordinates[i] > self.intervals[i].1 {
                coordinates[i] = self.intervals[i].1;
            }
        }
    }
}

#[cfg(test)]
mod test_move_to_boundary {
    use crate::particleswarm::{postmove::MoveToBoundary, PostMove};
    use num::abs;

    #[test]
    fn test_empty() {
        let intervals: Vec<(f32, f32)> = vec![];
        let mut coordinates = vec![];

        let postmove = MoveToBoundary::new(intervals);
        postmove.post_move(&mut coordinates);
    }

    #[test]
    fn test_inside_interval() {
        let intervals = vec![(0.0_f32, 1.0_f32)];
        let mut coordinates = vec![0.6_f32];

        let postmove = MoveToBoundary::new(intervals);
        postmove.post_move(&mut coordinates);

        assert!(abs(coordinates[0] - 0.6_f32) < 1e-6);
    }

    #[test]
    fn test_min() {
        let intervals = vec![(0.0_f32, 1.0_f32)];
        let mut coordinates = vec![-1.0_f32];

        let postmove = MoveToBoundary::new(intervals);
        postmove.post_move(&mut coordinates);

        assert!(abs(coordinates[0]) < 1e-6);
    }

    #[test]
    fn test_max() {
        let intervals = vec![(0.0_f32, 1.0_f32)];
        let mut coordinates = vec![3.0_f32];

        let postmove = MoveToBoundary::new(intervals);
        postmove.post_move(&mut coordinates);

        assert!(abs(coordinates[0] - 1.0_f32) < 1e-6);
    }

    #[test]
    fn test_mix() {
        let intervals = vec![(0.0_f32, 1.0_f32), (1.0_f32, 3.0_f32), (5.0_f32, 10.0_f32)];
        let mut coordinates = vec![-3.0_f32, 4.0_f32, 6.0_f32];

        let postmove = MoveToBoundary::new(intervals);
        postmove.post_move(&mut coordinates);

        assert!(abs(coordinates[0] - 0.0_f32) < 1e-6);
        assert!(abs(coordinates[1] - 3.0_f32) < 1e-6);
        assert!(abs(coordinates[2] - 6.0_f32) < 1e-6);
    }
}