optlib 0.4.0

The optimization algorithms realized in Rust. In given time realized genetic and particle swarm algorithms.
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
144
145
146
147
148

use num::Float;

use crate::particleswarm::PostVelocityCalc;

/// The trait to restrict value for every dimension of velocity
pub struct MaxVelocityDimensions<T> {
    max_velocity: Vec<T>,
}

impl<T> MaxVelocityDimensions<T> {
    pub fn new(max_velocity: Vec<T>) -> Self {
        Self { max_velocity }
    }
}

impl<T: Float> PostVelocityCalc<T> for MaxVelocityDimensions<T> {
    fn correct_velocity(&mut self, velocity: Vec<T>) -> Vec<T> {
        assert_eq!(velocity.len(), self.max_velocity.len());

        let new_velocity = velocity
            .iter()
            .zip(self.max_velocity.iter())
            .map(|(v, v_max)| {
                if v.abs() <= *v_max {
                    *v
                } else {
                    v_max.abs() * v.signum()
                }
            })
            .collect();

        new_velocity
    }
}

/// The trait to restrict absolute velocity
pub struct MaxVelocityAbs<T> {
    max_velocity: T,
}

impl<T> MaxVelocityAbs<T> {
    pub fn new(max_velocity: T) -> Self {
        Self { max_velocity }
    }
}

impl<T: Float> PostVelocityCalc<T> for MaxVelocityAbs<T> {
    fn correct_velocity(&mut self, velocity: Vec<T>) -> Vec<T> {
        let current_velocity_abs = velocity
            .iter()
            .fold(T::zero(), |acc, vi| acc + (*vi) * (*vi))
            .sqrt();
        if current_velocity_abs > self.max_velocity {
            let new_velocity = velocity
                .iter()
                .map(|vi| (*vi) * self.max_velocity / current_velocity_abs)
                .collect();
            new_velocity
        } else {
            velocity
        }
    }
}

#[cfg(test)]
mod tests {
    use num::abs;
    use super::{MaxVelocityAbs, MaxVelocityDimensions};
    use crate::particleswarm::PostVelocityCalc;

    #[test]
    fn test_max_velocity_dimensions_empty() {
        let max_velocity: Vec<f32> = vec![];
        let velocity: Vec<f32> = vec![];

        let mut post_velocity = MaxVelocityDimensions::new(max_velocity);
        let new_velocity = post_velocity.correct_velocity(velocity);

        assert_eq!(new_velocity, vec![]);
    }

    #[test]
    #[should_panic]
    fn test_max_velocity_invalid_size() {
        let max_velocity: Vec<f32> = vec![2.0_f32];
        let velocity: Vec<f32> = vec![];

        let mut post_velocity = MaxVelocityDimensions::new(max_velocity);
        post_velocity.correct_velocity(velocity);
    }

    #[test]
    fn test_max_velocity_dimensions_not_change() {
        let max_velocity: Vec<f32> = vec![10.0_f32, 10.0_f32];
        let velocity: Vec<f32> = vec![5.0_f32, -5.0_f32];

        let mut post_velocity = MaxVelocityDimensions::new(max_velocity);
        let new_velocity = post_velocity.correct_velocity(velocity.clone());

        assert_eq!(new_velocity, velocity);
    }

    #[test]
    fn test_max_velocity_dimensions_fix() {
        let max_velocity: Vec<f32> = vec![10.0_f32, 10.0_f32, 10.0_f32];
        let velocity: Vec<f32> = vec![15.0_f32, -15.0_f32, 5.0_f32];

        let mut post_velocity = MaxVelocityDimensions::new(max_velocity);
        let new_velocity = post_velocity.correct_velocity(velocity.clone());

        assert_eq!(new_velocity, vec![10.0_f32, -10.0_f32, 5.0_f32]);
    }

    #[test]
    fn test_max_velocity_abs_empty() {
        let max_velocity = 10.0_f32;
        let velocity: Vec<f32> = vec![];

        let mut post_velocity = MaxVelocityAbs::new(max_velocity);
        let new_velocity = post_velocity.correct_velocity(velocity);

        assert_eq!(new_velocity, vec![]);
    }

    #[test]
    fn test_max_velocity_abs_not_change() {
        let max_velocity = 10.0_f32;
        let velocity: Vec<f32> = vec![5.0_f32, -5.0_f32];

        let mut post_velocity = MaxVelocityAbs::new(max_velocity);
        let new_velocity = post_velocity.correct_velocity(velocity.clone());

        assert_eq!(new_velocity, velocity);
    }

    #[test]
    fn test_max_velocity_abs_change() {
        let max_velocity = 10.0_f32;
        let velocity: Vec<f32> = vec![15.0_f32, -15.0_f32];

        let mut post_velocity = MaxVelocityAbs::new(max_velocity);
        let new_velocity = post_velocity.correct_velocity(velocity.clone());
        let new_velocity_abs = (new_velocity[0] * new_velocity[0] + 
            new_velocity[1] * new_velocity[1]).sqrt();

        assert!(abs(new_velocity_abs - max_velocity) < 1e-3);
    }
}