evolve 0.4.0

A generic, composable genetic algorithm framework for Rust
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

use crate::core::{
    context::Context, individual::Individual, offspring::Offspring, population::Population,
    state::State,
};
use crate::fitness::FitnessEvaluator;
use crate::operators::GeneticOperator;
use rand::{Rng, RngExt, SeedableRng};

/// Parallel version of [`Gaussian`](crate::operators::sequential::mutation::Gaussian).
///
/// Distributes individuals across pool workers for Gaussian mutation.
/// Each task gets its own RNG seeded from the main one.
#[derive(Debug, Clone, Copy)]
pub struct Gaussian {
    std_dev: f64,
    min: Option<f64>,
    max: Option<f64>,
}

impl Gaussian {
    /// Creates a new parallel `Gaussian` mutation with the given standard deviation.
    pub fn new(std_dev: f64) -> Self {
        Self { std_dev, min: None, max: None }
    }

    /// Sets the lower bound. Genes are clamped to this minimum after mutation.
    pub fn min(mut self, min: f64) -> Self {
        self.min = Some(min);
        self
    }

    /// Sets the upper bound. Genes are clamped to this maximum after mutation.
    pub fn max(mut self, max: f64) -> Self {
        self.max = Some(max);
        self
    }
}

/// Generates a standard normal random value using the Box-Muller transform.
fn box_muller(rng: &mut impl Rng) -> f64 {
    let u1: f64 = rng.random();
    let u2: f64 = rng.random();
    (-2.0 * u1.ln()).sqrt() * (std::f64::consts::TAU * u2).cos()
}

macro_rules! impl_parallel_gaussian {
    ($float:ty, $cast:expr) => {
        impl<F, Fe, R, C, const N: usize> GeneticOperator<[$float; N], F, Fe, R, C> for Gaussian
        where
            $float: Send + Sync,
            F: Send,
            R: Rng + SeedableRng,
            Fe: FitnessEvaluator<[$float; N], F> + Sync,
            C: Sync,
            Individual<[$float; N], F>: Sync,
        {
            fn apply(&self, state: &State<[$float; N], F>, ctx: &mut Context<Fe, R, C>) -> Offspring<[$float; N], F> {
                let individuals = state.population().as_slice();
                let std_dev = self.std_dev;
                let min = self.min;
                let max = self.max;
                let inputs: vecpool::PoolVec<(u64, usize)> = (0..individuals.len())
                    .map(|i| (ctx.rng().random::<u64>(), i))
                    .collect();

                let results = ctx.pool().map(&inputs, |(seed, idx)| {
                    let mut rng = R::seed_from_u64(*seed);
                    let mut genome = *individuals[*idx].genome();
                    let gene_idx = rng.random_range(0..N);
                    genome[gene_idx] += $cast(box_muller(&mut rng) * std_dev);
                    if let Some(lo) = min { genome[gene_idx] = genome[gene_idx].max(lo as $float); }
                    if let Some(hi) = max { genome[gene_idx] = genome[gene_idx].min(hi as $float); }
                    Individual::new(genome)
                });

                let mut population = Population::with_capacity(individuals.len());
                for r in results {
                    population.add(r.expect("pool task panicked"));
                }
                Offspring::Multiple(population)
            }
        }

        impl<F, Fe, R, C> GeneticOperator<Vec<$float>, F, Fe, R, C> for Gaussian
        where
            $float: Send + Sync,
            F: Send,
            R: Rng + SeedableRng,
            Fe: FitnessEvaluator<Vec<$float>, F> + Sync,
            C: Sync,
            Individual<Vec<$float>, F>: Sync,
        {
            fn apply(&self, state: &State<Vec<$float>, F>, ctx: &mut Context<Fe, R, C>) -> Offspring<Vec<$float>, F> {
                let individuals = state.population().as_slice();
                let std_dev = self.std_dev;
                let min = self.min;
                let max = self.max;
                let inputs: vecpool::PoolVec<(u64, usize)> = (0..individuals.len())
                    .map(|i| (ctx.rng().random::<u64>(), i))
                    .collect();

                let results = ctx.pool().map(&inputs, |(seed, idx)| {
                    let mut rng = R::seed_from_u64(*seed);
                    let mut genome = individuals[*idx].genome().clone();
                    let gene_idx = rng.random_range(0..genome.len());
                    genome[gene_idx] += $cast(box_muller(&mut rng) * std_dev);
                    if let Some(lo) = min { genome[gene_idx] = genome[gene_idx].max(lo as $float); }
                    if let Some(hi) = max { genome[gene_idx] = genome[gene_idx].min(hi as $float); }
                    Individual::new(genome)
                });

                let mut population = Population::with_capacity(individuals.len());
                for r in results {
                    population.add(r.expect("pool task panicked"));
                }
                Offspring::Multiple(population)
            }
        }
    };
}

impl_parallel_gaussian!(f64, |x: f64| x);
impl_parallel_gaussian!(f32, |x: f64| x as f32);