intervals 2.1.0

A generic interval type with support for open/closed bounds.
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use crate::bounds;
use num_traits::{Num, NumCast};
use super::{Partition, SubInterval};

#[derive(Debug, Clone, Copy, PartialEq)]
#[cfg_attr(
    feature = "serde",
    derive(Serialize, Deserialize),
    serde(crate = "serde_crate")
)]
/// Type representing a uniform partitioning of a closed interval.
///
/// # Examples
/// ```
/// # use intervals::partitions::{Partition, Uniform};
/// let partition = Uniform {
///     size: 5,
///     left: 0.0,
///     right: 1.0,
/// };
///
/// assert_eq!(partition.index(&0.2), Some(1));
/// assert_eq!(partition.index(&0.7), Some(3));
/// ```
pub struct Uniform<V> {
    /// The number of partitions in the partitioning.
    pub size: usize,

    /// The left side of the interval.
    pub left: V,

    /// The right side of the interval.
    pub right: V,
}

impl<V: Clone + Num + NumCast> Uniform<V> {
    pub fn partition_width(&self) -> V {
        let range = self.right.clone() - self.left.clone();

        range / NumCast::from(self.size).unwrap()
    }
}

impl<V: Clone + PartialOrd + Num + NumCast> Partition for Uniform<V> {
    type Value = V;

    fn len(&self) -> usize { self.size }

    fn index(&self, value: &V) -> Option<usize> {
        let value = value.clone();

        if value < self.left || value > self.right {
            return None
        }

        if value == self.right {
            return Some(self.size - 1)
        }

        let diff = value - self.left.clone();
        let width = self.partition_width();

        NumCast::from(diff / width.clone())
    }

    fn subinterval(&self, k: usize) -> Option<SubInterval<V>> {
        if k < self.size {
            let width = self.partition_width();

            Some(SubInterval {
                index: k,
                interval: crate::Interval {
                    left: bounds::Closed(self.left.clone()),
                    right: if k == self.size - 1 {
                        bounds::OpenOrClosed::Closed(self.left.clone() + width)
                    } else {
                        bounds::OpenOrClosed::Open(self.left.clone() + width)
                    },
                },
            })
        } else {
            None
        }
    }
}

impl<V: std::fmt::Display> std::fmt::Display for Uniform<V> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self.size {
            1 => write!(f, "{{{} = x0, x1 = {}}}", self.left, self.right),
            2 => write!(f, "{{{} = x0, x1, x2 = {}}}", self.left, self.right),
            _ => write!(f, "{{{} = x0, x1, ..., x{} = {}}}", self.left, self.size, self.right),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_index() {
        let d = Uniform {
            size: 5,
            left: 0.0f64,
            right: 5.0f64,
        };

        assert!(d.index(&-1.0).is_none());
        assert!(d.index(&6.0).is_none());

        assert_eq!(d.index(&0.0).unwrap(), 0);
        assert_eq!(d.index(&1.0).unwrap(), 1);
        assert_eq!(d.index(&2.0).unwrap(), 2);
        assert_eq!(d.index(&3.0).unwrap(), 3);
        assert_eq!(d.index(&4.0).unwrap(), 4);
        assert_eq!(d.index(&5.0).unwrap(), 4);
    }
}