More test passing for History

src/batch.rs

@@ -2,7 +2,7 @@ use std::collections::{HashMap, HashSet};
 
 use crate::{Game, Gaussian, Player, N_INF};
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct Skill {
     pub forward: Gaussian,
     pub backward: Gaussian,
@@ -96,7 +96,6 @@ pub struct Batch {
     pub skills: HashMap<String, Skill>,
     events: Vec<Event>,
     time: f64,
-    agents: HashMap<String, Agent>,
     p_draw: f64,
 }
 
@@ -105,23 +104,27 @@ impl Batch {
         composition: Vec<Vec<Vec<&str>>>,
         results: Vec<Vec<u16>>,
         time: f64,
-        agents: HashMap<String, Agent>,
+        agents: &mut HashMap<String, Agent>,
         p_draw: f64,
     ) -> Self {
         let mut this = Self {
             skills: HashMap::new(),
             events: Vec::new(),
             time,
-            agents,
             p_draw,
         };
 
-        this.add_events(composition, results);
+        this.add_events(composition, results, agents);
 
         this
     }
 
-    pub fn add_events(&mut self, composition: Vec<Vec<Vec<&str>>>, results: Vec<Vec<u16>>) {
+    pub fn add_events(
+        &mut self,
+        composition: Vec<Vec<Vec<&str>>>,
+        results: Vec<Vec<u16>>,
+        agents: &mut HashMap<String, Agent>,
+    ) {
         let this_agent = composition
             .iter()
             .flat_map(|teams| teams.iter())
@@ -130,16 +133,16 @@ impl Batch {
             .collect::<HashSet<_>>();
 
         for a in this_agent {
-            let elapsed = compute_elapsed(self.agents[a].last_time, self.time);
+            let elapsed = compute_elapsed(agents[a].last_time, self.time);
 
             if let Some(skill) = self.skills.get_mut(a) {
                 skill.elapsed = elapsed;
-                skill.forward = self.agents[a].receive(elapsed);
+                skill.forward = agents[a].receive(elapsed);
             } else {
                 self.skills.insert(
                     a.to_string(),
                     Skill {
-                        forward: self.agents[a].receive(elapsed),
+                        forward: agents[a].receive(elapsed),
                         ..Default::default()
                     },
                 );
@@ -173,7 +176,7 @@ impl Batch {
             self.events.push(event);
         }
 
-        self.iteration(from);
+        self.iteration(from, agents);
     }
 
     pub fn posterior(&self, agent: &str) -> Gaussian {
@@ -189,29 +192,33 @@ impl Batch {
             .collect::<HashMap<_, _>>()
     }
 
-    fn within_prior(&self, item: &Item) -> Player {
-        let r = &self.agents[&item.name].player;
+    fn within_prior(&self, item: &Item, agents: &mut HashMap<String, Agent>) -> Player {
+        let r = &agents[&item.name].player;
         let g = self.posterior(&item.name) / item.likelihood;
 
         Player::new(g, r.beta, r.gamma, N_INF)
     }
 
-    pub fn within_priors(&self, event: usize) -> Vec<Vec<Player>> {
+    pub fn within_priors(
+        &self,
+        event: usize,
+        agents: &mut HashMap<String, Agent>,
+    ) -> Vec<Vec<Player>> {
         self.events[event]
             .teams
             .iter()
             .map(|team| {
                 team.items
                     .iter()
-                    .map(|item| self.within_prior(item))
+                    .map(|item| self.within_prior(item, agents))
                     .collect::<Vec<_>>()
             })
             .collect::<Vec<_>>()
     }
 
-    fn iteration(&mut self, from: usize) {
+    fn iteration(&mut self, from: usize, agents: &mut HashMap<String, Agent>) {
         for e in from..self.events.len() {
-            let teams = self.within_priors(e);
+            let teams = self.within_priors(e, agents);
             let result = self.events[e].result();
 
             let g = Game::new(teams, result, self.p_draw);
@@ -230,7 +237,7 @@ impl Batch {
         }
     }
 
-    pub fn convergence(&mut self) -> usize {
+    pub fn convergence(&mut self, agents: &mut HashMap<String, Agent>) -> usize {
         let epsilon = 1e-6;
         let iterations = 20;
 
@@ -240,7 +247,7 @@ impl Batch {
         while (step.0 > epsilon || step.1 > epsilon) && i < iterations {
             let old = self.posteriors();
 
-            self.iteration(0);
+            self.iteration(0, agents);
 
             let new = self.posteriors();
 
@@ -259,36 +266,34 @@ impl Batch {
         i
     }
 
-    /*
-    def convergence(self, epsilon=1e-6, iterations = 20):
-        step, i = (inf, inf), 0
-        while gr_tuple(step, epsilon) and (i < iterations):
-            old = self.posteriors().copy()
-            self.iteration()
-            step = dict_diff(old, self.posteriors())
-            i += 1
-        return i
-    */
-
     pub fn forward_prior_out(&self, agent: &str) -> Gaussian {
         let skill = &self.skills[agent];
 
         skill.forward * skill.likelihood
     }
 
-    /*
-    def backward_prior_out(self, agent):
-        N = self.skills[agent].likelihood*self.skills[agent].backward
-        return N.forget(self.agents[agent].player.gamma, self.skills[agent].elapsed)
-    def new_backward_info(self):
-        for a in self.skills:
-            self.skills[a].backward = self.agents[a].message
-        return self.iteration()
-    def new_forward_info(self):
-        for a in self.skills:
-            self.skills[a].forward = self.agents[a].receive(self.skills[a].elapsed)
-        return self.iteration()
-    */
+    pub fn backward_prior_out(&self, agent: &str, agents: &mut HashMap<String, Agent>) -> Gaussian {
+        let skill = &self.skills[agent];
+        let n = skill.likelihood * skill.backward;
+
+        n.forget(agents[agent].player.gamma, skill.elapsed)
+    }
+
+    pub fn new_backward_info(&mut self, agents: &mut HashMap<String, Agent>) {
+        for (agent, skill) in self.skills.iter_mut() {
+            skill.backward = agents[agent].message;
+        }
+
+        self.iteration(0, agents);
+    }
+
+    pub fn new_forward_info(&mut self, agents: &mut HashMap<String, Agent>) {
+        for (agent, skill) in self.skills.iter_mut() {
+            skill.forward = agents[agent].receive(skill.elapsed);
+        }
+
+        self.iteration(0, agents);
+    }
 }
 
 #[cfg(test)]
@@ -324,7 +329,7 @@ mod tests {
             ],
             vec![vec![1, 0], vec![0, 1], vec![1, 0]],
             0.0,
-            agents,
+            &mut agents,
             0.0,
         );
 
@@ -339,7 +344,7 @@ mod tests {
         assert_eq!(post["c"].mu(), 20.79477925612302);
         assert_eq!(post["c"].sigma(), 7.194481422570443);
 
-        assert_eq!(b.convergence(), 1);
+        assert_eq!(b.convergence(&mut agents), 1);
     }
 
     #[test]
@@ -369,7 +374,7 @@ mod tests {
             ],
             vec![vec![1, 0], vec![0, 1], vec![1, 0]],
             2.0,
-            agents,
+            &mut agents,
             0.0,
         );
 
@@ -384,7 +389,7 @@ mod tests {
         assert_eq!(post["c"].mu(), 24.88968178743119);
         assert_eq!(post["c"].sigma(), 5.866311348102562);
 
-        assert!(b.convergence() > 1);
+        assert!(b.convergence(&mut agents) > 1);
 
         let post = b.posteriors();