radiate-engines 1.3.0

Engines for the Radiate genetic algorithm library.
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

use crate::builder::config::EngineConfig;
use crate::{Chromosome, EngineControl};
use radiate_core::MetricQuery;
use radiate_core::error::RadiateResult;
use radiate_core::{
    Ecosystem, Front, MetricSet, Objective, Phenotype, Problem, Score, metric, metric_names,
};
use std::sync::{Arc, Mutex, RwLock};

pub struct EvolutionContext<C: Chromosome, T> {
    pub(crate) ecosystem: Ecosystem<C>,
    pub(crate) best: T,
    pub(crate) index: usize,
    pub(crate) metrics: MetricSet,
    pub(crate) score: Option<Score>,
    pub(crate) front: Arc<RwLock<Front<Phenotype<C>>>>,
    pub(crate) objective: Objective,
    pub(crate) problem: Arc<dyn Problem<C, T>>,
    pub(crate) control: Option<EngineControl>,
    pub(crate) exprs: Option<Arc<Mutex<Vec<MetricQuery>>>>,
}

impl<C: Chromosome, T> EvolutionContext<C, T> {
    pub fn index(&self) -> usize {
        self.index
    }

    pub fn metrics(&self) -> &MetricSet {
        &self.metrics
    }

    pub fn score(&self) -> Option<&Score> {
        self.score.as_ref()
    }

    pub fn ecosystem(&self) -> &Ecosystem<C> {
        &self.ecosystem
    }

    pub fn front(&self) -> Arc<RwLock<Front<Phenotype<C>>>> {
        self.front.clone()
    }

    pub fn get_or_create_control(&mut self) -> EngineControl {
        if self.control.is_none() {
            let (one, two) = EngineControl::pair();
            self.control = Some(one);
            return two;
        }

        self.control.as_ref().unwrap().clone()
    }

    pub(crate) fn try_advance_one(&mut self) -> RadiateResult<bool> {
        self.index += 1;

        let best = self.ecosystem.get_phenotype(0);
        let best_improved = self
            .metrics
            .improvements()
            .map(|m| m.last_value() > 0.0)
            .unwrap_or(false);

        if best_improved && let Some(best) = best {
            self.score = best.score().cloned();
            self.best = self.problem.decode(best.genotype());
        }

        self.metrics
            .replace(metric!(metric_names::INDEX, self.index));
        self.metrics.bump(self.index as u64);

        Ok(best_improved)
    }
}

impl<C, T> From<EngineConfig<C, T>> for EvolutionContext<C, T>
where
    C: Chromosome + Clone,
    T: Clone,
{
    fn from(config: EngineConfig<C, T>) -> Self {
        if let Some(generation) = config.generation() {
            return EvolutionContext {
                ecosystem: generation.ecosystem().clone(),
                best: generation.value().clone(),
                index: generation.index(),
                metrics: generation.metrics().clone(),
                score: Some(generation.score().clone()),
                front: config.front(),
                objective: config.objective().clone(),
                problem: config.problem().clone(),
                control: None,
                exprs: generation.exprs(),
            };
        }

        let initial_genotype = config
            .ecosystem()
            .get_genotype(0)
            .map(|geno| config.problem().decode(geno));

        EvolutionContext {
            ecosystem: config.ecosystem().clone(),
            best: initial_genotype.unwrap(),
            index: 0,
            metrics: MetricSet::default(),
            score: None,
            front: config.front(),
            objective: config.objective().clone(),
            problem: config.problem().clone(),
            control: None,
            exprs: config.exprs(),
        }
    }
}