spdkit 0.1.0

spdkit: Structure Predication Development Kit
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
140
141
142
143
144
145
146
147
148
149
150
151
152

// [[file:../spdkit.note::*imports][imports:1]]
use std::marker::PhantomData;

use crate::encoding::*;
use crate::random::*;
// imports:1 ends here

// [[file:../spdkit.note::8469d257][8469d257]]
pub trait Genome: Clone + Send + std::hash::Hash + std::cmp::Eq {
    //
}
// 8469d257 ends here

// [[file:../spdkit.note::edee42d4][edee42d4]]
#[derive(Clone, Debug)]
pub struct Individual<G>
where
    G: Genome,
{
    raw_score: f64,
    genome: G,
}

/// Evaluate the objective value of an individual.
///
/// Potentially expensive operation.
pub trait EvaluateObjectiveValue<G>: Clone + std::fmt::Debug + std::marker::Sync
where
    G: Genome,
{
    fn evaluate(&self, genome: &G) -> f64;
}

impl<G> Individual<G>
where
    G: Genome,
{
    /// Create a new individual from a genome and evaluation function for raw
    /// score.
    pub fn new<E>(genome: G, func: &mut E) -> Self
    where
        E: EvaluateObjectiveValue<G>,
    {
        let raw_score = func.evaluate(&genome);
        Self { genome, raw_score }
    }

    /// Return genome of this individual.
    pub fn genome(&self) -> &G {
        &self.genome
    }

    /// Return the evaluated objective value of this individual.
    ///
    /// This is sometimes referred to as objective fitness since this
    /// measurement is based solely on an individual's geno/phenotype and is not
    /// affected by other factors such as the current makeup of the population
    ///
    /// # Reference
    ///
    /// * De Jong 2006
    ///
    pub fn objective_value(&self) -> f64 {
        self.raw_score
    }
}

impl<G> AsRef<Individual<G>> for Individual<G>
where
    G: Genome,
{
    fn as_ref(&self) -> &Self {
        self
    }
}
// edee42d4 ends here

// [[file:../spdkit.note::ad65eec7][ad65eec7]]
use gut::prelude::*;

/// blanket implementation for creating new individuals from genomes
pub(crate) trait Create<G>
where
    G: Genome,
{
    fn create(&self, genomes: impl IntoIterator<Item = G>) -> Vec<Individual<G>>;
}

impl<G, T> Create<G> for T
where
    G: Genome,
    T: EvaluateObjectiveValue<G>,
{
    /// Create individuals from genomes.
    fn create(&self, genomes: impl IntoIterator<Item = G>) -> Vec<Individual<G>> {
        // remove possible duplicates
        let genomes: Vec<_> = genomes.into_iter().collect();
        let n = genomes.len();
        let genomes: std::collections::HashSet<_> = genomes.into_iter().collect();
        let m = n - genomes.len();
        if m > 0 {
            info!("Removed {m} duplicates from {n} created genomes.");
        }

        // 2022-01-20: allow run in parallel
        genomes
            .into_par_iter()
            .map(|g| {
                let raw_score = self.evaluate(&g);
                Individual { genome: g, raw_score }
            })
            .collect()
    }
}
// ad65eec7 ends here

// [[file:../spdkit.note::*onemax][onemax:1]]
#[derive(Clone, Debug)]
pub struct OneMax;

impl EvaluateObjectiveValue<Binary> for OneMax {
    fn evaluate(&self, genome: &Binary) -> f64 {
        let s: usize = genome.iter().filter(|&b| *b).count();
        s as f64
    }
}
// onemax:1 ends here

// [[file:../spdkit.note::*test][test:1]]
#[cfg(test)]
mod test {
    use super::*;
    use crate::encoding::Binary;

    #[test]
    fn test() {
        let codes: Vec<_> = vec!["10110", "01010"]
            .iter()
            .map(|x| Binary::from_str(x))
            .collect();

        let indvs = OneMax.create(codes);
        for indv in indvs.iter() {
            println!(
                "indv {:}, objective value = {}",
                indv.genome(),
                indv.objective_value()
            );
        }
    }
}
// test:1 ends here