use std::fmt;

pub trait StandardlyDistributable<T> {
	fn get_standard_distribution(v: Vec<T>) -> Self;
}

pub struct StandardDistribution {
	pub mean: f64,
	pub deviation: f64
}

impl fmt::Display for StandardDistribution {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		write!(f, "({}, {})", self.mean, self.deviation)
	}
}

impl StandardlyDistributable<u32> for StandardDistribution {
	fn get_standard_distribution(v: Vec<u32>) -> Self {
		let n = f64::from(u32::try_from(v.len()).unwrap());
		let summation = f64::from(v.iter().sum::<u32>());
		let mean = summation/ n;

		let mut deviation = 0.0;
		for i in 0..v.len() {
			let x_f = f64::from(v[i]);
			deviation += x_f * x_f - 2.0 * mean * x_f + mean * mean;
		}

		deviation /= f64::from(u32::try_from(v.len() - 1).unwrap());
		return StandardDistribution { mean, deviation };
	}
}

impl StandardlyDistributable<f64> for StandardDistribution {
	fn get_standard_distribution(v: Vec<f64>) -> Self {
		let summation:f64 = v.iter().sum();
		let mean = summation / f64::from(u32::try_from(v.len()).unwrap());

		let mut deviation = 0.0;
		for i in 0..v.len() {
			let x_f = v[i];
			deviation += x_f * x_f - 2.0 * mean * x_f + mean * mean;
		}

		deviation /= f64::from(u32::try_from(v.len() - 1).unwrap());

		return StandardDistribution { mean, deviation };
	}
}

#[cfg(test)]
mod tests {
    use super::*;
	
    #[test]
	pub fn test_sd() {
		let expected_mean = 5.0;
		let expected_deviation = 7.5;
		let line = (1..10).collect();
		let s_dist = StandardDistribution::get_standard_distribution(line);
		
		let mean_comparison = expected_mean - s_dist.mean;
		let deviation_comparison = expected_deviation - s_dist.deviation;
		assert!(mean_comparison < 0.01);
		assert!(deviation_comparison < 0.01);
		
		println!("{}", s_dist);
	}
}