Finding algorithm now kinda works

src/learner.rs

@@ -31,25 +31,40 @@ impl Learner {
     }
     pub fn calculate_formula(&mut self) -> Formula {
         for _ in 0..self.iterations {
-            self.best_algorithm = self.iterate()
+            let current_best = Learner::get_similarity(
+                &self.expected_outputs,
+                &self.best_algorithm.run(self.inputs.clone()),
+            );
+            let found_best = self.iterate();
+            if found_best.1 > current_best.unwrap_or(0.) {
+                self.best_algorithm = found_best.0;
+            }
         }
         self.best_algorithm.clone()
     }
-    pub fn calculate_formula_debug(&mut self) -> Formula {
+    pub fn calculate_formula_debug(&mut self, tree: bool, sim: bool) -> Formula {
         for _ in 0..self.iterations {
-            self.best_algorithm = self.iterate();
+            let current_best = Learner::get_similarity(
-            self.best_algorithm.display_tree();
+                &self.expected_outputs,
+                &self.best_algorithm.run(self.inputs.clone()),
+            );
+            let found_best = self.iterate();
+
+            if sim {
+                println!("{:?}", &found_best.1);
+            }
+            if tree {
+                self.best_algorithm.display_tree();
+            }
+
+            if found_best.1 > current_best.unwrap_or(0.) {
+                self.best_algorithm = found_best.0;
+            }
         }
         self.best_algorithm.clone()
     }
-    fn iterate(&self) -> Formula {
+    fn iterate(&self) -> (Formula, f64) {
-        let best_similarity = Learner::get_similarity(
+        let mut formulas: Vec<(Formula, f64)> = vec![];
-            &self.expected_outputs,
-            &self.best_algorithm.run(self.inputs.clone()),
-        )
-        .unwrap();
-        let mut formulas: Vec<(Formula, f64)> =
-            vec![(self.best_algorithm.clone(), best_similarity)];
         for _ in 0..self.formulas_per_iteration {
             let mut formula = self.best_algorithm.clone();
             Learner::mutate_formula_randomly(&mut formula);
@@ -71,20 +86,23 @@ impl Learner {
                 }
             })
             .unwrap()
-            .0
             .clone()
     }
     fn mutate_formula_randomly(formula: &mut Formula) {
-        let mut editor = formula.modify_random_node();
+        let amount_of_mutations = random_range(1..4);
-        let decided_action = random_range(0..4);
+        for _ in 0..amount_of_mutations {
-        if decided_action == ACTION_ADD {
+            let mut editor = formula.modify_random_node();
-            editor.add_node(editor.get_random_node());
+            let decided_action = random_range(0..4);
-        } else if decided_action == ACTION_REMOVE {
+
-            editor.remove_node(None);
+            if decided_action == ACTION_ADD {
-        } else if decided_action == ACTION_INSERT {
+                editor.add_node(editor.get_random_node());
-            editor.insert_node(editor.get_random_node(), None);
+            } else if decided_action == ACTION_REMOVE {
-        } else if decided_action == ACTION_MUTATE {
+                editor.remove_node(None);
-            editor.mutate_node();
+            } else if decided_action == ACTION_INSERT {
+                editor.insert_node(editor.get_random_node(), None);
+            } else if decided_action == ACTION_MUTATE {
+                editor.mutate_node();
+            }
         }
     }
     pub fn get_similarity(expected_output: &Vec<f64>, real_output: &Vec<f64>) -> Result<f64, ()> {

src/main.rs

@@ -9,11 +9,11 @@ mod tests;
 fn main() {
     let mut learner = Learner::new(
         vec![0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.],
-        vec![0., 2., 4., 6., 8., 10., 12., 14., 16., 19., 20.],
+        vec![0., 1., 4., 9., 16., 25., 36., 49., 64., 81., 100.],
+        None,
         None,
-        Some(10000),
     );
-    let formula = learner.calculate_formula_debug();
+    let formula = learner.calculate_formula();
     println!("{:?}", formula.as_text());
     formula.display_tree();
 }

src/node/mod.rs

@@ -88,7 +88,7 @@ impl Node {
             } => {
                 self.max_children_count = max_args.clone();
                 if let Some(x) = max_args {
-                    self.children.truncate(x.clone());
+                    self.children.resize(x.clone(), Node::number(0.));
                 }
             }
             NodeHandler::Variable => {