Struct math::partition::integer_interval_map::IntegerIntervalMap

pub struct IntegerIntervalMap<T> { /* fields omitted */ }

Maps I64Intervals to values of a numeric type T.

Implementations

impl<T: Copy + Num> IntegerIntervalMap<T>

pub fn new() -> Self

pub fn aggregate(&mut self, key: I64Interval, value: T)

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 analytic::{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>

Example

use analytic::{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>

Converts into the underlying BTreeMap

pub fn get(&self, key: &I64Interval) -> Option<T>

Returns a Some value only if the key corresponds to one of the current exact intervals and not its subset or superset.

Example

use analytic::{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>

fn clone(&self) -> IntegerIntervalMap<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for IntegerIntervalMap<T>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T: Copy + Num + Debug> Default for IntegerIntervalMap<T>

fn default() -> Self

Returns the "default value" for a type.

impl<T: Eq> Eq for IntegerIntervalMap<T>

impl<T> IntoIterator for IntegerIntervalMap<T>

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.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: PartialEq> PartialEq<IntegerIntervalMap<T>> for IntegerIntervalMap<T>

fn eq(&self, other: &IntegerIntervalMap<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &IntegerIntervalMap<T>) -> bool

This method tests for !=.

impl<T> StructuralEq for IntegerIntervalMap<T>

impl<T> StructuralPartialEq for IntegerIntervalMap<T>

impl<T> SubsetIndexable<ContiguousIntegerSet<i64>, ContiguousIntegerSet<i64>> for IntegerIntervalMap<T>

fn get_set_containing(&self, subset: &I64Interval) -> Option<I64Interval>