commit df49bc94419166fbe7e7663aecccf3e989fd870b Author: Anders Olsson Date: Sun Oct 21 14:25:21 2018 +0200 Initial commit. diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..6936990 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +/target +**/*.rs.bk +Cargo.lock diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..be29532 --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "trueskill" +version = "0.1.0" +authors = ["Anders Olsson "] + +[dependencies] diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..f72d9f2 --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,110 @@ +mod matrix; + +use matrix::Matrix; + +/// Default initial mean of ratings. +const MU: f32 = 25.0; + +/// Default initial standard deviation of ratings. +const SIGMA: f32 = MU / 3.0; + +/// Default distance that guarantees about 76% chance of winning. +const BETA: f32 = SIGMA / 2.0; + +/// Default dynamic factor. +const TAU: f32 = SIGMA / 100.0; + +/// Default draw probability of the game. +const DRAW_PROBABILITY: f32 = 0.10; + +/// A basis to check reliability of the result. +const DELTA: f32 = 0.0001; + +#[derive(Debug, PartialEq)] +struct Rating { + mu: f32, + sigma: f32, +} + +impl Default for Rating { + fn default() -> Rating { + Rating { + mu: MU, + sigma: SIGMA, + } + } +} + +fn quality(rating_groups: &[&[Rating]]) -> f32 { + let flatten_ratings = rating_groups.iter().flat_map(|group| group.iter()).collect::>(); + let flatten_weights = vec![1.0; flatten_ratings.len()].into_boxed_slice(); + + let length = flatten_ratings.len(); + + let mut mean_matrix = Matrix::new(length, 1); + + for (i, rating) in flatten_ratings.iter().enumerate() { + mean_matrix[(i, 0)] = rating.mu; + } + + let mut variance_matrix = Matrix::new(length, length); + + for (i, rating) in flatten_ratings.iter().enumerate() { + variance_matrix[(i, i)] = rating.sigma.powi(2); + } + + let mut rotated_a_matrix = Matrix::new(rating_groups.len() - 1, length); + + let mut t = 0; + let mut x = 0; + + for (row, group) in rating_groups.windows(2).enumerate() { + let current = group[0]; + let next = group[1]; + + for n in t..t + current.len() { + rotated_a_matrix[(row, n)] = flatten_weights[n]; + t += 1; + x += 1; + } + + for n in x..x + next.len() { + rotated_a_matrix[(row, n)] = -flatten_weights[n]; + x += 1; + } + } + + let a_matrix = rotated_a_matrix.transpose(); + + let _ata = BETA.powi(2) * &rotated_a_matrix * &a_matrix; + let _atsa = &rotated_a_matrix * &variance_matrix * &a_matrix; + let start = mean_matrix.transpose() * &a_matrix; + let middle = &_ata + &_atsa; + let end = &rotated_a_matrix * &mean_matrix; + + let e_arg = (-0.5 * &start * &middle.inverse() * &end).determinant(); + let s_arg = _ata.determinant() / middle.determinant(); + + e_arg.exp() * s_arg.sqrt() +} + + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_quality_1vs1() { + let alice = Rating { + mu: 25.0, + sigma: SIGMA, + }; + + let bob = Rating { + mu: 30.0, + sigma: SIGMA, + }; + + assert_eq!(quality(&[&[alice], &[bob]]), 0.41614607); + } +} diff --git a/src/matrix.rs b/src/matrix.rs new file mode 100644 index 0000000..c178f0e --- /dev/null +++ b/src/matrix.rs @@ -0,0 +1,213 @@ +use std::ops; + +fn det(m: &[f32], x: usize) -> f32 { + if x == 1 { + m[0] + } else if x == 2 { + m[0] * m[3] - m[1] * m[2] + } else { + let mut d = 0.0; + + for n in 0..x { + let ms = m + .iter() + .enumerate() + .skip(x) + .filter(|(i, _)| (i % x) != n) + .map(|(_, v)| *v).collect::>(); + + d += (-1.0f32).powi(n as i32) * m[n] * det(&ms, x - 1); + } + + d + } +} + +#[derive(Clone, Debug)] +pub struct Matrix { + data: Box<[f32]>, + height: usize, + width: usize, +} + +impl Matrix { + pub fn new(height: usize, width: usize) -> Matrix { + Matrix { + data: vec![0.0; height * width].into_boxed_slice(), + height, + width, + } + } + + pub fn transpose(&self) -> Matrix { + let mut matrix = Matrix::new(self.width, self.height); + + for c in 0..self.width { + for r in 0..self.height { + matrix[(c, r)] = self[(r, c)]; + } + } + + matrix + } + + pub fn minor(&self, row_n: usize, col_n: usize) -> Matrix { + let mut matrix = Matrix::new(self.height - 1 , self.width - 1); + + let mut nr = 0; + + for r in 0..self.height { + if r == row_n { + continue; + } + + let mut nc = 0; + + for c in 0..self.width { + if c == col_n { + continue; + } + + matrix[(nr, nc)] = self[(r, c)]; + + nc += 1; + } + + nr += 1; + } + + matrix + } + + pub fn determinant(&self) -> f32 { + debug_assert!(self.width == self.height); + + det(&self.data, self.width) + } + + pub fn adjugate(&self) -> Matrix { + debug_assert!(self.width == self.height); + + let mut matrix = Matrix::new(self.height, self.width); + + if matrix.height == 2 { + matrix[(0, 0)] = self[(1, 1)]; + matrix[(0, 1)] = -self[(0, 1)]; + matrix[(1, 0)] = -self[(1, 0)]; + matrix[(1, 1)] = self[(0, 0)]; + } else { + for r in 0..matrix.height { + for c in 0..matrix.width { + let sign = if (r + c) % 2 == 0 { 1.0 } else { -1.0 }; + + matrix[(r, c)] = self.minor(r, c).determinant() * sign; + } + } + } + + matrix + } + + pub fn inverse(&self) -> Matrix { + let mut matrix = Matrix::new(self.width, self.height); + + if self.height == self.width && self.height == 1 { + matrix[(0, 0)] = 1.0 / self[(0, 0)]; + } else { + } + + matrix + } +} + + + +impl ops::Index<(usize, usize)> for Matrix { + type Output = f32; + + fn index(&self, pos: (usize, usize)) -> &Self::Output { + &self.data[(self.width * pos.0) + pos.1] + } +} + +impl ops::IndexMut<(usize, usize)> for Matrix { + fn index_mut(&mut self, pos: (usize, usize)) -> &mut Self::Output { + &mut self.data[(self.width * pos.0) + pos.1] + } +} + +impl<'a> ops::Mul<&'a Matrix> for f32 { + type Output = Matrix; + + fn mul(self, rhs: &'a Matrix) -> Matrix { + let mut matrix = Matrix::new(rhs.height, rhs.width); + + for r in 0..rhs.height { + for c in 0..rhs.width { + matrix[(r, c)] = self * rhs[(r, c)]; + } + } + + matrix + } +} + +impl<'a> ops::Mul<&'a Matrix> for Matrix { + type Output = Matrix; + + fn mul(self, rhs: &'a Matrix) -> Matrix { + let mut matrix = Matrix::new(self.height, rhs.width); + + for r in 0..matrix.height { + for c in 0..matrix.width { + let mut value = 0.0; + + for x in 0..self.width { + value += self[(r, x)] * rhs[(x, c)]; + } + + matrix[(r, c)] = value; + } + } + + matrix + } +} + +impl<'a> ops::Mul<&'a Matrix> for &'a Matrix { + type Output = Matrix; + + fn mul(self, rhs: &'a Matrix) -> Matrix { + let mut matrix = Matrix::new(self.height, rhs.width); + + for r in 0..matrix.height { + for c in 0..matrix.width { + let mut value = 0.0; + + for x in 0..self.width { + value += self[(r, x)] * rhs[(x, c)]; + } + + matrix[(r, c)] = value; + } + } + + matrix + } +} + +impl<'a> ops::Add<&'a Matrix> for &'a Matrix { + type Output = Matrix; + + fn add(self, rhs: &'a Matrix) -> Matrix { + let mut matrix = Matrix::new(self.height, self.width); + + for r in 0..matrix.height { + for c in 0..matrix.width { + matrix[(r, c)] = self[(r, c)] + rhs[(r, c)]; + } + } + + matrix + } +}