Struct IntervalCollection

pub struct IntervalCollection<T: Num + PartialOrd + Clone + Display, U: Num + PartialOrd + Display> { /* private fields */ }

Result of combine_intervals: a collection of Intervals. This can be converted to a Vec of Intervals, or converted to a Counter (only integer and positive counts instead of values) or Set (any Interval with value >0 is included and if possible combined with neighbouring intervals).

Examples

use std::collections::HashMap;
use intervalues::{Interval, IntervalCollection, combine_intervals, BaseInterval};

// Two intervals, from 0 to 2 with count 1 and 1 to 3 with count 2
let input: Vec<[i64; 3]> = vec!([0, 2, 1], [1, 3, 2]);
let input = input.iter()
    .map(|x| Interval::new(x[0], x[1], x[2]))
    .collect();
let out: IntervalCollection<i64,i64> = combine_intervals(input);

assert_eq!(out.to_vec_as_counter()[0], Interval::default());
assert_eq!(out.to_vec()[1], Interval::new(1, 2, 3));
assert_eq!(out.to_vec_as_set(), vec!(BaseInterval::new(0, 3)))

Implementations

impl<T, U> IntervalCollection<T, U>

where T: Num + PartialOrd + Clone + Copy + Display, U: Num + PartialOrd + Clone + Copy + Display + Sum,

pub fn new() -> Self

pub fn print(&self) -> String

pub fn get_lb(&self) -> T

pub fn get_ub(&self) -> T

pub fn len(&self) -> usize

pub fn get_bounds(&self) -> (T, T)

pub fn contains_num(&self, num: T) -> bool

pub fn get_value(&self, num: T) -> U

pub fn contains_interval(&self, interval: Interval<T, U>) -> bool

pub fn get_value_of_interval_by_parts( &self, interval: Interval<T, U>, ) -> IntervalCollection<T, U>

pub fn get_partially_overlaps_interval(&self, other: &Interval<T, U>) -> bool

pub fn get_partially_overlaps(&self, other: IntervalCollection<T, U>) -> bool

pub fn from_vec(vec: Vec<Interval<T, U>>) -> Self

pub fn to_vec_owned(self) -> Vec<Interval<T, U>>

pub fn to_vec(&self) -> Vec<Interval<T, U>>

pub fn to_vec_as_set(&self) -> Vec<BaseInterval<T>>

impl<T, U> IntervalCollection<T, U>

where T: Num + PartialOrd + Clone + Copy + Display, U: Num + PartialOrd + Clone + Copy + Sum + From<T> + Display,

pub fn total_value(&self) -> U

impl<T, U> IntervalCollection<T, U>

where T: Num + PartialOrd + Clone + Copy + Display, U: Num + PartialOrd + Clone + Copy + ToPrimitive + Sum + Display,

pub fn to_vec_as_counter(&self) -> Vec<Interval<T, usize>>

Trait Implementations

impl<T: Clone + Num + PartialOrd + Clone + Display, U: Clone + Num + PartialOrd + Display> Clone for IntervalCollection<T, U>

fn clone(&self) -> IntervalCollection<T, U>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Num + PartialOrd + Clone + Display, U: Debug + Num + PartialOrd + Display> Debug for IntervalCollection<T, U>

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

Formats the value using the given formatter.

impl<T, U> Display for IntervalCollection<T, U>

where T: Num + PartialOrd + Clone + Copy + Display, U: Num + PartialOrd + Clone + Copy + Display + Sum,

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

Formats the value using the given formatter.

impl<T: Hash + Num + PartialOrd + Clone + Display, U: Hash + Num + PartialOrd + Display> Hash for IntervalCollection<T, U>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: PartialEq + Num + PartialOrd + Clone + Display, U: PartialEq + Num + PartialOrd + Display> PartialEq for IntervalCollection<T, U>

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq + Num + PartialOrd + Clone + Display, U: Eq + Num + PartialOrd + Display> Eq for IntervalCollection<T, U>

impl<T: Num + PartialOrd + Clone + Display, U: Num + PartialOrd + Display> StructuralPartialEq for IntervalCollection<T, U>