genevo 0.7.1

genevo provides building blocks to run simulations of optimization and search problems using genetic algorithms (GA). Execute genetic algorithm (GA) simulations in a customizable and extensible way.
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

#[cfg(test)]
#[macro_use]
extern crate galvanic_assert;

use galvanic_assert::matchers::*;

use genevo::{
    population::{BinaryEncodedGenomeBuilder, ValueEncodedGenomeBuilder},
    prelude::*,
    random::Rng,
};

#[test]
fn create_population_of_vec_of_bool_uniform_at_random() {
    let population: Population<Vec<bool>> = build_population()
        .with_genome_builder(BinaryEncodedGenomeBuilder::new(4))
        .of_size(200)
        .uniform_at_random();

    println!("{:?}", population);
    assert_that!(&population.size(), eq(200));
}

#[test]
fn create_population_of_vec_of_f64_uniform_at_random() {
    let population: Population<Vec<f64>> = build_population()
        .with_genome_builder(ValueEncodedGenomeBuilder::new(4, -2., 2.))
        .of_size(200)
        .uniform_at_random();

    println!("{:?}", population);
    assert_that!(&population.size(), eq(200));
}

#[test]
fn create_population_of_custom_genotype_uniform_at_random() {
    #[derive(Clone, Debug, PartialEq)]
    struct Pos {
        x: usize,
        y: usize,
    }

    struct PositionsBuilder;
    impl GenomeBuilder<Vec<Pos>> for PositionsBuilder {
        fn build_genome<R>(&self, _: usize, rng: &mut R) -> Vec<Pos>
        where
            R: Rng + Sized,
        {
            (0..8)
                .map(|row| Pos {
                    x: row,
                    y: rng.gen_range(0..8),
                })
                .collect()
        }
    }

    let population: Population<Vec<Pos>> = build_population()
        .with_genome_builder(PositionsBuilder)
        .of_size(200)
        .uniform_at_random();

    println!("{:?}", population);
    assert_that!(&population.size(), eq(200));
}

#[cfg(feature = "fixedbitset")]
mod fixedbitset_population_builder {

    use super::*;
    use fixedbitset::FixedBitSet;

    #[test]
    fn create_population_of_fixedbitset_uniform_at_random() {
        let population: Population<FixedBitSet> = build_population()
            .with_genome_builder(BinaryEncodedGenomeBuilder::new(20))
            .of_size(200)
            .uniform_at_random();

        println!("{:?}", population);
        assert_that!(&population.size(), eq(200));
    }

    #[test]
    fn create_population_with_custom_number_generator() {
        let population: Population<FixedBitSet> = build_population()
            .with_genome_builder(BinaryEncodedGenomeBuilder::new(8))
            .of_size(200)
            .using_seed([42; 32]);

        println!("{:?}", population);
        assert_that!(&population.size(), eq(200));
    }
}