logaritmisk/trueskill-tt
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rename d to diff, and t to team

Browse Source
This commit is contained in:
Anders Olsson
2022-12-29 20:38:36 +01:00
parent e3906aebaa
commit 05f178641c
1 changed files with 26 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
src/game.rs
View File

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