diff --git a/gemla/src/bracket/genetic_state.rs b/gemla/src/bracket/genetic_state.rs index bfdaa06..c86dd4e 100644 --- a/gemla/src/bracket/genetic_state.rs +++ b/gemla/src/bracket/genetic_state.rs @@ -2,10 +2,9 @@ /// A trait used to interact with the internal state of nodes within the genetic bracket pub trait GeneticState { - /// Runs a simulation on the state object in order to guage it's fitness. /// - iterations: the number of iterations (learning cycles) that the current state should simulate - /// + /// /// This will be called for every node in a bracket before evaluating it's fitness against other nodes. fn run_simulation(&mut self, iterations: u64); @@ -15,4 +14,4 @@ pub trait GeneticState { /// Initializes a new instance of a genetic state. fn initialize() -> Self; -} \ No newline at end of file +} diff --git a/gemla/src/bracket/mod.rs b/gemla/src/bracket/mod.rs index 40aaeab..023c2ed 100644 --- a/gemla/src/bracket/mod.rs +++ b/gemla/src/bracket/mod.rs @@ -3,16 +3,16 @@ pub mod genetic_state; use super::file_linked::FileLinked; use super::tree; +use serde::de::DeserializeOwned; +use serde::{Deserialize, Serialize}; use std::fmt; use std::str::FromStr; use std::string::ToString; -use serde::de::DeserializeOwned; -use serde::{Deserialize, Serialize}; #[derive(Clone, Debug, Serialize, Deserialize)] #[serde(tag = "enumType", content = "enumContent")] pub enum IterationScaling { - Linear(u32) + Linear(u32), } impl Default for IterationScaling { @@ -23,105 +23,98 @@ impl Default for IterationScaling { impl fmt::Display for IterationScaling { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{}", serde_json::to_string(self).expect("Unable to deserialize IterationScaling struct")) + write!( + f, + "{}", + serde_json::to_string(self).expect("Unable to deserialize IterationScaling struct") + ) } } - #[derive(Serialize, Deserialize, Clone, Debug)] pub struct Bracket { tree: tree::Tree, step: u64, - iteration_scaling: IterationScaling + iteration_scaling: IterationScaling, } impl fmt::Display for Bracket { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{}", serde_json::to_string(self).expect("Unable to deserialize Bracket struct")) + write!( + f, + "{}", + serde_json::to_string(self).expect("Unable to deserialize Bracket struct") + ) } } -impl Bracket - where T: genetic_state::GeneticState + ToString + FromStr + Default + fmt::Display + DeserializeOwned + Serialize + Clone +impl Bracket +where + T: genetic_state::GeneticState + + ToString + + FromStr + + Default + + fmt::Display + + DeserializeOwned + + Serialize + + Clone, { - pub fn initialize(file_path: String) -> Result, String> - { + pub fn initialize(file_path: String) -> Result, String> { FileLinked::new( - Bracket - { + Bracket { tree: btree!(T::initialize()), step: 0, - iteration_scaling: IterationScaling::default() - } - ,file_path) + iteration_scaling: IterationScaling::default(), + }, + file_path, + ) } - pub fn iteration_scaling(&mut self, iteration_scaling: IterationScaling) -> &mut Self - { + pub fn iteration_scaling(&mut self, iteration_scaling: IterationScaling) -> &mut Self { self.iteration_scaling = iteration_scaling; self } - pub fn create_new_branch(&self, height: u64) -> tree::Tree - { - if height == 1 - { + pub fn create_new_branch(&self, height: u64) -> tree::Tree { + if height == 1 { let mut base_node = btree!(T::initialize()); - base_node.val.run_simulation( - match self.iteration_scaling - { - IterationScaling::Linear(x) => (x * (height as u32)).into() - } - ); + base_node.val.run_simulation(match self.iteration_scaling { + IterationScaling::Linear(x) => (x as u64) * height, + }); - btree!(base_node.val.clone()) - } - else - { + btree!(base_node.val) + } else { let left = self.create_new_branch(height - 1); let right = self.create_new_branch(height - 1); - let mut new_val = if left.val.get_fit_score() >= right.val.get_fit_score() - { + let mut new_val = if left.val.get_fit_score() >= right.val.get_fit_score() { left.val.clone() - } - else { + } else { right.val.clone() }; - new_val.run_simulation( - match self.iteration_scaling - { - IterationScaling::Linear(x) => (x * (height as u32)).into() - } - ); + new_val.run_simulation(match self.iteration_scaling { + IterationScaling::Linear(x) => (x as u64) * height, + }); - btree!(new_val, Some(left), Some(right)) + btree!(new_val, left, right) } } - pub fn run_simulation_step(&mut self) -> &mut Self - { + pub fn run_simulation_step(&mut self) -> &mut Self { let new_branch = self.create_new_branch(self.step + 1); - self.tree.val.run_simulation( - match self.iteration_scaling - { - IterationScaling::Linear(x) => ((x as u64) * (self.step + 1)).into() - } - ); + self.tree.val.run_simulation(match self.iteration_scaling { + IterationScaling::Linear(x) => ((x as u64) * (self.step + 1)), + }); - let new_val = if new_branch.val.get_fit_score() >= self.tree.val.get_fit_score() - { + let new_val = if new_branch.val.get_fit_score() >= self.tree.val.get_fit_score() { new_branch.val.clone() - } - else - { + } else { self.tree.val.clone() }; - - self.tree = btree!(new_val, Some(new_branch), Some(self.tree.clone())); + self.tree = btree!(new_val, new_branch, self.tree.clone()); self.step += 1; diff --git a/gemla/src/file_linked/mod.rs b/gemla/src/file_linked/mod.rs index 3f7320d..71a11f9 100644 --- a/gemla/src/file_linked/mod.rs +++ b/gemla/src/file_linked/mod.rs @@ -22,10 +22,7 @@ where T: ToString, { pub fn new(val: T, path: String) -> Result, String> { - let result = FileLinked { - val, - path, - }; + let result = FileLinked { val, path }; result.write_data()?; diff --git a/gemla/src/tests/bracket.rs b/gemla/src/tests/bracket.rs index 2b4d559..cfae5d5 100644 --- a/gemla/src/tests/bracket.rs +++ b/gemla/src/tests/bracket.rs @@ -1,21 +1,19 @@ use super::super::bracket; +use serde::{Deserialize, Serialize}; +use std::fmt; use std::str::FromStr; use std::string::ToString; -use std::fmt; -use serde::{Deserialize, Serialize}; #[derive(Default, Deserialize, Serialize, Clone)] struct TestState { - pub score: f64 + pub score: f64, } -impl FromStr for TestState -{ +impl FromStr for TestState { type Err = String; - fn from_str(s: &str) -> Result - { + fn from_str(s: &str) -> Result { toml::from_str(s).map_err(|_| format!("Unable to parse string {}", s)) } } @@ -33,8 +31,7 @@ impl TestState { } impl bracket::genetic_state::GeneticState for TestState { - fn run_simulation(&mut self, iterations: u64) - { + fn run_simulation(&mut self, iterations: u64) { self.score += iterations as f64; } @@ -43,15 +40,12 @@ impl bracket::genetic_state::GeneticState for TestState { } fn initialize() -> Self { - TestState { - score: 0.0 - } + TestState { score: 0.0 } } } #[test] fn test_new() { - let bracket = bracket::Bracket::::initialize("./temp".to_string()) .expect("Bracket failed to initialize"); @@ -69,11 +63,13 @@ fn test_run() { let mut bracket = bracket::Bracket::::initialize("./temp".to_string()) .expect("Bracket failed to initialize"); - bracket.mutate(|b| drop(b.iteration_scaling(bracket::IterationScaling::Linear(2)))) + bracket + .mutate(|b| drop(b.iteration_scaling(bracket::IterationScaling::Linear(2)))) .expect("Failed to set iteration scaling"); for _ in 0..3 { - bracket.mutate(|b| drop(b.run_simulation_step())) + bracket + .mutate(|b| drop(b.run_simulation_step())) .expect("Failed to run step"); } @@ -82,26 +78,26 @@ fn test_run() { format!("{{\"tree\":{},\"step\":3,\"iteration_scaling\":{{\"enumType\":\"Linear\",\"enumContent\":2}}}}", btree!( TestState::new(12.0), - Some(btree!( + btree!( TestState::new(12.0), - Some(btree!(TestState::new(6.0), - Some(btree!(TestState::new(2.0))), - Some(btree!(TestState::new(2.0))))), - Some(btree!(TestState::new(6.0), - Some(btree!(TestState::new(2.0))), - Some(btree!(TestState::new(2.0))))) - )), - Some(btree!( + btree!(TestState::new(6.0), + btree!(TestState::new(2.0)), + btree!(TestState::new(2.0))), + btree!(TestState::new(6.0), + btree!(TestState::new(2.0)), + btree!(TestState::new(2.0))) + ), + btree!( TestState::new(12.0), - Some(btree!(TestState::new(6.0), - Some(btree!(TestState::new(2.0))), - Some(btree!(TestState::new(2.0))))), - Some(btree!(TestState::new(6.0), - Some(btree!(TestState::new(2.0))), - Some(btree!(TestState::new(2.0))))) - )) - )) + btree!(TestState::new(6.0), + btree!(TestState::new(2.0)), + btree!(TestState::new(2.0))), + btree!(TestState::new(6.0), + btree!(TestState::new(2.0)), + btree!(TestState::new(2.0)))) + ) + ) ); std::fs::remove_file("./temp").expect("Unable to remove file"); -} \ No newline at end of file +} diff --git a/gemla/src/tests/file_linked.rs b/gemla/src/tests/file_linked.rs index ab4d755..36546af 100644 --- a/gemla/src/tests/file_linked.rs +++ b/gemla/src/tests/file_linked.rs @@ -4,7 +4,7 @@ use std::fs; #[test] fn test_mutate() -> Result<(), String> { - let tree = btree!(1, Some(btree!(2)), Some(btree!(3, Some(btree!(4)),))); + let tree = btree!(1, btree!(2), btree!(3, btree!(4),)); let mut linked_tree = FileLinked::new(tree, String::from("test.txt"))?; assert_eq!( diff --git a/gemla/src/tests/tree.rs b/gemla/src/tests/tree.rs index fe4bca7..890bbb8 100644 --- a/gemla/src/tests/tree.rs +++ b/gemla/src/tests/tree.rs @@ -19,14 +19,14 @@ fn test_new() { #[test] fn test_fmt() { assert_eq!( - format!("{}", btree!("foo", Some(btree!("bar")),),), + format!("{}", btree!("foo", btree!("bar"),),), "{\"val\":\"foo\",\"left\":{\"val\":\"bar\",\"left\":null,\"right\":null},\"right\":null}" ); } #[test] fn test_fmt_node() { - let t = btree!(17, Some(btree!(16)), Some(btree!(12))); + let t = btree!(17, btree!(16), btree!(12)); assert_eq!(Tree::fmt_node(&t.left), "16"); assert_eq!( Tree::fmt_node(&Some(Box::new(btree!(btree!("foo"))))), diff --git a/gemla/src/tree/mod.rs b/gemla/src/tree/mod.rs index 274c167..f5486f7 100644 --- a/gemla/src/tree/mod.rs +++ b/gemla/src/tree/mod.rs @@ -77,15 +77,16 @@ pub struct Tree { macro_rules! btree { ($val:expr, $l:expr, $r:expr) => { $crate::tree::Tree::new( - $val, - $l.and_then(|l| Some(Box::new(l))), - $r.and_then(|r| Some(Box::new(r)))) + $val, + Some(Box::new($l)), + Some(Box::new($r)), + ) }; ($val:expr, , $r:expr) => { - $crate::tree::Tree::new($val, None, $r.and_then(|r| Some(Box::new(r)))) + $crate::tree::Tree::new($val, None, Some(Box::new($r))) }; ($val:expr, $l:expr,) => { - $crate::tree::Tree::new($val, $l.and_then(|l| Some(Box::new(l))), None) + $crate::tree::Tree::new($val, Some(Box::new($l)), None) }; ($val:expr) => { $crate::tree::Tree::new($val, None, None)