[−][src]Struct math::partition::integer_interval_map::IntegerIntervalMap
Maps I64Interval
s to values of a numeric type T
.
Implementations
impl<T: Copy + Num> IntegerIntervalMap<T>
[src]
pub fn new() -> Self
[src]
pub fn aggregate(&mut self, key: I64Interval, value: T)
[src]
Adds an integer interval as the key
with an associated value
.
Any existing intervals intersecting the key
will be broken up,
where the region of intersection will have a value being the sum of
the existing value and the new value
, while the non-intersecting
regions will retain their original values.
Example
use math::{ interval::I64Interval, partition::integer_interval_map::IntegerIntervalMap, }; // | value // -1 0 1 2 3 4 | +2 // 6 7 8 | +4 // 4 5 6 7 | +1 //--------------------------- // 2 2 2 2 2 3 1 5 5 4 | superposed values let mut interval_map = IntegerIntervalMap::new(); interval_map.aggregate(I64Interval::new(-1, 4), 2); interval_map.aggregate(I64Interval::new(6, 8), 4); interval_map.aggregate(I64Interval::new(4, 7), 1); assert_eq!(interval_map.get(&I64Interval::new(-1, 3)), Some(2)); assert_eq!(interval_map.get(&I64Interval::new(4, 4)), Some(3)); assert_eq!(interval_map.get(&I64Interval::new(5, 5)), Some(1)); assert_eq!(interval_map.get(&I64Interval::new(6, 7)), Some(5)); assert_eq!(interval_map.get(&I64Interval::new(8, 8)), Some(4)); assert_eq!(interval_map.get(&I64Interval::new(-1, 4)), None); assert_eq!(interval_map.get(&I64Interval::new(6, 8)), None); assert_eq!(interval_map.get(&I64Interval::new(4, 7)), None);
pub fn iter(&self) -> Iter<'_, I64Interval, T>
[src]
Example
use math::{ interval::I64Interval, partition::integer_interval_map::IntegerIntervalMap, }; let mut interval_map = IntegerIntervalMap::new(); interval_map.aggregate(I64Interval::new(-1, 4), 2); interval_map.aggregate(I64Interval::new(6, 8), 4); interval_map.aggregate(I64Interval::new(4, 7), 1); let expected = vec![ (I64Interval::new(-1, 3), 2), (I64Interval::new(4, 4), 3), (I64Interval::new(5, 5), 1), (I64Interval::new(6, 7), 5), (I64Interval::new(8, 8), 4), ]; for ((interval, val), (expected_interval, exptected_val)) in interval_map.iter().zip(expected.iter()) { assert_eq!(interval, expected_interval); assert_eq!(val, exptected_val); }
pub fn into_map(self) -> BTreeMap<I64Interval, T>
[src]
Converts into the underlying BTreeMap
pub fn get(&self, key: &I64Interval) -> Option<T>
[src]
Returns a Some
value only if the key corresponds to one of the current
exact intervals and not its subset or superset.
Example
use math::{ interval::I64Interval, partition::integer_interval_map::IntegerIntervalMap, }; let mut interval_map = IntegerIntervalMap::new(); interval_map.aggregate(I64Interval::new(2, 5), 1); assert_eq!(interval_map.get(&I64Interval::new(2, 5)), Some(1)); assert_eq!(interval_map.get(&I64Interval::new(2, 4)), None); assert_eq!(interval_map.get(&I64Interval::new(2, 6)), None);
Trait Implementations
impl<T: Clone> Clone for IntegerIntervalMap<T>
[src]
pub fn clone(&self) -> IntegerIntervalMap<T>
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<T: Debug> Debug for IntegerIntervalMap<T>
[src]
impl<T: Copy + Num + Debug> Default for IntegerIntervalMap<T>
[src]
impl<T: Eq> Eq for IntegerIntervalMap<T>
[src]
impl<T> IntoIterator for IntegerIntervalMap<T>
[src]
type IntoIter = <BTreeMap<I64Interval, T> as IntoIterator>::IntoIter
Which kind of iterator are we turning this into?
type Item = <BTreeMap<I64Interval, T> as IntoIterator>::Item
The type of the elements being iterated over.
pub fn into_iter(self) -> Self::IntoIter
[src]
impl<T: PartialEq> PartialEq<IntegerIntervalMap<T>> for IntegerIntervalMap<T>
[src]
pub fn eq(&self, other: &IntegerIntervalMap<T>) -> bool
[src]
pub fn ne(&self, other: &IntegerIntervalMap<T>) -> bool
[src]
impl<T> StructuralEq for IntegerIntervalMap<T>
[src]
impl<T> StructuralPartialEq for IntegerIntervalMap<T>
[src]
impl<T> SubsetIndexable<ContiguousIntegerSet<i64>, ContiguousIntegerSet<i64>> for IntegerIntervalMap<T>
[src]
pub fn get_set_containing(&self, subset: &I64Interval) -> Option<I64Interval>
[src]
Auto Trait Implementations
impl<T> RefUnwindSafe for IntegerIntervalMap<T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
impl<T> Send for IntegerIntervalMap<T> where
T: Send,
T: Send,
impl<T> Sync for IntegerIntervalMap<T> where
T: Sync,
T: Sync,
impl<T> Unpin for IntegerIntervalMap<T>
impl<T> UnwindSafe for IntegerIntervalMap<T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Pointable for T
pub const ALIGN: usize
type Init = T
The type for initializers.
pub unsafe fn init(init: <T as Pointable>::Init) -> usize
pub unsafe fn deref<'a>(ptr: usize) -> &'a T
pub unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
pub unsafe fn drop(ptr: usize)
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,