Merge branch 'refactor'

src/main.rs

@@ -1,8 +1,12 @@
+#![warn(clippy::all, clippy::pedantic)]
+#![allow(clippy::clippy::cast_precision_loss)]
+
 mod stats;
 
 fn main() {
     // Stats
-    let mut numbers = stats::StatsCalculator::default_data();
+    let mut data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    let mut numbers = stats::NewStatsCalculator::from_vec(&mut data);
     println!("Data: {:?}", numbers);
     println!("Mean: {:?}", numbers.get_mean());
     println!("Median: {:?}", numbers.get_median());

src/stats.rs

@@ -1,17 +1,24 @@
 use std::convert::TryFrom;
+use ::std::collections::HashMap;
+
 
 #[derive(Debug)]
-pub struct StatsCalculator {
-    data: Vec<i32>,
+pub struct NewStatsCalculator<'a> {
+    data: &'a mut Vec<i32>,
+    length: u32,
+    total: i32,
 }
 
-impl StatsCalculator {
-    pub fn default_data() -> Self {
-        Self::from_vec(vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
-    }
-
-    pub fn from_vec(initial_data: Vec<i32>) -> Self {
-        return StatsCalculator { data: initial_data };
+impl<'a> NewStatsCalculator<'a> {
+    pub fn from_vec(initial_data: &'a mut Vec<i32>) -> Self {
+        let mut instance = NewStatsCalculator {
+            data: initial_data,
+            length: 0,
+            total: 0,
+        };
+        instance.get_length();
+        instance.get_total();
+        instance
     }
 
     // pub fn initialise(&mut self) -> () {
@@ -28,36 +35,84 @@ impl StatsCalculator {
     //     }
     // }
 
-    fn get_length(&self) -> i32 {
-        let length = i32::try_from(self.data.len());
+    fn get_length(&mut self) {
+        let length = u32::try_from(self.data.len());
 
         if let Ok(i) = length {
-            return i;
+            self.length = i;
         } else {
-            return 0;
+            self.length = 0;
         }
     }
 
-    fn get_total(&self) -> i32 {
-        return self.data.iter().sum();
+    fn get_total(&mut self) {
+        self.total = self.data.iter().sum();
     }
 
     pub fn get_mean(&self) -> f32 {
-        let total = self.get_total();
-        let length = self.get_length();
-        return total as f32 / length as f32;
+        self.total as f32 / self.length as f32
     }
 
     pub fn get_median(&mut self) -> f32 {
-        let length = self.get_length();
-        let mid = length as usize / 2;
+        let mid = self.length as usize / 2;
 
-        self.data.sort();
+        self.data.sort_unstable();
 
-        if length % 2 != 0 {
-            return self.data[mid] as f32;
+        if self.length % 2 == 0 {
+            (self.data[mid - 1] as f32 + self.data[mid] as f32) / 2.0
         } else {
-            return (self.data[mid - 1] as f32 + self.data[mid] as f32) / 2.0;
+            self.data[mid] as f32
         }
     }
+
+    // pub fn get_mode(&self) -> HashMap<&mut i32, i32> {
+    //     let mut mode = HashMap::new();
+    //     for ref i in self.data {
+    //         let count = mode.entry(i).or_insert(0);
+    //         *count += 1;
+    //     }
+    //     mode
+    // }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_get_length() {
+        let mut data = vec![1, 2, 3, 4, 5, 6];
+        let mut test = NewStatsCalculator::from_vec(&mut data);
+        test.get_length();
+        assert_eq!(test.length, 6);
+    }
+
+    #[test]
+    fn test_get_total() {
+        let mut data = vec![1, 2, 3, 4, 5, 6];
+        let mut test = NewStatsCalculator::from_vec(&mut data);
+        test.get_length();
+        assert_eq!(test.total, 21);
+    }
+
+    #[test]
+    fn test_get_mean() {
+        let mut data = vec![1, 2, 3, 4, 5, 6];
+        let test = NewStatsCalculator::from_vec(&mut data);
+        assert_eq!(test.get_mean(), 3.5);
+    }
+
+    #[test]
+    fn test_get_median_even() {
+        let mut data = vec![1, 2, 3, 4, 5, 6];
+        let mut test = NewStatsCalculator::from_vec(&mut data);
+        assert_eq!(test.get_median(), 3.5);
+    }
+
+    #[test]
+    fn test_get_median_odd() {
+        let mut data = vec![1, 2, 3, 4, 5, 6, 7];
+        let mut test = NewStatsCalculator::from_vec(&mut data);
+        assert_eq!(test.get_median(), 4.0);
+    }
 }