genomic 0.2.0

A small crate for implementing genetical 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

use rand::Rng;

use crate::{Chromosome, Crossover, Mutator};

/// Represents a collection of chromosomes.
///
/// Implementing it means traversing your structure with the `Mutator` and `Crossover` helpers.
/// The implementations of the `mutate` and `crossover` methods should generally be very similar to one another.
///
/// # Example
///
/// ```rust
/// # use genomic::prelude::*;
/// # use genomic::mutate;
///
/// #[derive(Clone, Debug)]
/// struct Pair {
///     left: u32,
///     right: u32,
/// }
///
/// impl Genome for Pair {
///     fn mutate(&mut self, mutator: &mut Mutator<impl rand::Rng>) {
///         mutator
///             .chromosome(&mut self.left)
///             .chromosome(&mut self.right);
///     }
///
///     fn crossover(&mut self, other: &mut Self, crossover: &mut Crossover<impl rand::Rng>) {
///         crossover
///             .chromosome(&mut self.left, &mut other.left)
///             .chromosome(&mut self.right, &mut other.right);
///     }
///
///     fn size_hint(&self) -> usize {
///         2
///     }
/// }
///
/// let mut instance = Pair {
///     left: 0,
///     right: 0,
/// };
///
/// mutate(&mut instance, 1.0, &mut rand::thread_rng());
///
/// let mut instance_copy = instance.clone();
///
/// mutate(&mut instance_copy, 0.1, &mut rand::thread_rng());
///
/// println!("{:?} {:?}", instance, instance_copy);
/// ```
pub trait Genome {
    /// Should mutate the chromosomes contained by this structure, using the `mutator` helper.
    fn mutate(&mut self, mutator: &mut Mutator<impl Rng>);

    /// Should perform a crossover over the chromosomes contained by this structure, using the `crossover` helper.
    ///
    /// **Note:** this function should *not* alter the number of chromosomes contained in either instances.
    /// Doing so might cause functions in this crate to produce incorrect results.
    fn crossover(&mut self, other: &mut Self, crossover: &mut Crossover<impl Rng>);

    /// Should return the number of chromosomes contained in this structure.
    ///
    /// Returning an invalid amount will not crash any of the functions from this crate,
    /// but it might cause them to produce incorrect results.
    fn size_hint(&self) -> usize;
}

impl<Ch: Chromosome> Genome for Ch {
    #[inline(always)]
    fn mutate(&mut self, mutator: &mut Mutator<impl Rng>) {
        mutator.chromosome(self);
    }

    #[inline(always)]
    fn crossover(&mut self, other: &mut Self, crossover: &mut Crossover<impl Rng>) {
        crossover.chromosome(self, other);
    }

    fn size_hint(&self) -> usize {
        1
    }
}

impl<G: Genome> Genome for Vec<G> {
    fn mutate(&mut self, mutator: &mut Mutator<impl Rng>) {
        mutator.iter(self.iter_mut());
    }

    fn crossover(&mut self, other: &mut Self, crossover: &mut Crossover<impl Rng>) {
        crossover.iter(self.iter_mut(), other.iter_mut());
    }

    fn size_hint(&self) -> usize {
        self.iter().map(|item| item.size_hint()).sum()
    }
}

impl<G: Genome> Genome for [G] {
    fn mutate(&mut self, mutator: &mut Mutator<impl Rng>) {
        mutator.iter(self.iter_mut());
    }

    fn crossover(&mut self, other: &mut Self, crossover: &mut Crossover<impl Rng>) {
        crossover.iter(self.iter_mut(), other.iter_mut());
    }

    fn size_hint(&self) -> usize {
        self.iter().map(|item| item.size_hint()).sum()
    }
}

macro_rules! impl_genome_tuple {
    ( $( $name:ident => $id:tt ),+ ) => {
        impl<$($name : Genome),+> Genome for ($($name),+) {
            fn mutate(&mut self, mutator: &mut Mutator<impl Rng>) {
                mutator
                    $(.genome(&mut self.$id))+;
            }

            fn crossover(&mut self, other: &mut Self, crossover: &mut Crossover<impl Rng>) {
                crossover
                    $(.genome(&mut self.$id, &mut other.$id))+;
            }

            fn size_hint(&self) -> usize {
                0
                $(+ self.$id.size_hint())+
            }
        }
    }
}

impl_genome_tuple!(G1 => 0, G2 => 1);
impl_genome_tuple!(G1 => 0, G2 => 1, G3 => 2);
impl_genome_tuple!(G1 => 0, G2 => 1, G3 => 2, G4 => 3);
impl_genome_tuple!(G1 => 0, G2 => 1, G3 => 2, G4 => 3, G5 => 4);
impl_genome_tuple!(G1 => 0, G2 => 1, G3 => 2, G4 => 3, G5 => 4, G6 => 5);