openskill 0.0.1

Rust implementation of OpenSkill (license free TrueSkill)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use crate::{
    error::OpenSkillError,
    math::{self, normal},
    rating::{to_team_ratings, Rating},
    utils::zip_without_self,
    validate::validate_team,
};

use statrs::distribution::ContinuousCDF;

pub fn predict_win(teams: &Vec<Vec<Rating>>, beta: f64) -> Result<Vec<f64>, OpenSkillError> {
    let beta_squared = beta.powi(2);

    validate_team(&teams)?;

    let num_teams = teams.len();
    let team_ratings = to_team_ratings(teams, None);
    let denom = math::denominator(num_teams, 2);

    Ok(zip_without_self(&team_ratings)
        .map(|(team_i, others)| {
            others
                .iter()
                .map(|team_q| {
                    normal().cdf(
                        ((*team_i).mu - team_q.mu)
                            / math::sigma_bar(
                                team_i.sigma_sq,
                                team_q.sigma_sq,
                                beta_squared,
                                team_i.team_size() + team_q.team_size(),
                            ),
                    )
                })
                .sum::<f64>()
                / denom
        })
        .collect())
}

#[cfg(test)]
mod test {
    use super::*;
    use crate::constant::DEFAULT_BETA;
    use approx::relative_eq;
    use std::iter::zip;

    fn predict_win_test(teams: Vec<Vec<Rating>>, want: Result<Vec<f64>, OpenSkillError>) {
        let got = predict_win(&teams, DEFAULT_BETA);
        match (got.clone(), want.clone()) {
            (Ok(got), Ok(want)) => {
                assert_eq!(got.len(), want.len());
                zip(got.iter(), want.iter()).for_each(|(g, w)| {
                    assert!(
                        relative_eq!(g, w, epsilon = 1e-6, max_relative = 1e-6),
                        "got: {g}, want: {w}",
                    )
                });
            }
            (Err(got), Err(want)) => {
                assert_eq!(got, want);
            }
            _ => assert!(false, "got: {got:?}, want: {want:?}"),
        };
    }

    #[test]
    fn predict_win_outcome_for_two_teams() {
        let teams = vec![
            vec![Rating::default(), Rating::new(32.444, 5.123)],
            vec![Rating::new(73.381, 1.421), Rating::new(25.188, 6.211)],
        ];
        let want = Ok(vec![0.0020706344961249385, 0.997929365503875]);
        predict_win_test(teams, want);
    }

    #[test]
    fn predict_win_outcome_for_multiple_asymmetric_teams() {
        let teams = vec![
            vec![Rating::default(), Rating::new(32.444, 5.123)],
            vec![Rating::new(73.381, 1.421), Rating::new(25.188, 6.211)],
            vec![Rating::new(32.444, 5.123)],
            vec![Rating::new(25.188, 6.211)],
        ];
        let want = Ok(vec![
            0.3273280055056081,
            0.49965489412719827,
            0.132583880271438,
            0.04043322009575564,
        ]);
        predict_win_test(teams, want);
    }

    #[test]
    fn predict_win_3_player_newbie_ffa() {
        let teams = vec![
            vec![Rating::default()],
            vec![Rating::default()],
            vec![Rating::default()],
        ];
        let want = Ok(vec![
            0.3333333333333333,
            0.3333333333333333,
            0.3333333333333333,
        ]);
        predict_win_test(teams, want);
    }

    #[test]
    fn predict_win_4_player_newbie_ffa() {
        let teams = vec![
            vec![Rating::default()],
            vec![Rating::default()],
            vec![Rating::default()],
            vec![Rating::default()],
        ];
        let want = Ok(vec![0.25, 0.25, 0.25, 0.25]);
        predict_win_test(teams, want);
    }

    #[test]
    fn predict_win_4_players_of_varying_skill() {
        let teams = vec![
            vec![Rating::new(1.0, 0.1)],
            vec![Rating::new(2.0, 0.1)],
            vec![Rating::new(3.0, 0.1)],
            vec![Rating::new(4.0, 0.1)],
        ];
        let want = Ok(vec![
            0.18420221980528928,
            0.22786446154550788,
            0.27213553845449207,
            0.31579778019471066,
        ]);
        predict_win_test(teams, want);
    }
}