genetic_algorithms 3.0.0

Library for solving genetic algorithm problems
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

#[cfg(test)]
use genetic_algorithms::chromosomes::Binary as BinaryChromosome;
use genetic_algorithms::genotypes::Binary as BinaryGenotype;
use genetic_algorithms::operations::mutation::bit_flip::bit_flip;
use genetic_algorithms::traits::LinearChromosome;
use std::borrow::Cow;

#[test]
fn bit_flip_changes_exactly_one_gene() {
    let dna = vec![
        BinaryGenotype { id: 0, value: true },
        BinaryGenotype {
            id: 1,
            value: false,
        },
        BinaryGenotype { id: 2, value: true },
        BinaryGenotype {
            id: 3,
            value: false,
        },
        BinaryGenotype { id: 4, value: true },
    ];

    // Run multiple times to check that exactly 1 gene changes each time
    for _ in 0..50 {
        let mut chromosome = BinaryChromosome::new();
        chromosome.set_dna(Cow::Owned(dna.clone()));

        bit_flip(&mut chromosome);

        let result = chromosome.dna();
        let mut diff_count = 0;
        for i in 0..dna.len() {
            if result[i].value != dna[i].value {
                diff_count += 1;
            }
        }
        assert_eq!(diff_count, 1, "Bit flip should change exactly 1 gene");
    }
}

#[test]
fn bit_flip_flips_the_value() {
    // All true -> one should become false
    let dna = vec![
        BinaryGenotype { id: 0, value: true },
        BinaryGenotype { id: 1, value: true },
        BinaryGenotype { id: 2, value: true },
    ];

    let mut chromosome = BinaryChromosome::new();
    chromosome.set_dna(Cow::Owned(dna));

    bit_flip(&mut chromosome);

    let result = chromosome.dna();
    let false_count = result.iter().filter(|g| !g.value).count();
    assert_eq!(false_count, 1, "One gene should have been flipped to false");
}

#[test]
fn bit_flip_preserves_length_and_ids() {
    let dna = vec![
        BinaryGenotype { id: 0, value: true },
        BinaryGenotype {
            id: 1,
            value: false,
        },
        BinaryGenotype { id: 2, value: true },
        BinaryGenotype {
            id: 3,
            value: false,
        },
    ];

    let mut chromosome = BinaryChromosome::new();
    chromosome.set_dna(Cow::Owned(dna.clone()));

    bit_flip(&mut chromosome);

    let result = chromosome.dna();
    assert_eq!(result.len(), 4);
    for i in 0..4 {
        assert_eq!(result[i].id, dna[i].id, "IDs should be preserved");
    }
}

// ==================== Phase 5 edge-case tests ====================

#[test]
fn bit_flip_empty_chromosome_no_panic() {
    let mut chromosome = BinaryChromosome::new();
    chromosome.set_dna(Cow::Owned(vec![]));
    bit_flip(&mut chromosome);
    assert_eq!(chromosome.dna().len(), 0);
}

#[test]
fn bit_flip_single_gene_flips_it() {
    let dna = vec![BinaryGenotype { id: 0, value: true }];
    let mut chromosome = BinaryChromosome::new();
    chromosome.set_dna(Cow::Owned(dna));

    bit_flip(&mut chromosome);

    // Only gene must be flipped
    assert!(!chromosome.dna()[0].value, "Single gene should be flipped");
}

#[test]
fn bit_flip_all_false_flips_one_to_true() {
    let dna = vec![
        BinaryGenotype {
            id: 0,
            value: false,
        },
        BinaryGenotype {
            id: 1,
            value: false,
        },
        BinaryGenotype {
            id: 2,
            value: false,
        },
    ];
    let mut chromosome = BinaryChromosome::new();
    chromosome.set_dna(Cow::Owned(dna));

    bit_flip(&mut chromosome);

    let true_count = chromosome.dna().iter().filter(|g| g.value).count();
    assert_eq!(true_count, 1, "One gene should have been flipped to true");
}