More test passing for History

src/history.rs

@@ -51,8 +51,6 @@ impl History {
             })
             .collect::<HashMap<_, _>>();
 
-        println!("{:#?}", agents);
-
         let mut this = Self {
             size: composition.len(),
             batches: Vec::new(),
@@ -75,13 +73,7 @@ impl History {
         results: Vec<Vec<u16>>,
         times: Vec<u64>,
     ) {
-        let o = {
-            let mut o = utils::sortperm(&times);
-            o.reverse();
-            o
-        };
-
-        let o = o;
+        let o = utils::sortperm(&times, false);
         let mut i = 0;
 
         while i < self.size {
@@ -102,7 +94,7 @@ impl History {
                 composition,
                 results,
                 t as f64,
-                self.agents.clone(),
+                &mut self.agents,
                 self.p_draw,
             );
 
@@ -119,16 +111,89 @@ impl History {
         }
     }
 
-    fn iteration(&self) {
-        todo!()
+    fn iteration(&mut self) -> (f64, f64) {
+        let mut step = (0.0, 0.0);
+
+        clean(self.agents.values_mut(), false);
+
+        for j in (0..self.batches.len() - 1).rev() {
+            for agent in self.batches[j + 1].skills.keys() {
+                self.agents.get_mut(agent).unwrap().message =
+                    self.batches[j + 1].backward_prior_out(agent, &mut self.agents);
+            }
+
+            let old = self.batches[j].posteriors();
+
+            self.batches[j].new_backward_info(&mut self.agents);
+
+            let new = self.batches[j].posteriors();
+
+            step = old
+                .iter()
+                .fold(step, |step, (a, old)| tuple_max(step, old.delta(new[a])));
+        }
+
+        clean(self.agents.values_mut(), false);
+
+        for j in 1..self.batches.len() {
+            for agent in self.batches[j - 1].skills.keys() {
+                self.agents.get_mut(agent).unwrap().message =
+                    self.batches[j - 1].forward_prior_out(agent);
+            }
+
+            let old = self.batches[j].posteriors();
+
+            self.batches[j].new_forward_info(&mut self.agents);
+
+            let new = self.batches[j].posteriors();
+
+            step = old
+                .iter()
+                .fold(step, |step, (a, old)| tuple_max(step, old.delta(new[a])));
+        }
+
+        if self.batches.len() == 1 {
+            let old = self.batches[0].posteriors();
+
+            self.batches[0].convergence(&mut self.agents);
+
+            let new = self.batches[0].posteriors();
+
+            step = old
+                .iter()
+                .fold(step, |step, (a, old)| tuple_max(step, old.delta(new[a])));
+        }
+
+        step
     }
 
-    fn convergence(&self) {
+    pub fn convergence(&mut self) -> ((f64, f64), usize) {
         let epsilon = 1e-6;
         let iterations = 30;
-        let verbose = true;
+        let verbose = false;
 
-        todo!()
+        let mut step = (f64::INFINITY, f64::INFINITY);
+        let mut i = 0;
+
+        while (step.0 > epsilon || step.1 > epsilon) && i < iterations {
+            if verbose {
+                print!("Iteration = {}", i);
+            }
+
+            step = self.iteration();
+
+            i += 1;
+
+            if verbose {
+                println!(", step = {:?}", step);
+            }
+        }
+
+        if verbose {
+            println!("End");
+        }
+
+        (step, i)
     }
 
     fn learning_curves(&self) {
@@ -140,6 +205,23 @@ impl History {
     }
 }
 
+fn clean<'a, A: Iterator<Item = &'a mut Agent>>(agents: A, last_time: bool) {
+    for a in agents {
+        a.message = N_INF;
+
+        if last_time {
+            a.last_time = f64::NEG_INFINITY;
+        }
+    }
+}
+
+fn tuple_max(a: (f64, f64), b: (f64, f64)) -> (f64, f64) {
+    (
+        if a.0 > b.0 { a.0 } else { b.0 },
+        if a.1 > b.1 { a.1 } else { b.1 },
+    )
+}
+
 #[cfg(test)]
 mod tests {
     use approx::assert_ulps_eq;
@@ -170,7 +252,7 @@ mod tests {
             priors.insert(k.to_string(), player);
         }
 
-        let h = History::new(
+        let mut h = History::new(
             composition,
             results,
             vec![1, 2, 3],
@@ -194,10 +276,172 @@ mod tests {
         assert_ulps_eq!(observed, expected, epsilon = 0.000001);
 
         let observed = h.batches[1].posterior("a");
-        let p = Game::new(h.batches[1].within_priors(0), vec![0, 1], P_DRAW).posteriors();
+        let p = Game::new(
+            h.batches[1].within_priors(0, &mut h.agents),
+            vec![0, 1],
+            P_DRAW,
+        )
+        .posteriors();
         let expected = p[0][0];
 
         assert_ulps_eq!(observed.mu(), expected.mu(), epsilon = 0.000001);
         assert_ulps_eq!(observed.sigma(), expected.sigma(), epsilon = 0.000001);
     }
+
+    #[test]
+    fn test_one_batch() {
+        let composition = vec![
+            vec![vec!["aj"], vec!["bj"]],
+            vec![vec!["bj"], vec!["cj"]],
+            vec![vec!["cj"], vec!["aj"]],
+        ];
+        let results = vec![vec![1, 0], vec![1, 0], vec![1, 0]];
+        let times = vec![1, 1, 1];
+
+        let mut priors = HashMap::new();
+
+        for k in ["aj", "bj", "cj"] {
+            let player = Player::new(
+                Gaussian::new(25.0, 25.0 / 3.0),
+                25.0 / 6.0,
+                0.15 * 25.0 / 3.0,
+                N_INF,
+            );
+
+            priors.insert(k.to_string(), player);
+        }
+
+        let mut h1 = History::new(
+            composition,
+            results,
+            times,
+            priors,
+            MU,
+            BETA,
+            SIGMA,
+            GAMMA,
+            P_DRAW,
+        );
+
+        assert_ulps_eq!(
+            h1.batches[0].posterior("aj").mu(),
+            22.904409330892914,
+            epsilon = 0.000001
+        );
+        assert_ulps_eq!(
+            h1.batches[0].posterior("aj").sigma(),
+            6.0103304390431,
+            epsilon = 0.000001
+        );
+        assert_ulps_eq!(
+            h1.batches[0].posterior("cj").mu(),
+            25.110318212568806,
+            epsilon = 0.000001
+        );
+        assert_ulps_eq!(
+            h1.batches[0].posterior("cj").sigma(),
+            5.866311348102563,
+            epsilon = 0.000001
+        );
+
+        let (_step, _i) = h1.convergence();
+
+        assert_ulps_eq!(
+            h1.batches[0].posterior("aj").mu(),
+            25.00000000,
+            epsilon = 0.000001
+        );
+        assert_ulps_eq!(
+            h1.batches[0].posterior("aj").sigma(),
+            5.41921200,
+            epsilon = 0.000001
+        );
+        assert_ulps_eq!(
+            h1.batches[0].posterior("cj").mu(),
+            25.00000000,
+            epsilon = 0.000001
+        );
+        assert_ulps_eq!(
+            h1.batches[0].posterior("cj").sigma(),
+            5.41921200,
+            epsilon = 0.000001
+        );
+
+        let composition = vec![
+            vec![vec!["aj"], vec!["bj"]],
+            vec![vec!["bj"], vec!["cj"]],
+            vec![vec!["cj"], vec!["aj"]],
+        ];
+        let results = vec![vec![1, 0], vec![1, 0], vec![1, 0]];
+        let times = vec![1, 2, 3];
+
+        let mut priors = HashMap::new();
+
+        for k in ["aj", "bj", "cj"] {
+            let player = Player::new(
+                Gaussian::new(25.0, 25.0 / 3.0),
+                25.0 / 6.0,
+                25.0 / 300.0,
+                N_INF,
+            );
+
+            priors.insert(k.to_string(), player);
+        }
+
+        let mut h2 = History::new(
+            composition,
+            results,
+            times,
+            priors,
+            MU,
+            BETA,
+            SIGMA,
+            GAMMA,
+            P_DRAW,
+        );
+
+        assert_ulps_eq!(
+            h2.batches[2].posterior("aj").mu(),
+            22.90352227792141,
+            epsilon = 0.000001
+        );
+        assert_ulps_eq!(
+            h2.batches[2].posterior("aj").sigma(),
+            6.011017301320632,
+            epsilon = 0.000001
+        );
+        assert_ulps_eq!(
+            h2.batches[2].posterior("cj").mu(),
+            25.110702468366718,
+            epsilon = 0.000001
+        );
+        assert_ulps_eq!(
+            h2.batches[2].posterior("cj").sigma(),
+            5.866811597660157,
+            epsilon = 0.000001
+        );
+
+        let (_step, _i) = h2.convergence();
+
+        assert_ulps_eq!(
+            h2.batches[2].posterior("aj").mu(),
+            24.99999999,
+            epsilon = 0.000001
+        );
+        assert_ulps_eq!(
+            h2.batches[2].posterior("aj").sigma(),
+            5.419212002,
+            epsilon = 0.000001
+        );
+        assert_ulps_eq!(
+            h2.batches[2].posterior("cj").mu(),
+            24.99999999,
+            epsilon = 0.000001
+        );
+        assert_ulps_eq!(
+            h2.batches[2].posterior("cj").sigma(),
+            5.419212002,
+            epsilon = 0.000001
+        );
+    }
 }