mean.rs

const MANY: usize = 1001;

use rand::Rng;

mod avg {
    use std::{collections::HashMap, fmt};

    pub struct AvgData {
        pub avg: f64,
        pub med: f64,
        pub r#mod: i32,
    }

    impl fmt::Display for AvgData {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            write! {
                f,
                "avg: {}\nmed: {}\nmod: {}",
                self.avg, self.med, self.r#mod
            }
        }
    }

    pub fn get_average(numbers: &[i32]) -> f64 {
        numbers.iter().sum::<i32>() as f64 / numbers.len() as f64
    }

    pub fn get_median(numbers: &[i32]) -> f64 {
        let mut cloned = numbers.to_owned().clone();
        cloned.sort();
        if let 0 = cloned.len() % 2 {
            get_average(&cloned[
                (cloned.len() / 2 - 1)..(cloned.len() / 2 + 1)
            ])
        } else {
            cloned[cloned.len() / 2] as f64
        }
    }

    pub fn get_mode(numbers: &[i32]) -> i32 {
        let mut modes = HashMap::new();

        *numbers
            .iter()
            .max_by_key(|&i| *modes
                .entry(i)
                .and_modify(|n| *n += 1)
                .or_insert(0)
            )
            .unwrap()
    }

    #[cfg(test)]
    mod tests {
        use rand::prelude::SliceRandom;

        use super::*;

        #[test]
        fn is_get_average_function_works_well() {
            assert_eq!(get_average(&[1, 2, 5, 7]), 3.75);
        }

        #[test]
        fn is_get_median_function_works_well() {
            let mut v = [1, 2, 3, 4, 5, 6];
            v.shuffle(&mut rand::thread_rng());
            assert_eq!(get_median(&v), 3.5);
        }

        #[test]
        fn is_get_mode_function_works_well() {
            assert_eq!(get_mode(&[1, 1, 1, 1, 2, 2, 3, 5, 6]), 1);
        }
    }
}

fn main() {
    // make random list
    let mut rand_seed = rand::thread_rng();
    let num_sample = std::iter::repeat_with(|| rand_seed.gen_range(0..=MANY as i32 * 5))
        .take(MANY)
        .collect::<Vec<_>>();

    let num_infos = num_list_info(&num_sample);
    println!("{num_infos}");
}

fn num_list_info(nums: &[i32]) -> avg::AvgData {
    avg::AvgData {
        avg: avg::get_average(nums),
        med: avg::get_median(nums),
        r#mod: avg::get_mode(nums),
    }
}