Revert back.

src/lib.rs

@@ -1,3 +1,6 @@
+extern crate statrs;
+extern crate noisy_float;
+
 mod factor_graph;
 mod gaussian;
 mod math;
@@ -25,22 +28,7 @@ const DRAW_PROBABILITY: f64 = 0.10;
 ///  A basis to check reliability of the result.
 const DELTA: f64 = 0.0001;
 
-#[derive(Debug, PartialEq)]
-pub struct Rating {
-    pub mu: f64,
-    pub sigma: f64,
-}
-
-impl Default for Rating {
-    fn default() -> Rating {
-        Rating {
-            mu: MU,
-            sigma: SIGMA,
-        }
-    }
-}
-
-fn rate(rating_groups: &[&[Rating]]) {
+pub fn rate(rating_groups: &[&[Gaussian]]) {
     let flatten_ratings = rating_groups
         .iter()
         .flat_map(|group| group.iter())
@@ -74,7 +62,7 @@ fn rate(rating_groups: &[&[Rating]]) {
 
     for (i, rating) in flatten_ratings.iter().enumerate() {
         let variable = ss[i];
-        let gaussian = Gaussian::with_mu_sigma(rating.mu, (rating.sigma.powi(2) + tau_sqr).sqrt());
+        let gaussian = Gaussian::from_mean_variance(rating.mean(), (rating.variance() + tau_sqr).sqrt());
 
         skill.push(PriorFactor::new(
             &mut variable_arena,
@@ -89,14 +77,11 @@ fn rate(rating_groups: &[&[Rating]]) {
     let mut skill_to_perf = Vec::new();;
 
     for i in 0..size {
-        let mean = ss[i];
-        let value = ps[i];
-
         skill_to_perf.push(LikelihoodFactor::new(
             &mut variable_arena,
             factor_id,
-            mean,
-            value,
+            ss[i],
+            ps[i],
             beta_sqr,
         ));
 
@@ -149,6 +134,7 @@ fn rate(rating_groups: &[&[Rating]]) {
         factor.start(&mut variable_arena);
     }
 
+    /*
     println!("before:");
 
     for i in 0..size {
@@ -157,11 +143,12 @@ fn rate(rating_groups: &[&[Rating]]) {
             .map(|variable| variable.get_value())
             .unwrap();
 
-        let mu = value.mu();
-        let sigma = value.sigma();
+        let mu = value.mean();
+        let sigma = value.std_dev();
 
         println!("* player={}, mu={}, sigma={}", i, mu, sigma);
     }
+    */
 
     for factor in &skill_to_perf {
         factor.update_value(&mut variable_arena);
@@ -194,6 +181,7 @@ fn rate(rating_groups: &[&[Rating]]) {
         factor.update_mean(&mut variable_arena);
     }
 
+    /*
     println!("after:");
 
     for i in 0..size {
@@ -202,14 +190,15 @@ fn rate(rating_groups: &[&[Rating]]) {
             .map(|variable| variable.get_value())
             .unwrap();
 
-        let mu = value.mu();
-        let sigma = value.sigma();
+        let mu = value.mean();
+        let sigma = value.std_dev();
 
         println!("* player={}, mu={}, sigma={}", i, mu, sigma);
     }
+    */
 }
 
-fn quality(rating_groups: &[&[Rating]]) -> f64 {
+pub fn quality(rating_groups: &[&[Gaussian]]) -> f64 {
     let flatten_ratings = rating_groups
         .iter()
         .flat_map(|group| group.iter())
@@ -222,13 +211,13 @@ fn quality(rating_groups: &[&[Rating]]) -> f64 {
     let mut mean_matrix = Matrix::new(length, 1);
 
     for (i, rating) in flatten_ratings.iter().enumerate() {
-        mean_matrix[(i, 0)] = rating.mu;
+        mean_matrix[(i, 0)] = rating.mean();
     }
 
     let mut variance_matrix = Matrix::new(length, length);
 
     for (i, rating) in flatten_ratings.iter().enumerate() {
-        variance_matrix[(i, i)] = rating.sigma.powi(2);
+        variance_matrix[(i, i)] = rating.std_dev().powi(2);
     }
 
     let mut rotated_a_matrix = Matrix::new(rating_groups.len() - 1, length);
@@ -272,35 +261,23 @@ mod tests {
 
     #[test]
     fn test_quality_1vs1() {
-        let alice = Rating {
-            mu: 25.0,
-            sigma: SIGMA,
-        };
+        let alice = Gaussian::from_mean_std_dev(MU, SIGMA);
+        let bob = Gaussian::from_mean_std_dev(MU, SIGMA);
 
-        let bob = Rating {
-            mu: 30.0,
-            sigma: SIGMA,
-        };
-
-        assert_eq!(quality(&[&[alice], &[bob]]), 0.41614606763952605);
+        assert_eq!(quality(&[&[alice], &[bob]]), 0.4472135954999579);
     }
 
     #[test]
     fn test_rate_1vs1() {
-        let alice = Rating {
-            mu: 25.0,
-            sigma: SIGMA,
-        };
+        let alice = Gaussian::from_mean_std_dev(MU, SIGMA);
+        let bob = Gaussian::from_mean_std_dev(MU, SIGMA);
+        let chris = Gaussian::from_mean_std_dev(MU, SIGMA);
+        let darren = Gaussian::from_mean_std_dev(MU, SIGMA);
 
-        let bob = Rating {
-            mu: 30.0,
-            sigma: SIGMA,
-        };
+        // println!("alice: {:?}", alice);
+        // println!("bob: {:?}", alice);
 
-        // alice: mu=27.175, sigma=7.112
-        // bob:   mu=23.141, sigma=6.859
-
-        rate(&[&[alice], &[bob]]);
+        rate(&[&[alice], &[bob], &[chris], &[darren]]);
 
         assert_eq!(true, false);
     }