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
68
69
70
71
72
73
74
75
76
77
78
79
80
81

use crate::numeric::Domain;
use crate::ops::{Merged, Union};
use crate::IntervalSet;

use crate::util::commutative_op_impl;

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

impl<T: Domain> Union<Self> for Finite<T> {
    type Output = IntervalSet<T>;

    fn union(&self, rhs: &Self) -> Self::Output {
        match self.merged(rhs) {
            Some(interval) => interval.into(),
            None => IntervalSet::new(vec![self.clone().into(), rhs.clone().into()]),
        }
    }
}

impl<T: Domain> Union<Self> for HalfBounded<T> {
    type Output = IntervalSet<T>;

    fn union(&self, rhs: &Self) -> Self::Output {
        match self.merged(rhs) {
            Some(interval) => interval.into(),
            None => IntervalSet::new(vec![self.clone().into(), rhs.clone().into()]),
        }
    }
}

impl<T: Domain> Union<HalfBounded<T>> for Finite<T> {
    type Output = IntervalSet<T>;

    fn union(&self, rhs: &HalfBounded<T>) -> Self::Output {
        match self.merged(rhs) {
            Some(interval) => interval.into(),
            None => IntervalSet::new(vec![self.clone().into(), rhs.clone().into()]),
        }
    }
}

impl<T: Domain> Union<Finite<T>> for BoundCase<T> {
    type Output = IntervalSet<T>;

    fn union(&self, rhs: &Finite<T>) -> Self::Output {
        // we don't use contiguous for Interval<T> because we disjointness information gets erased
        match self {
            Self::Unbounded => Self::Unbounded.into(),
            Self::Half(lhs) => lhs.union(rhs),
            Self::Finite(lhs) => lhs.union(rhs),
        }
    }
}

impl<T: Domain> Union<HalfBounded<T>> for BoundCase<T> {
    type Output = IntervalSet<T>;

    fn union(&self, rhs: &HalfBounded<T>) -> Self::Output {
        match self {
            Self::Unbounded => Self::Unbounded.into(),
            Self::Half(lhs) => lhs.union(rhs),
            Self::Finite(lhs) => lhs.union(rhs),
        }
    }
}

impl<T: Domain> Union<Self> for BoundCase<T> {
    type Output = IntervalSet<T>;

    fn union(&self, rhs: &Self) -> Self::Output {
        match self {
            Self::Unbounded => Self::Unbounded.into(),
            Self::Half(lhs) => rhs.union(lhs),
            Self::Finite(lhs) => rhs.union(lhs),
        }
    }
}

commutative_op_impl!(Union, union, HalfBounded<T>, Finite<T>, IntervalSet<T>);
commutative_op_impl!(Union, union, HalfBounded<T>, BoundCase<T>, IntervalSet<T>);
commutative_op_impl!(Union, union, Finite<T>, BoundCase<T>, IntervalSet<T>);