From 05f178641cb52971cb68908105d18e739b6cc29d Mon Sep 17 00:00:00 2001
From: Anders Olsson <anders.e.olsson@gmail.com>
Date: Thu, 29 Dec 2022 20:38:36 +0100
Subject: [PATCH] Rename d to diff, and t to team

---
 src/game.rs | 52 ++++++++++++++++++++++++++--------------------------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/src/game.rs b/src/game.rs
index 9dccb80..4b9ab7e 100644
--- a/src/game.rs
+++ b/src/game.rs
@@ -108,7 +108,7 @@ impl Game {
     fn likelihood_teams(&mut self) -> Vec<Gaussian> {
         let o = sort_perm(&self.result, true);
 
-        let mut t = o
+        let mut team = o
             .iter()
             .map(|&e| {
                 let performance = self.teams[e]
@@ -125,7 +125,7 @@ impl Game {
             })
             .collect::<Vec<_>>();
 
-        let mut d = t
+        let mut diff = team
             .windows(2)
             .map(|w| DiffMessage {
                 prior: w[0].prior - w[1].prior,
@@ -163,49 +163,49 @@ impl Game {
         while tuple_gt(step, 1e-6) && iter < 10 {
             step = (0.0, 0.0);
 
-            for e in 0..d.len() - 1 {
-                d[e].prior = t[e].posterior_win() - t[e + 1].posterior_lose();
+            for e in 0..diff.len() - 1 {
+                diff[e].prior = team[e].posterior_win() - team[e + 1].posterior_lose();
 
                 if iter == 0 {
-                    self.evidence *= evidence(&d, &margin, &tie, e);
+                    self.evidence *= evidence(&diff, &margin, &tie, e);
                 }
 
-                d[e].likelihood = approx(d[e].prior, margin[e], tie[e]) / d[e].prior;
-                let likelihood_lose = t[e].posterior_win() - d[e].likelihood;
-                step = tuple_max(step, t[e + 1].likelihood_lose.delta(likelihood_lose));
-                t[e + 1].likelihood_lose = likelihood_lose;
+                diff[e].likelihood = approx(diff[e].prior, margin[e], tie[e]) / diff[e].prior;
+                let likelihood_lose = team[e].posterior_win() - diff[e].likelihood;
+                step = tuple_max(step, team[e + 1].likelihood_lose.delta(likelihood_lose));
+                team[e + 1].likelihood_lose = likelihood_lose;
             }
 
-            for e in (1..d.len()).rev() {
-                d[e].prior = t[e].posterior_win() - t[e + 1].posterior_lose();
+            for e in (1..diff.len()).rev() {
+                diff[e].prior = team[e].posterior_win() - team[e + 1].posterior_lose();
 
-                if iter == 0 && e == d.len() - 1 {
-                    self.evidence *= evidence(&d, &margin, &tie, e);
+                if iter == 0 && e == diff.len() - 1 {
+                    self.evidence *= evidence(&diff, &margin, &tie, e);
                 }
 
-                d[e].likelihood = approx(d[e].prior, margin[e], tie[e]) / d[e].prior;
-                let likelihood_win = t[e + 1].posterior_lose() + d[e].likelihood;
-                step = tuple_max(step, t[e].likelihood_win.delta(likelihood_win));
-                t[e].likelihood_win = likelihood_win;
+                diff[e].likelihood = approx(diff[e].prior, margin[e], tie[e]) / diff[e].prior;
+                let likelihood_win = team[e + 1].posterior_lose() + diff[e].likelihood;
+                step = tuple_max(step, team[e].likelihood_win.delta(likelihood_win));
+                team[e].likelihood_win = likelihood_win;
             }
 
             iter += 1;
         }
 
-        if d.len() == 1 {
-            self.evidence = evidence(&d, &margin, &tie, 0);
+        if diff.len() == 1 {
+            self.evidence = evidence(&diff, &margin, &tie, 0);
 
-            d[0].prior = t[0].posterior_win() - t[1].posterior_lose();
-            d[0].likelihood = approx(d[0].prior, margin[0], tie[0]) / d[0].prior;
+            diff[0].prior = team[0].posterior_win() - team[1].posterior_lose();
+            diff[0].likelihood = approx(diff[0].prior, margin[0], tie[0]) / diff[0].prior;
         }
 
-        let t_end = t.len() - 1;
-        let d_end = d.len() - 1;
+        let t_end = team.len() - 1;
+        let d_end = diff.len() - 1;
 
-        t[0].likelihood_win = t[1].posterior_lose() + d[0].likelihood;
-        t[t_end].likelihood_lose = t[t_end - 1].posterior_win() - d[d_end].likelihood;
+        team[0].likelihood_win = team[1].posterior_lose() + diff[0].likelihood;
+        team[t_end].likelihood_lose = team[t_end - 1].posterior_win() - diff[d_end].likelihood;
 
-        o.iter().map(|&e| t[e].likelihood()).collect::<Vec<_>>()
+        o.iter().map(|&e| team[e].likelihood()).collect::<Vec<_>>()
     }
 
     pub fn posteriors(&self) -> Vec<Vec<Gaussian>> {