genetic_algorithm 0.27.1

A genetic algorithm implementation
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

pub use super::clone::Clone as CrossoverClone;
pub use super::multi_gene::MultiGene as CrossoverMultiGene;
pub use super::multi_point::MultiPoint as CrossoverMultiPoint;
pub use super::rejuvenate::Rejuvenate as CrossoverRejuvenate;
pub use super::single_gene::SingleGene as CrossoverSingleGene;
pub use super::single_point::SinglePoint as CrossoverSinglePoint;
pub use super::uniform::Uniform as CrossoverUniform;
pub use super::Crossover;

use crate::genotype::{EvolveGenotype, SupportsGeneCrossover, SupportsPointCrossover};
use crate::strategy::evolve::{EvolveConfig, EvolveState};
use crate::strategy::StrategyReporter;
use rand::Rng;

#[derive(Clone, Debug)]
pub enum Wrapper<G: EvolveGenotype + SupportsGeneCrossover + SupportsPointCrossover> {
    Clone(CrossoverClone<G>),
    MultiGene(CrossoverMultiGene<G>),
    MultiPoint(CrossoverMultiPoint<G>),
    Rejuvenate(CrossoverRejuvenate<G>),
    SingleGene(CrossoverSingleGene<G>),
    SinglePoint(CrossoverSinglePoint<G>),
    Uniform(CrossoverUniform<G>),
}

impl<G: EvolveGenotype + SupportsGeneCrossover + SupportsPointCrossover> Crossover for Wrapper<G> {
    type Genotype = G;

    fn before(&mut self, genotype: &G, state: &mut EvolveState<G>, config: &EvolveConfig) {
        match self {
            Wrapper::Clone(crossover) => crossover.before(genotype, state, config),
            Wrapper::MultiGene(crossover) => crossover.before(genotype, state, config),
            Wrapper::MultiPoint(crossover) => crossover.before(genotype, state, config),
            Wrapper::Rejuvenate(crossover) => crossover.before(genotype, state, config),
            Wrapper::SingleGene(crossover) => crossover.before(genotype, state, config),
            Wrapper::SinglePoint(crossover) => crossover.before(genotype, state, config),
            Wrapper::Uniform(crossover) => crossover.before(genotype, state, config),
        }
    }

    fn call<R: Rng, SR: StrategyReporter<Genotype = G>>(
        &mut self,
        genotype: &G,
        state: &mut EvolveState<G>,
        config: &EvolveConfig,
        reporter: &mut SR,
        rng: &mut R,
    ) {
        match self {
            Wrapper::Clone(crossover) => crossover.call(genotype, state, config, reporter, rng),
            Wrapper::MultiGene(crossover) => crossover.call(genotype, state, config, reporter, rng),
            Wrapper::MultiPoint(crossover) => {
                crossover.call(genotype, state, config, reporter, rng)
            }
            Wrapper::Rejuvenate(crossover) => {
                crossover.call(genotype, state, config, reporter, rng)
            }
            Wrapper::SingleGene(crossover) => {
                crossover.call(genotype, state, config, reporter, rng)
            }
            Wrapper::SinglePoint(crossover) => {
                crossover.call(genotype, state, config, reporter, rng)
            }
            Wrapper::Uniform(crossover) => crossover.call(genotype, state, config, reporter, rng),
        }
    }

    fn after(&mut self, genotype: &G, state: &mut EvolveState<G>, config: &EvolveConfig) {
        match self {
            Wrapper::Clone(crossover) => crossover.after(genotype, state, config),
            Wrapper::MultiGene(crossover) => crossover.after(genotype, state, config),
            Wrapper::MultiPoint(crossover) => crossover.after(genotype, state, config),
            Wrapper::Rejuvenate(crossover) => crossover.after(genotype, state, config),
            Wrapper::SingleGene(crossover) => crossover.after(genotype, state, config),
            Wrapper::SinglePoint(crossover) => crossover.after(genotype, state, config),
            Wrapper::Uniform(crossover) => crossover.after(genotype, state, config),
        }
    }
}

impl<G: EvolveGenotype + SupportsGeneCrossover + SupportsPointCrossover> From<CrossoverClone<G>>
    for Wrapper<G>
{
    fn from(crossover: CrossoverClone<G>) -> Self {
        Wrapper::Clone(crossover)
    }
}
impl<G: EvolveGenotype + SupportsGeneCrossover + SupportsPointCrossover>
    From<CrossoverMultiGene<G>> for Wrapper<G>
{
    fn from(crossover: CrossoverMultiGene<G>) -> Self {
        Wrapper::MultiGene(crossover)
    }
}
impl<G: EvolveGenotype + SupportsGeneCrossover + SupportsPointCrossover>
    From<CrossoverMultiPoint<G>> for Wrapper<G>
{
    fn from(crossover: CrossoverMultiPoint<G>) -> Self {
        Wrapper::MultiPoint(crossover)
    }
}
impl<G: EvolveGenotype + SupportsGeneCrossover + SupportsPointCrossover>
    From<CrossoverRejuvenate<G>> for Wrapper<G>
{
    fn from(crossover: CrossoverRejuvenate<G>) -> Self {
        Wrapper::Rejuvenate(crossover)
    }
}
impl<G: EvolveGenotype + SupportsGeneCrossover + SupportsPointCrossover>
    From<CrossoverSingleGene<G>> for Wrapper<G>
{
    fn from(crossover: CrossoverSingleGene<G>) -> Self {
        Wrapper::SingleGene(crossover)
    }
}
impl<G: EvolveGenotype + SupportsGeneCrossover + SupportsPointCrossover>
    From<CrossoverSinglePoint<G>> for Wrapper<G>
{
    fn from(crossover: CrossoverSinglePoint<G>) -> Self {
        Wrapper::SinglePoint(crossover)
    }
}
impl<G: EvolveGenotype + SupportsGeneCrossover + SupportsPointCrossover>
    From<CrossoverUniform<G>> for Wrapper<G>
{
    fn from(crossover: CrossoverUniform<G>) -> Self {
        Wrapper::Uniform(crossover)
    }
}