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.best_algorithm.clone()
-    }
-    pub fn calculate_formula_debug(&mut self) -> Formula {
-        for _ in 0..self.iterations {
-            self.best_algorithm = self.iterate();
-            self.best_algorithm.display_tree();
-        }
-        self.best_algorithm.clone()
-    }
-    fn iterate(&self) -> Formula {
-        let best_similarity = Learner::get_similarity(
                 &self.expected_outputs,
                 &self.best_algorithm.run(self.inputs.clone()),
-        )
+            );
-        .unwrap();
+            let found_best = self.iterate();
-        let mut formulas: Vec<(Formula, f64)> =
+            if found_best.1 > current_best.unwrap_or(0.) {
-            vec![(self.best_algorithm.clone(), best_similarity)];
+                self.best_algorithm = found_best.0;
+            }
+        }
+        self.best_algorithm.clone()
+    }
+    pub fn calculate_formula_debug(&mut self, tree: bool, sim: bool) -> Formula {
+        for _ in 0..self.iterations {
+            let current_best = Learner::get_similarity(
+                &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, f64) {
+        let mut formulas: Vec<(Formula, f64)> = vec![];
         for _ in 0..self.formulas_per_iteration {
             let mut formula = self.best_algorithm.clone();
             Learner::mutate_formula_randomly(&mut formula);
@@ -71,12 +86,14 @@ impl Learner {
                 }
             })
             .unwrap()
-            .0
             .clone()
     }
     fn mutate_formula_randomly(formula: &mut Formula) {
+        let amount_of_mutations = random_range(1..4);
+        for _ in 0..amount_of_mutations {
             let mut editor = formula.modify_random_node();
             let decided_action = random_range(0..4);
+
             if decided_action == ACTION_ADD {
                 editor.add_node(editor.get_random_node());
             } else if decided_action == ACTION_REMOVE {
@@ -87,6 +104,7 @@ impl Learner {
                 editor.mutate_node();
             }
         }
+    }
     pub fn get_similarity(expected_output: &Vec<f64>, real_output: &Vec<f64>) -> Result<f64, ()> {
         if expected_output.len() != real_output.len() {
             return Err(());

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 => {