1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

//! Interval partition

#[cfg(any(test, feature = "arbitrary"))]
use quickcheck::{Arbitrary, Gen};
use partition::{Partition, Subdivide, Mid};


/// A half-open interval [a, b) between two points a and b
#[derive(Copy, Clone, Debug)]
pub struct Interval<T> {
    start: T,
    end: T,
}

impl<T: PartialOrd> Interval<T> {
    /// Create a new interval given lower and upper bound
    ///
    /// This constructor dynamically asserts that `start < end`.
    pub fn new(start: T, end: T) -> Interval<T> {
        assert!(start < end);
        Interval { start: start, end: end }
    }
}

impl<T: Mid + Copy> Subdivide for Interval<T> {
    fn subdivide(&self) -> Vec<Interval<T>> {
        let mid = self.start.mid(&self.end);
        vec![
            Interval { start: self.start, end: mid },
            Interval { start: mid, end: self.end },
        ]
    }
}

impl<T: Mid + PartialOrd + Copy> Partition<T> for Interval<T> {
    fn contains(&self, elem: &T) -> bool {
        (self.start <= *elem) && (*elem < self.end)
    }
}

#[cfg(any(test, feature = "arbitrary"))]
impl<T: PartialOrd + Arbitrary> Arbitrary for Interval<T> {
    fn arbitrary<G: Gen>(g: &mut G) -> Interval<T> {
        use std::iter::repeat;
        let a: T = Arbitrary::arbitrary(g);
        let b = repeat(())
            .map(|_| Arbitrary::arbitrary(g))
            .filter(|b: &T| b > &a)
            .next()
            .unwrap();
        Interval::new(a, b)
    }
}


#[cfg(test)]
mod test {
    pub use super::Interval;

    partition_quickcheck!(interval_f32_partition, Interval<f32>, f32);
    partition_quickcheck!(interval_f64_partition, Interval<f64>, f64);
}