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
use serde_json;
use std::fs::File;
use std::io::{BufReader, Read, Write};
use ::*;
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct EASettings {
pub rng_seed: u32,
pub pop_size: u32,
pub param_count: u32,
pub gen_count: u32,
pub tour_size: u32,
pub use_elite: bool,
pub x_type: CrossoverOperator,
pub x_prob: f32,
pub x_alpha: f32,
pub mut_type: MutationOperator,
pub mut_prob: f32,
pub mut_sigma: f32,
}
impl EASettings {
pub fn new(pop_size: u32, gen_count: u32, param_count: u32) -> EASettings {
EASettings{
rng_seed: 0,
param_count: param_count,
pop_size: pop_size,
gen_count: gen_count,
tour_size: 3,
use_elite: true,
x_type: CrossoverOperator::BlxAlpha,
x_prob: 0.7f32,
x_alpha: 0.1f32,
mut_type: MutationOperator::Gaussian,
mut_prob: 1f32 / (param_count as f32),
mut_sigma: 0.1f32,
}
}
pub fn from_json(filename: &str) -> Self {
let file = File::open(filename).expect("Can not open file");
let mut buf_reader = BufReader::new(file);
let mut json_str = String::new();
buf_reader.read_to_string(&mut json_str).expect("Can not read file contents");
let res: EASettings = serde_json::from_str(&json_str).expect("Can not deserialize json to EASettings");
res
}
pub fn to_json(&self, filename: &str) {
let mut file = File::create(&filename).expect("Can not open file");
let json_str = serde_json::to_string(&self).expect("Can not serialize to json from EASettings");
file.write_all(json_str.as_bytes()).expect("Can not write to file");
}
}
impl Jsonable for EASettings {
type T = Self;
}
#[allow(dead_code)]
#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
pub enum CrossoverOperator {
Arithmetic,
BlxAlpha,
}
#[allow(dead_code)]
#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
pub enum MutationOperator {
Gaussian,
Uniform,
}
#[cfg(test)]
mod test {
use settings::*;
#[test]
fn test_json() {
let settings = EASettings::new(100, 100, 100);
let filename = "test_json.json";
settings.to_json(&filename);
let settings2 = EASettings::from_json(&filename);
assert!(settings.gen_count == settings2.gen_count);
assert!(settings.mut_prob == settings2.mut_prob);
assert!(settings.mut_sigma == settings2.mut_sigma);
assert!(settings.mut_type == settings2.mut_type);
assert!(settings.param_count == settings2.param_count);
assert!(settings.pop_size == settings2.pop_size);
assert!(settings.rng_seed == settings2.rng_seed);
assert!(settings.tour_size == settings2.tour_size);
assert!(settings.use_elite == settings2.use_elite);
assert!(settings.x_type == settings2.x_type);
assert!(settings.x_alpha == settings2.x_alpha);
assert!(settings.x_prob == settings2.x_prob);
}
}