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
82
83
84
85
86

use core::ops::Sub;

use crate::numeric::{Domain, LibZero};

use crate::measure::{Count, Countable, Measurement, Width};

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

impl<T, Out> Width for Finite<T>
where
    Out: LibZero,
    T: Domain + Sub<T, Output = Out>,
{
    type Output = Out;

    fn width(&self) -> Measurement<Self::Output> {
        match self {
            Self::Empty => Measurement::Finite(Out::new_zero()),
            Self::FullyBounded(left, right) => {
                Measurement::Finite(right.value().clone() - left.value().clone())
            }
        }
    }
}

impl<T, Out> Width for HalfBounded<T>
where
    Out: LibZero,
    T: Domain + Sub<T, Output = Out>,
{
    type Output = Out;

    fn width(&self) -> Measurement<Self::Output> {
        Measurement::Infinite
    }
}

impl<T, Out> Width for BoundCase<T>
where
    Out: LibZero,
    T: Domain + Sub<T, Output = Out>,
{
    type Output = Out;

    fn width(&self) -> crate::measure::Measurement<Self::Output> {
        match self {
            Self::Finite(inner) => inner.width(),
            Self::Half(inner) => inner.width(),
            Self::Unbounded => Measurement::Infinite,
        }
    }
}

impl<T> Count for Finite<T>
where
    T: Countable,
    T::Output: LibZero,
{
    type Output = T::Output;

    fn count(&self) -> crate::measure::Measurement<Self::Output> {
        match self {
            Self::FullyBounded(left, right) => {
                let count = T::count_inclusive(left.value(), right.value())
                    .expect("Count should be Some since interval is FullyBounded");
                Measurement::Finite(count)
            }
            Self::Empty => Measurement::Finite(Self::Output::new_zero()),
        }
    }
}

impl<T> Count for BoundCase<T>
where
    T: Countable,
    T::Output: LibZero,
{
    type Output = T::Output;

    fn count(&self) -> crate::measure::Measurement<Self::Output> {
        match self {
            Self::Finite(inner) => inner.count(),
            _ => Measurement::Infinite,
        }
    }
}