Struct IntervalSet 

pub struct IntervalSet<T: Domain> { /* private fields */ }

A Set in N, Z, or R consisting of disjoint contiguous intervals.

Invariants

• All stored intervals are normalized.
  • We do not enforce this here because it should be an invariant of Interval already.
• No stored interval may be the empty set.
  • Emptiness is represented by storing no intervals.
  • Normalized Interval<T> should have a total ordering w/o empty sets.
• All intervals are stored in ascending order.
• All stored intervals are disjoint subsets of T.
  • Stored intervals should not be adjacent.
    • This can only be assured for T: Eq + Ord

Implementations

impl<T: Domain> IntervalSet<T>

pub fn empty() -> Self

Create a new empty IntervalSet

pub fn new(intervals: Vec<Interval<T>>) -> Self

Create a new Set of intervals and enforce invariants.

pub fn satisfies_invariants(intervals: &Vec<Interval<T>>) -> bool

pub fn new_unchecked(intervals: Vec<Interval<T>>) -> Self

Creates a new IntervalSet without checking invariants.

The invariants check and enforcement step can be expensive, O(nlog(n)), since it sorts all elements. If an operation is certain that it has left the invariants in tact it can create a new IntervalSet directly.

Behavior is undefined if invariants are violated!

pub fn convex_hull(&self) -> Interval<T>

Creates an Interval that forms a convex hull for this Set.

This should be equivalent to using ConvexHull, but much more efficient and convenient.

This function call relies on invariants.

Example

use intervalsets::prelude::*;

let set = IntervalSet::from_iter([
    Interval::closed(100, 110),
    Interval::closed(0, 10),
]);
assert_eq!(set.convex_hull(), Interval::closed(0, 110));

// ConvexHull trait equivalent
assert_eq!(Interval::convex_hull([set]), Interval::closed(0, 110));

pub fn expect_interval(self) -> Interval<T>

Take the only Interval in this Set. self is consumed.

This is useful for operations that could return multiple intervals such as Union.

Panics

This method panics if there is not exactly one subset.

Example

use intervalsets::prelude::*;

let interval = Interval::closed(0, 10);
let iset = IntervalSet::from(interval.clone());
let unwrapped = iset.expect_interval(); // iset moved
assert_eq!(interval, unwrapped);

let a = Interval::closed(0, 10)
    .union(&Interval::closed(5, 15))
    .expect_interval();
assert_eq!(a, Interval::closed(0, 15));

let a = IntervalSet::<i32>::from_iter([]);
assert_eq!(a.expect_interval(), Interval::<i32>::empty());

use intervalsets::prelude::*;

let a = Interval::closed(0, 10)
    .union(&Interval::closed(100, 110))
    .expect_interval();

pub fn intervals(&self) -> &Vec<Interval<T>>

Return an immutable reference to the subsets.

pub fn iter(&self) -> impl Iterator<Item = &Interval<T>>

Returns a new iterator over the subsets in ascending order.

pub fn collect_map<F>(&self, func: F) -> Self

where F: Fn(&mut Vec<Interval<T>>, &Interval<T>),

Returns a new IntervalSet mapped from this Set’s subsets.

The mapping function is given a mutable vector in which to collect as many or as few new intervals as desired regardless of the intermediate types in question.

Example

use intervalsets::prelude::*;

let x = Interval::closed(0, 10)
    .union(&Interval::closed(20, 40))
    .union(&Interval::closed(50, 100));

let mapped = x.collect_map(|mut collect, subset| {
    if subset.count().finite() > 30 {
        collect.push(subset.clone())
    }
});

assert_eq!(mapped, IntervalSet::from(Interval::closed(50, 100)));

let mask = Interval::closed(5, 25);
let mapped = x.collect_map(|mut collect, subset| {
    collect.push(mask.intersection(subset));
});
assert_eq!(mapped, IntervalSet::from_iter([
    Interval::closed(5, 10),
    Interval::closed(20, 25)
]));

let mask_set = IntervalSet::from_iter([
    Interval::closed(20, 30),
    Interval::closed(50, 60),
]);
let mapped = x.collect_map(|mut collect, subset| {
    for interval in subset.difference(&mask_set) {
        collect.push(interval)
    }
});
assert_eq!(mapped, IntervalSet::from_iter([
    Interval::closed(0, 10),
    Interval::closed(31, 40),
    Interval::closed(61, 100),
]));

pub fn flat_map<F>(&self, func: F) -> Self

where F: Fn(&Interval<T>) -> Self,

Returns a new IntervalSet mapped from this Set`s subsets.

use intervalsets::prelude::*;

let x = Interval::closed(0, 10)
    .union(&Interval::closed(20, 40))
    .union(&Interval::closed(50, 100));

let mapped = x.flat_map(|subset| {
    if subset.count().finite() > 30 {
        subset.clone().into()
    } else {
        Interval::empty().into()
    }
});

assert_eq!(mapped, IntervalSet::from(Interval::closed(50, 100)));

Trait Implementations

impl<T: Domain> Bounding<T> for IntervalSet<T>

fn bound(&self, side: Side) -> Option<&Bound<T>>

fn left(&self) -> Option<&Bound<T>>

fn right(&self) -> Option<&Bound<T>>

fn lval(&self) -> Option<&T>

fn rval(&self) -> Option<&T>

impl<T: Clone + Domain> Clone for IntervalSet<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Domain> Complement for IntervalSet<T>

type Output = IntervalSet<T>

fn complement(&self) -> Self::Output

impl<T: Domain> Contains<Interval<T>> for IntervalSet<T>

fn contains(&self, rhs: &Interval<T>) -> bool

impl<T: Domain> Contains<IntervalSet<T>> for Interval<T>

fn contains(&self, rhs: &IntervalSet<T>) -> bool

impl<T: Domain> Contains<T> for IntervalSet<T>

fn contains(&self, rhs: &T) -> bool

impl<T: Domain> Contains for IntervalSet<T>

fn contains(&self, rhs: &Self) -> bool

impl<T: Domain> ConvexHull<IntervalSet<T>> for Interval<T>

fn convex_hull<U: IntoIterator<Item = IntervalSet<T>>>(iter: U) -> Self

impl<T, Out> Count for IntervalSet<T>

where T: Countable<Output = Out>, Out: LibZero + Clone + Add<Out, Output = Out>,

type Output = Out

fn count(&self) -> Measurement<Self::Output>

impl<T: Debug + Domain> Debug for IntervalSet<T>

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

Formats the value using the given formatter.

impl<T: Domain> Difference<Interval<T>> for IntervalSet<T>

type Output = IntervalSet<T>

fn difference(&self, rhs: &Interval<T>) -> Self::Output

impl<T: Domain> Difference<IntervalSet<T>> for Interval<T>

type Output = IntervalSet<T>

fn difference(&self, rhs: &IntervalSet<T>) -> Self::Output

impl<T: Domain> Difference for IntervalSet<T>

type Output = IntervalSet<T>

fn difference(&self, rhs: &IntervalSet<T>) -> Self::Output

impl<T: Display + Domain> Display for IntervalSet<T>

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

Formats the value using the given formatter.

impl<T: Domain> From<Interval<T>> for IntervalSet<T>

fn from(value: Interval<T>) -> Self

Converts to this type from the input type.

impl<T: Domain> FromIterator<Interval<T>> for IntervalSet<T>

fn from_iter<U: IntoIterator<Item = Interval<T>>>(iter: U) -> Self

Creates a value from an iterator.

impl<T: Hash + Domain> Hash for IntervalSet<T>

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: Domain> Intersection<Interval<T>> for IntervalSet<T>

type Output = IntervalSet<T>

fn intersection(&self, rhs: &Interval<T>) -> Self::Output

impl<T: Domain> Intersection<IntervalSet<T>> for Interval<T>

type Output = IntervalSet<T>

fn intersection(&self, rhs: &IntervalSet<T>) -> Self::Output

impl<T: Domain> Intersection for IntervalSet<T>

type Output = IntervalSet<T>

fn intersection(&self, rhs: &Self) -> Self::Output

impl<T: Domain> Intersects<Interval<T>> for IntervalSet<T>

fn intersects(&self, rhs: &Interval<T>) -> bool

fn is_disjoint_from(&self, rhs: &Rhs) -> bool

impl<T: Domain> Intersects<IntervalSet<T>> for Interval<T>

fn intersects(&self, rhs: &IntervalSet<T>) -> bool

fn is_disjoint_from(&self, rhs: &Rhs) -> bool

impl<T: Domain> Intersects for IntervalSet<T>

fn intersects(&self, rhs: &Self) -> bool

fn is_disjoint_from(&self, rhs: &Rhs) -> bool

impl<T: Domain> IntoIterator for IntervalSet<T>

type Item = Interval<T>

The type of the elements being iterated over.

type IntoIter = IntoIter<<IntervalSet<T> as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Domain> MaybeEmpty for IntervalSet<T>

fn is_empty(&self) -> bool

impl<T: Domain + Ord> Ord for IntervalSet<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq + Domain> PartialEq for IntervalSet<T>

fn eq(&self, other: &IntervalSet<T>) -> 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: Domain + PartialOrd> PartialOrd for IntervalSet<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Domain> SymmetricDifference<Interval<T>> for IntervalSet<T>

type Output = IntervalSet<T>

fn sym_difference(&self, rhs: &Interval<T>) -> Self::Output

impl<T: Domain> SymmetricDifference<IntervalSet<T>> for Interval<T>

type Output = IntervalSet<T>

fn sym_difference(&self, rhs: &IntervalSet<T>) -> Self::Output

impl<T: Domain> SymmetricDifference for IntervalSet<T>

type Output = IntervalSet<T>

fn sym_difference(&self, rhs: &IntervalSet<T>) -> Self::Output

impl<T: Domain> Union<Interval<T>> for IntervalSet<T>

type Output = IntervalSet<T>

fn union(&self, rhs: &Interval<T>) -> Self::Output

impl<T: Domain> Union<IntervalSet<T>> for Interval<T>

type Output = IntervalSet<T>

fn union(&self, rhs: &IntervalSet<T>) -> Self::Output

impl<T: Domain> Union for IntervalSet<T>

type Output = IntervalSet<T>

fn union(&self, rhs: &Self) -> Self::Output

impl<T, Out> Width for IntervalSet<T>

where T: Domain + Sub<T, Output = Out>, Out: LibZero + Add<Out, Output = Out> + Clone,

type Output = Out

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

impl<T: Domain + Eq> Eq for IntervalSet<T>

impl<T: Domain> StructuralPartialEq for IntervalSet<T>