use rand::rngs::StdRng;
use rand::Rng;

pub trait RandomExt<T> {
    fn gen_interval(&mut self, min: T, max: T) -> T;
}

impl RandomExt<f32> for StdRng {
    fn gen_interval(&mut self, min: f32, max: f32) -> f32 {
        if min == max {
            return min;
        }
        let minimum = f32::min(min, max);
        let maximum = f32::max(min, max);
        let diff = maximum - minimum;
        let x: f32 = self.gen();
        x * diff + minimum
    }
}

impl RandomExt<f64> for StdRng {
    fn gen_interval(&mut self, min: f64, max: f64) -> f64 {
        if min == max {
            return min;
        }
        let minimum = f64::min(min, max);
        let maximum = f64::max(min, max);
        let diff = maximum - minimum;
        let x: f64 = self.gen();
        x * diff + minimum
    }
}

#[cfg(test)]
mod test {
    use rand::prelude::StdRng;
    use rand::{Rng, SeedableRng};

    #[test]
    fn test_gen() {
        let random_seed = rand::random();
        let mut rng = StdRng::seed_from_u64(random_seed);
        for _ in 0..1000 {
            let random_number: f64 = rng.gen();
            assert!(random_number < 1.);
            assert!(random_number > 0.);
        }
    }
}