moors 0.2.10

Solving multi-objective optimization problems using genetic 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

use ndarray::{ArrayViewMut1, s};

use crate::{operators::MutationOperator, random::RandomGenerator};

#[derive(Debug, Clone)]
/// Scramble Mutation operator that selects a subset of the chromosome and randomly reorders it.
pub struct ScrambleMutation {}

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

impl MutationOperator for ScrambleMutation {
    fn mutate<'a>(&self, mut individual: ArrayViewMut1<'a, f64>, rng: &mut impl RandomGenerator) {
        let n = individual.len();
        // Select two random indices to define the segment.
        let idx1 = rng.gen_range_usize(0, n);
        let idx2 = rng.gen_range_usize(0, n);
        let (start, end) = if idx1 <= idx2 {
            (idx1, idx2)
        } else {
            (idx2, idx1)
        };
        if start == end {
            return;
        }
        // Extract the segment.
        let mut segment = individual.slice(s![start..end]).to_vec();
        // Randomly reorder (scramble) the segment.
        rng.shuffle_vec(&mut segment);
        // Copy the scrambled segment back.
        for (i, &value) in segment.iter().enumerate() {
            individual[start + i] = value;
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::random::{RandomGenerator, TestDummyRng};
    use ndarray::{Array1, array};
    use rstest::rstest;

    /// A fake RandomGenerator for scramble mutation testing.
    struct FakeRandomGeneratorScramble {
        // Predefined values for segment boundary selection.
        usize_values: Vec<usize>,
        fake_rng: TestDummyRng,
    }

    impl FakeRandomGeneratorScramble {
        fn new(usize_values: Vec<usize>) -> Self {
            Self {
                usize_values,
                fake_rng: TestDummyRng,
            }
        }
    }

    impl RandomGenerator for FakeRandomGeneratorScramble {
        type R = TestDummyRng;
        fn rng(&mut self) -> &mut TestDummyRng {
            &mut self.fake_rng
        }

        fn gen_range_usize(&mut self, _min: usize, _max: usize) -> usize {
            self.usize_values.remove(0)
        }

        fn shuffle_vec(&mut self, vector: &mut Vec<f64>) {
            let vector_clone = vector.clone();
            vector[0] = vector_clone[1];
            vector[1] = vector_clone[0];
            vector[2] = vector_clone[3];
            vector[3] = vector_clone[2];
        }
    }

    #[rstest(rng_boundaries,
        case(vec![0, 4]),
        case(vec![4, 0])
    )]
    fn test_scramble_mutation(rng_boundaries: Vec<usize>) {
        // Test individual: [0.0, 1.0, 2.0, 3.0, 4.0, 5.0]
        // Note that selected indexes are 0 and 4 so the segment will be: [0.0, 1.0, 2.0, 3.0]
        // the shuffle mock is simple, it's only  0.0 <-> 1.0 and 2.0 <-> 3.0
        // So the expected individual is [1.0, 0.0, 3.0, 2.0, 4.0, 5.0]
        let mut individual: Array1<f64> = array![0.0, 1.0, 2.0, 3.0, 4.0, 5.0];
        let mut rng = FakeRandomGeneratorScramble::new(rng_boundaries);
        let mutation_operator = ScrambleMutation::new();
        {
            let view = individual.view_mut();
            mutation_operator.mutate(view, &mut rng);
        }
        let expected: Array1<f64> = array![1.0, 0.0, 3.0, 2.0, 4.0, 5.0];
        assert_eq!(individual, expected);
    }

    #[test]
    fn test_scramble_mutation_same_idx() {
        // in this test gen range return 0 twice, so no segment..
        let mut individual: Array1<f64> = array![0.0, 1.0, 2.0, 3.0, 4.0, 5.0];
        let mut rng = FakeRandomGeneratorScramble::new(vec![0, 0]);
        let mutation_operator = ScrambleMutation::new();
        {
            let view = individual.view_mut();
            mutation_operator.mutate(view, &mut rng);
        }
        let expected: Array1<f64> = array![0.0, 1.0, 2.0, 3.0, 4.0, 5.0];
        assert_eq!(individual, expected);
    }
}