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

use crate::constant::{DEFAULT_MU, DEFAULT_SIGMA};
use std::{fmt::Display, iter::zip};

#[derive(Debug, Clone)]
pub struct Rating {
    pub mu: f64,
    pub sigma: f64,
}

impl Display for Rating {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "(mu: {}, sigma: {})", self.mu, self.sigma)
    }
}

impl Default for Rating {
    fn default() -> Self {
        Self {
            mu: DEFAULT_MU,
            sigma: DEFAULT_SIGMA,
        }
    }
}

impl Rating {
    pub fn new(mu: f64, sigma: f64) -> Self {
        Self { mu, sigma }
    }
}

#[derive(Debug, Clone)]
pub struct TeamRating {
    pub members: Vec<Rating>,
    pub mu: f64,
    pub sigma_sq: f64,
    pub rank: usize,
}

impl TeamRating {
    pub fn new(members: Vec<Rating>, rank: usize) -> Self {
        let mu = members.iter().map(|m| m.mu).sum::<f64>();
        let sigma_sq = members.iter().map(|m| m.sigma.powi(2)).sum::<f64>();
        Self {
            members,
            mu,
            sigma_sq,
            rank,
        }
    }

    pub fn team_size(&self) -> usize {
        self.members.len()
    }
}

pub(crate) fn to_team_ratings(
    teams: &Vec<Vec<Rating>>,
    ranks: Option<Vec<usize>>,
) -> Vec<TeamRating> {
    let ranks = ranks.unwrap_or_else(|| (0..teams.len()).collect());
    zip(teams.iter(), ranks.iter())
        .map(|(team, rank)| TeamRating::new(team.clone(), *rank))
        .collect()
}

pub(crate) fn calc_total_player(team_ratings: &Vec<TeamRating>) -> usize {
    team_ratings.iter().map(|it| it.team_size()).sum::<usize>()
}

pub struct GameResult {
    pub teams: Vec<Vec<Rating>>,
    pub ranks: Vec<usize>,
}

impl GameResult {
    pub fn new(teams: Vec<Vec<Rating>>, ranks: Vec<usize>) -> Self {
        Self { teams, ranks }
    }
}

pub type GammaFunc = fn(f64, f64, team: &TeamRating) -> f64;

pub fn default_gamma(c: f64, _: f64, team: &TeamRating) -> f64 {
    team.sigma_sq.sqrt() / c
}

pub type OrdinalFunc = fn(&Rating, f64) -> f64;

pub fn default_ordinal(rating: &Rating, z: f64) -> f64 {
    rating.mu - (z * rating.sigma)
}

pub fn ladder_pairs<T>(ranks: &Vec<T>) -> Vec<Vec<T>>
where
    T: Clone,
{
    let o_ranks: Vec<Option<T>> = ranks.clone().into_iter().map(Some).collect();
    let left: Vec<_> = [None]
        .iter()
        .cloned()
        .chain(o_ranks[..o_ranks.len() - 1].iter().cloned())
        .collect();
    let right = vec![&o_ranks[1..], &[None]].concat();
    return zip(left, right)
        .map(|(l, r)| match (l, r) {
            (Some(l), Some(r)) => vec![l, r],
            (Some(l), None) => vec![l],
            (None, Some(r)) => vec![r],
            _ => vec![],
        })
        .collect();
}