neat_lib 0.1.1

Rust implementation of NeuroEvolution of Augmenting Topologies
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

use serde::{Deserialize, Serialize};
use crate::neat::math::clamp;
use rand_distr::{Normal, Distribution};
use std::ops::{Add, Sub, Mul, Div, AddAssign};
use rand::Rng;

#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub struct FloatAttribute(f64);

impl FloatAttribute {
    pub fn new(value: f64) -> Self {
        FloatAttribute(value)
    }

    pub fn new_norm(mean: f64, std_dev: f64) -> Self {
        let normal = Normal::new(mean, std_dev).unwrap();
        FloatAttribute(normal.sample(&mut rand::thread_rng()))
    }

    pub fn abs(&self) -> f64 {
        self.0.abs()
    }

    pub fn mutate(&mut self, replace_rate: f64, mutate_rate: f64, mutate_power: f64, min: f64, max: f64, mean: f64, std_dev: f64 ) {
        let mut rng = rand::thread_rng();
        let rand = rng.gen_range(0.0..1.0);
        if rand < mutate_rate {
            let normal = Normal::new(0.0, mutate_power).unwrap();
            self.0 = clamp(self.0 + normal.sample(&mut rng), min, max);
            return
        }

        if rand < replace_rate + mutate_rate {
            self.0 = FloatAttribute::init_value(&mut rng, mean, std_dev, min, max)
        }
    }

    pub fn set_value(&mut self, value: f64) {
        self. 0 = value
    }

    pub fn value(&self) -> f64 {
        self.0
    }

    fn init_value(rng: &mut impl Rng, mean: f64, std_dev: f64, min: f64, max: f64) -> f64 {
        let normal = Normal::new(mean, std_dev).unwrap();
        clamp(normal.sample(rng), min, max)
    }
}

impl Add for FloatAttribute {
    type Output = Self;
    fn add(self, rhs: Self) -> Self::Output {
        return FloatAttribute(self.value() + rhs.value())
    }
}

impl Sub for FloatAttribute {
    type Output = Self;
    fn sub(self, rhs: Self) -> Self::Output {
        return FloatAttribute(self.value() - rhs.value())
    }
}

impl Mul for FloatAttribute {
    type Output = Self;
    fn mul(self, rhs: Self) -> Self::Output {
        return FloatAttribute(self.value() * rhs.value())
    }
}


impl Div for FloatAttribute {
    type Output = Self;
    fn div(self, rhs: Self) -> Self::Output {
        return FloatAttribute(self.value() / rhs.value())
    }
}

impl AddAssign for FloatAttribute {
    fn add_assign(&mut self, rhs: Self) {
        self.set_value(self.value() + rhs.value())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_float_attribute_mutate() {
        let mut float = FloatAttribute::new(0.0);
        float.mutate(0.0, 1.0, 1.0, -1.0, 1.0, 0.0, 0.0);
        assert!(float.value() <= 1.0, "float should be smaller than 1.0")
    }

    #[test]
    fn test_float_attribute_ops() {
        let float1 = FloatAttribute::new(1.0);
        let float2 = FloatAttribute::new(1.0);
        assert!((float1 + float2).value() == 2.0, "+");
        assert!((float1 - float2).value() == 0.0, "-");
        assert!((float1 * float2).value() == 1.0, "*");
        assert!((float1 / float2).value() == 1.0, "/");
    }
}