intervalsets 0.1.0-alpha.2

The intervalsets crate provides bounded and unbounded intervals implemented as sets with all the associated set operations.
Documentation 
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
63
64
65
66
67

use crate::numeric::Domain;
use crate::ops::{Contains, Intersects};
use crate::util::commutative_predicate_impl;
use crate::Side;

use super::{BoundCase, Finite, HalfBounded};

impl<T: Domain> Intersects<Self> for Finite<T> {
    fn intersects(&self, rhs: &Self) -> bool {
        self.map_or::<bool>(false, |l1, r1| {
            rhs.map_or::<bool>(false, |l2, r2| {
                l1.contains(Side::Left, r2.value())
                    && l2.contains(Side::Left, r1.value())
                    && r1.contains(Side::Right, l1.value())
                    && r2.contains(Side::Right, l1.value())
            })
        })
    }
}

impl<T: Domain> Intersects<Finite<T>> for HalfBounded<T> {
    fn intersects(&self, rhs: &Finite<T>) -> bool {
        rhs.map_or(false, |left, right| {
            self.contains(left.value()) || self.contains(right.value())
        })
    }
}

impl<T: Domain> Intersects<Self> for HalfBounded<T> {
    fn intersects(&self, rhs: &Self) -> bool {
        self.contains(rhs.bound.value()) || rhs.contains(self.bound.value())
    }
}

impl<T: Domain> Intersects<Finite<T>> for BoundCase<T> {
    fn intersects(&self, rhs: &Finite<T>) -> bool {
        match self {
            Self::Finite(lhs) => lhs.intersects(rhs),
            Self::Half(lhs) => lhs.intersects(rhs),
            Self::Unbounded => *rhs != Finite::Empty,
        }
    }
}

impl<T: Domain> Intersects<HalfBounded<T>> for BoundCase<T> {
    fn intersects(&self, rhs: &HalfBounded<T>) -> bool {
        match self {
            Self::Finite(lhs) => rhs.intersects(lhs),
            Self::Half(lhs) => lhs.intersects(rhs),
            Self::Unbounded => true,
        }
    }
}

impl<T: Domain> Intersects<Self> for BoundCase<T> {
    fn intersects(&self, rhs: &Self) -> bool {
        match self {
            Self::Finite(lhs) => rhs.intersects(lhs),
            Self::Half(lhs) => rhs.intersects(lhs),
            Self::Unbounded => *rhs != Finite::Empty.into(),
        }
    }
}

commutative_predicate_impl!(Intersects, intersects, Finite<T>, HalfBounded<T>);
commutative_predicate_impl!(Intersects, intersects, Finite<T>, BoundCase<T>);
commutative_predicate_impl!(Intersects, intersects, HalfBounded<T>, BoundCase<T>);