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

Update test to use assert_ulps_eq

Browse Source
This commit is contained in:
Anders Olsson
2022-06-27 11:46:59 +02:00
parent 0633c766a5
commit 2467d7e027
2 changed files with 55 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files

188
src/game.rs
View File

@@ -244,9 +244,8 @@ mod tests {
let a = p[0][0]; let a = p[0][0];
let b = p[1][0]; let b = p[1][0];
assert_eq!(a.mu, 20.79477925612302); assert_ulps_eq!(a, Gaussian::new(20.794779, 7.194481), epsilon = 1e-6);
assert_eq!(b.mu, 29.205220743876975); assert_ulps_eq!(b, Gaussian::new(29.205220, 7.194481), epsilon = 1e-6);
assert_eq!(a.sigma, 7.194481422570443);
let t_a = Player::new(Gaussian::new(29.0, 1.0), 25.0 / 6.0, GAMMA); let t_a = Player::new(Gaussian::new(29.0, 1.0), 25.0 / 6.0, GAMMA);
let t_b = Player::new(Gaussian::new(25.0, 25.0 / 3.0), 25.0 / 6.0, GAMMA); let t_b = Player::new(Gaussian::new(25.0, 25.0 / 3.0), 25.0 / 6.0, GAMMA);
@@ -257,10 +256,8 @@ mod tests {
let a = p[0][0]; let a = p[0][0];
let b = p[1][0]; let b = p[1][0];
assert_eq!(a.mu, 28.896475351225412); assert_ulps_eq!(a, Gaussian::new(28.896475, 0.996604), epsilon = 1e-6);
assert_eq!(a.sigma, 0.9966043313004235); assert_ulps_eq!(b, Gaussian::new(32.189211, 6.062063), epsilon = 1e-6);
assert_eq!(b.mu, 32.18921172045737);
assert_eq!(b.sigma, 6.062063735879715);
let t_a = Player::new(Gaussian::new(1.139, 0.531), 1.0, 0.2125); let t_a = Player::new(Gaussian::new(1.139, 0.531), 1.0, 0.2125);
let t_b = Player::new(Gaussian::new(15.568, 0.51), 1.0, 0.2125); let t_b = Player::new(Gaussian::new(15.568, 0.51), 1.0, 0.2125);
@@ -298,10 +295,8 @@ mod tests {
let a = p[0][0]; let a = p[0][0];
let b = p[1][0]; let b = p[1][0];
assert_eq!(a.mu, 25.00000000000592); assert_ulps_eq!(a, Gaussian::new(25.000000, 6.238469), epsilon = 1e-6);
assert_eq!(a.sigma, 6.238469796269066); assert_ulps_eq!(b, Gaussian::new(31.311358, 6.698818), epsilon = 1e-6);
assert_eq!(b.mu, 31.31135822129149);
assert_eq!(b.sigma, 6.69881865477675);
let g = Game::new(teams.clone(), vec![], vec![], 0.0); let g = Game::new(teams.clone(), vec![], vec![], 0.0);
let p = g.posteriors(); let p = g.posteriors();
@@ -309,10 +304,8 @@ mod tests {
let a = p[0][0]; let a = p[0][0];
let b = p[1][0]; let b = p[1][0];
assert_eq!(a.mu, 31.31135822129149); assert_ulps_eq!(a, Gaussian::new(31.311358, 6.698818), epsilon = 1e-6);
assert_eq!(a.sigma, 6.69881865477675); assert_ulps_eq!(b, Gaussian::new(25.000000, 6.238469), epsilon = 1e-6);
assert_eq!(b.mu, 25.00000000000592);
assert_eq!(b.sigma, 6.238469796269066);
let g = Game::new(teams, vec![1.0, 2.0, 0.0], vec![], 0.5); let g = Game::new(teams, vec![1.0, 2.0, 0.0], vec![], 0.5);
let p = g.posteriors(); let p = g.posteriors();
@@ -321,12 +314,9 @@ mod tests {
let b = p[1][0]; let b = p[1][0];
let c = p[2][0]; let c = p[2][0];
assert_eq!(a.mu, 24.999999999511545); assert_ulps_eq!(a, Gaussian::new(24.999999, 6.092561), epsilon = 1e-6);
assert_eq!(a.sigma, 6.092561128305945); assert_ulps_eq!(b, Gaussian::new(33.379314, 6.483575), epsilon = 1e-6);
assert_eq!(b.mu, 33.37931495595287); assert_ulps_eq!(c, Gaussian::new(16.620685, 6.483575), epsilon = 1e-6);
assert_eq!(b.sigma, 6.483575782278924);
assert_eq!(c.mu, 16.62068504453558);
assert_eq!(c.sigma, 6.483575782198122);
} }
#[test] #[test]
@@ -340,10 +330,8 @@ mod tests {
let a = p[0][0]; let a = p[0][0];
let b = p[1][0]; let b = p[1][0];
assert_eq!(a.mu, 24.999999999999996); assert_ulps_eq!(a, Gaussian::new(24.999999, 6.469480), epsilon = 1e-6);
assert_eq!(a.sigma, 6.469480769842277); assert_ulps_eq!(b, Gaussian::new(24.999999, 6.469480), epsilon = 1e-6);
assert_eq!(b.mu, 24.999999999999996);
assert_eq!(b.sigma, 6.469480769842277);
let t_a = Player::new(Gaussian::new(25.0, 3.0), 25.0 / 6.0, 25.0 / 300.0); let t_a = Player::new(Gaussian::new(25.0, 3.0), 25.0 / 6.0, 25.0 / 300.0);
let t_b = Player::new(Gaussian::new(29.0, 2.0), 25.0 / 6.0, 25.0 / 300.0); let t_b = Player::new(Gaussian::new(29.0, 2.0), 25.0 / 6.0, 25.0 / 300.0);
@@ -354,10 +342,8 @@ mod tests {
let a = p[0][0]; let a = p[0][0];
let b = p[1][0]; let b = p[1][0];
assert_eq!(a.mu, 25.73600181056662); assert_ulps_eq!(a, Gaussian::new(25.736001, 2.709956), epsilon = 1e-6);
assert_eq!(a.sigma, 2.709956162204711); assert_ulps_eq!(b, Gaussian::new(28.672888, 1.916471), epsilon = 1e-6);
assert_eq!(b.mu, 28.67288808419261);
assert_eq!(b.sigma, 1.9164711604544398);
} }
#[test] #[test]
@@ -378,12 +364,9 @@ mod tests {
let b = p[1][0]; let b = p[1][0];
let c = p[2][0]; let c = p[2][0];
assert_eq!(a.mu, 24.999999999999996); assert_ulps_eq!(a, Gaussian::new(24.999999, 5.729068), epsilon = 1e-6);
assert_eq!(a.sigma, 5.729068664890827); assert_ulps_eq!(b, Gaussian::new(25.000000, 5.707423), epsilon = 1e-6);
assert_eq!(b.mu, 25.000000000000004); assert_ulps_eq!(c, Gaussian::new(24.999999, 5.729068), epsilon = 1e-6);
assert_eq!(b.sigma, 5.707423522433266);
assert_eq!(c.mu, 24.999999999999996);
assert_eq!(c.sigma, 5.729068664890825);
let t_a = Player::new(Gaussian::new(25.0, 3.0), 25.0 / 6.0, 25.0 / 300.0); let t_a = Player::new(Gaussian::new(25.0, 3.0), 25.0 / 6.0, 25.0 / 300.0);
let t_b = Player::new(Gaussian::new(25.0, 3.0), 25.0 / 6.0, 25.0 / 300.0); let t_b = Player::new(Gaussian::new(25.0, 3.0), 25.0 / 6.0, 25.0 / 300.0);
@@ -401,12 +384,9 @@ mod tests {
let b = p[1][0]; let b = p[1][0];
let c = p[2][0]; let c = p[2][0];
assert_eq!(a.mu, 25.48850755025261); assert_ulps_eq!(a, Gaussian::new(25.488507, 2.638208), epsilon = 1e-6);
assert_eq!(a.sigma, 2.6382084442984226); assert_ulps_eq!(b, Gaussian::new(25.510671, 2.628751), epsilon = 1e-6);
assert_eq!(b.mu, 25.510671709901217); assert_ulps_eq!(c, Gaussian::new(28.555920, 1.885689), epsilon = 1e-6);
assert_eq!(b.sigma, 2.6287517663583633);
assert_eq!(c.mu, 28.555920328820527);
assert_eq!(c.sigma, 1.8856891308577184);
} }
#[test] #[test]
@@ -454,16 +434,8 @@ mod tests {
let g = Game::new(vec![t_a.clone(), t_b.clone()], vec![], vec![w_a, w_b], 0.0); let g = Game::new(vec![t_a.clone(), t_b.clone()], vec![], vec![w_a, w_b], 0.0);
let p = g.posteriors(); let p = g.posteriors();
assert_ulps_eq!( assert_ulps_eq!(p[0][0], Gaussian::new(30.625173, 7.765472), epsilon = 1e-6);
p[0][0], assert_ulps_eq!(p[1][0], Gaussian::new(13.749653, 5.733840), epsilon = 1e-6);
Gaussian::new(30.625173, 7.765472),
epsilon = 0.000001
);
assert_ulps_eq!(
p[1][0],
Gaussian::new(13.749653, 5.733840),
epsilon = 0.000001
);
let w_a = vec![1.0]; let w_a = vec![1.0];
let w_b = vec![0.7]; let w_b = vec![0.7];
@@ -471,16 +443,8 @@ mod tests {
let g = Game::new(vec![t_a.clone(), t_b.clone()], vec![], vec![w_a, w_b], 0.0); let g = Game::new(vec![t_a.clone(), t_b.clone()], vec![], vec![w_a, w_b], 0.0);
let p = g.posteriors(); let p = g.posteriors();
assert_ulps_eq!( assert_ulps_eq!(p[0][0], Gaussian::new(27.630080, 7.206676), epsilon = 1e-6);
p[0][0], assert_ulps_eq!(p[1][0], Gaussian::new(23.158943, 7.801628), epsilon = 1e-6);
Gaussian::new(27.630080, 7.206676),
epsilon = 0.000001
);
assert_ulps_eq!(
p[1][0],
Gaussian::new(23.158943, 7.801628),
epsilon = 0.000001
);
let w_a = vec![1.6]; let w_a = vec![1.6];
let w_b = vec![0.7]; let w_b = vec![0.7];
@@ -488,16 +452,8 @@ mod tests {
let g = Game::new(vec![t_a, t_b], vec![], vec![w_a, w_b], 0.0); let g = Game::new(vec![t_a, t_b], vec![], vec![w_a, w_b], 0.0);
let p = g.posteriors(); let p = g.posteriors();
assert_ulps_eq!( assert_ulps_eq!(p[0][0], Gaussian::new(26.142438, 7.573088), epsilon = 1e-6);
p[0][0], assert_ulps_eq!(p[1][0], Gaussian::new(24.500183, 8.193278), epsilon = 1e-6);
Gaussian::new(26.142438, 7.573088),
epsilon = 0.000001
);
assert_ulps_eq!(
p[1][0],
Gaussian::new(24.500183, 8.193278),
epsilon = 0.000001
);
let w_a = vec![1.0]; let w_a = vec![1.0];
let w_b = vec![0.0]; let w_b = vec![0.0];
@@ -508,12 +464,8 @@ mod tests {
let g = Game::new(vec![t_a, t_b], vec![], vec![w_a, w_b], 0.0); let g = Game::new(vec![t_a, t_b], vec![], vec![w_a, w_b], 0.0);
let p = g.posteriors(); let p = g.posteriors();
assert_ulps_eq!( assert_ulps_eq!(p[0][0], Gaussian::new(5.557067, 4.052826), epsilon = 1e-6);
p[0][0], assert_ulps_eq!(p[1][0], Gaussian::new(2.000000, 6.000000), epsilon = 1e-6);
Gaussian::new(5.55706798109105, 4.0528268357577995),
epsilon = 0.000001
);
assert_ulps_eq!(p[1][0], Gaussian::new(2.0, 6.0), epsilon = 0.000001);
let w_a = vec![1.0]; let w_a = vec![1.0];
let w_b = vec![-1.0]; let w_b = vec![-1.0];
@@ -524,7 +476,7 @@ mod tests {
let g = Game::new(vec![t_a, t_b], vec![], vec![w_a, w_b], 0.0); let g = Game::new(vec![t_a, t_b], vec![], vec![w_a, w_b], 0.0);
let p = g.posteriors(); let p = g.posteriors();
assert_ulps_eq!(p[0][0], p[1][0], epsilon = 0.000001); assert_ulps_eq!(p[0][0], p[1][0], epsilon = 1e-6);
} }
#[test] #[test]
@@ -544,26 +496,10 @@ mod tests {
let g = Game::new(vec![t_a.clone(), t_b.clone()], vec![], vec![w_a, w_b], 0.0); let g = Game::new(vec![t_a.clone(), t_b.clone()], vec![], vec![w_a, w_b], 0.0);
let p = g.posteriors(); let p = g.posteriors();
assert_ulps_eq!( assert_ulps_eq!(p[0][0], Gaussian::new(27.539023, 8.129639), epsilon = 1e-6);
p[0][0], assert_ulps_eq!(p[0][1], Gaussian::new(30.078046, 7.485372), epsilon = 1e-6);
Gaussian::new(27.539023, 8.129639), assert_ulps_eq!(p[1][0], Gaussian::new(19.287197, 7.243465), epsilon = 1e-6);
epsilon = 0.000001 assert_ulps_eq!(p[1][1], Gaussian::new(21.191465, 7.867608), epsilon = 1e-6);
);
assert_ulps_eq!(
p[0][1],
Gaussian::new(30.078046, 7.485372),
epsilon = 0.000001
);
assert_ulps_eq!(
p[1][0],
Gaussian::new(19.287197, 7.243465),
epsilon = 0.000001
);
assert_ulps_eq!(
p[1][1],
Gaussian::new(21.191465, 7.867608),
epsilon = 0.000001
);
let w_a = vec![1.3, 1.5]; let w_a = vec![1.3, 1.5];
let w_b = vec![0.7, 0.4]; let w_b = vec![0.7, 0.4];
@@ -571,26 +507,10 @@ mod tests {
let g = Game::new(vec![t_a.clone(), t_b.clone()], vec![], vec![w_a, w_b], 0.0); let g = Game::new(vec![t_a.clone(), t_b.clone()], vec![], vec![w_a, w_b], 0.0);
let p = g.posteriors(); let p = g.posteriors();
assert_ulps_eq!( assert_ulps_eq!(p[0][0], Gaussian::new(25.190190, 8.220511), epsilon = 1e-6);
p[0][0], assert_ulps_eq!(p[0][1], Gaussian::new(25.219450, 8.182783), epsilon = 1e-6);
Gaussian::new(25.190190, 8.220511), assert_ulps_eq!(p[1][0], Gaussian::new(24.897589, 8.300779), epsilon = 1e-6);
epsilon = 0.000001 assert_ulps_eq!(p[1][1], Gaussian::new(24.941479, 8.322717), epsilon = 1e-6);
);
assert_ulps_eq!(
p[0][1],
Gaussian::new(25.219450, 8.182783),
epsilon = 0.000001
);
assert_ulps_eq!(
p[1][0],
Gaussian::new(24.897589, 8.300779),
epsilon = 0.000001
);
assert_ulps_eq!(
p[1][1],
Gaussian::new(24.941479, 8.322717),
epsilon = 0.000001
);
let w_a = vec![1.6, 0.2]; let w_a = vec![1.6, 0.2];
let w_b = vec![0.7, 2.4]; let w_b = vec![0.7, 2.4];
@@ -598,26 +518,10 @@ mod tests {
let g = Game::new(vec![t_a.clone(), t_b.clone()], vec![], vec![w_a, w_b], 0.0); let g = Game::new(vec![t_a.clone(), t_b.clone()], vec![], vec![w_a, w_b], 0.0);
let p = g.posteriors(); let p = g.posteriors();
assert_ulps_eq!( assert_ulps_eq!(p[0][0], Gaussian::new(31.674697, 7.501180), epsilon = 1e-6);
p[0][0], assert_ulps_eq!(p[0][1], Gaussian::new(25.834337, 8.320970), epsilon = 1e-6);
Gaussian::new(31.674697, 7.501180), assert_ulps_eq!(p[1][0], Gaussian::new(22.079819, 8.180607), epsilon = 1e-6);
epsilon = 0.000001 assert_ulps_eq!(p[1][1], Gaussian::new(14.987953, 6.308469), epsilon = 1e-6);
);
assert_ulps_eq!(
p[0][1],
Gaussian::new(25.834337, 8.320970),
epsilon = 0.000001
);
assert_ulps_eq!(
p[1][0],
Gaussian::new(22.079819, 8.180607),
epsilon = 0.000001
);
assert_ulps_eq!(
p[1][1],
Gaussian::new(14.987953, 6.308469),
epsilon = 0.000001
);
let g = Game::new( let g = Game::new(
vec![ vec![
@@ -640,9 +544,9 @@ mod tests {
let g = Game::new(vec![t_a, t_b.clone()], vec![], vec![w_a, w_b], 0.0); let g = Game::new(vec![t_a, t_b.clone()], vec![], vec![w_a, w_b], 0.0);
let p = g.posteriors(); let p = g.posteriors();
assert_ulps_eq!(p[0][0], post_2vs1[0][0], epsilon = 0.000001); assert_ulps_eq!(p[0][0], post_2vs1[0][0], epsilon = 1e-6);
assert_ulps_eq!(p[0][1], post_2vs1[0][1], epsilon = 0.000001); assert_ulps_eq!(p[0][1], post_2vs1[0][1], epsilon = 1e-6);
assert_ulps_eq!(p[1][0], post_2vs1[1][0], epsilon = 0.000001); assert_ulps_eq!(p[1][0], post_2vs1[1][0], epsilon = 1e-6);
assert_ulps_eq!(p[1][1], t_b[1].prior, epsilon = 0.000001); assert_ulps_eq!(p[1][1], t_b[1].prior, epsilon = 1e-6);
} }
} }

9
src/lib.rs
View File

@@ -79,6 +79,15 @@ where
} }
} }
impl<K> Default for IndexMap<K>
where
K: Eq + Hash,
{
fn default() -> Self {
IndexMap::new()
}
}
fn erfc(x: f64) -> f64 { fn erfc(x: f64) -> f64 {
let z = x.abs(); let z = x.abs();
let t = 1.0 / (1.0 + z / 2.0); let t = 1.0 / (1.0 + z / 2.0);