Struct math::set::contiguous_integer_set::ContiguousIntegerSet

pub struct ContiguousIntegerSet<E: Integer + Copy> { /* fields omitted */ }

Represents the set of integers in [start, end]. Ord is automatically derived so that comparison is done lexicographically with start first and end second.

Implementations

impl<E: Integer + Copy> ContiguousIntegerSet<E>

pub fn new(start: E, end: E) -> Self

Creates an integer set [start, end], where the end is inclusive.

pub fn get_start_and_end(&self) -> (E, E)

pub fn is_subset_of(&self, other: &ContiguousIntegerSet<E>) -> bool

pub fn slice<'a, I: Slicing<&'a ContiguousIntegerSet<E>, Option<ContiguousIntegerSet<E>>>>(
    &'a self,
    slicer: I
) -> Option<ContiguousIntegerSet<E>>

Trait Implementations

impl<E: Clone + Integer + Copy> Clone for ContiguousIntegerSet<E>

fn clone(&self) -> ContiguousIntegerSet<E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E: Integer + Copy> Coalesce<ContiguousIntegerSet<E>> for ContiguousIntegerSet<E>

returns an interval if only if the two intervals can be merged into a single non-empty interval. An empty interval can be merged with any other non-empty interval

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

impl<E: Integer + Copy> Coalesce<E> for ContiguousIntegerSet<E>

fn coalesce_with(&self, other: &E) -> Option<Self>

impl<E> CoalesceIntervals<ContiguousIntegerSet<E>, E> for OrderedIntegerSet<E> where
    E: Integer + Copy + ToPrimitive, 

fn to_coalesced_intervals(&self) -> Vec<ContiguousIntegerSet<E>>

fn coalesce_intervals_inplace(&mut self)

fn into_coalesced(self) -> Self

impl<'a, V, B: Integer + Copy + ToPrimitive> CommonRefinementZip<B, (&'a ContiguousIntegerSet<B>, &'a V), ContiguousIntegerSet<B>, V> for Iter<'a, IntInterval<B>, V> where
    B: 'a,
    V: 'a + Clone, 

Example

use math::{
    interval::{traits::Interval, IntInterval},
    iter::CommonRefinementZip,
};
use std::collections::BTreeMap;

let m1: BTreeMap<IntInterval<usize>, i32> =
    vec![(IntInterval::new(0, 5), 5), (IntInterval::new(8, 10), 2)]
        .into_iter()
        .collect();

let m2: BTreeMap<IntInterval<usize>, i32> =
    vec![(IntInterval::new(2, 4), 8), (IntInterval::new(12, 13), 9)]
        .into_iter()
        .collect();

let mut iter = m1.iter().common_refinement_zip(m2.iter());
assert_eq!(
    Some((IntInterval::new(0, 1), vec![Some(5), None])),
    iter.next()
);
assert_eq!(
    Some((IntInterval::new(2, 4), vec![Some(5), Some(8)])),
    iter.next()
);
assert_eq!(
    Some((IntInterval::new(5, 5), vec![Some(5), None])),
    iter.next()
);
assert_eq!(
    Some((IntInterval::new(8, 10), vec![Some(2), None])),
    iter.next()
);
assert_eq!(
    Some((IntInterval::new(12, 13), vec![None, Some(9)])),
    iter.next()
);
assert_eq!(None, iter.next());

fn get_interval_value_extractor(
    &self
) -> Box<dyn Fn(Self::Item) -> (IntInterval<B>, V)>

fn common_refinement_zip(
    self,
    other: Self
) -> CommonRefinementZipped<B, Self, X, P, V>ⓘ

Important traits for CommonRefinementZipped<B, I, X, P, V>

impl<B, I, X, P, V> Iterator for CommonRefinementZipped<B, I, X, P, V> where
    B: Copy + Num + Ord,
    I: Iterator<Item = X> + Sized,
    P: Clone + Interval<B> + for<'b> Intersect<&'b P, Option<P>>,
    V: Clone,  type Item = (P, Vec<Option<V>>);

impl<'a, V, B: Integer + Copy + ToPrimitive> CommonRefinementZip<B, (ContiguousIntegerSet<B>, V), ContiguousIntegerSet<B>, V> for IntoIter<IntInterval<B>, V> where
    B: 'a, 

fn get_interval_value_extractor(
    &self
) -> Box<dyn Fn(Self::Item) -> (IntInterval<B>, V)>

fn common_refinement_zip(
    self,
    other: Self
) -> CommonRefinementZipped<B, Self, X, P, V>ⓘ

Important traits for CommonRefinementZipped<B, I, X, P, V>

impl<B, I, X, P, V> Iterator for CommonRefinementZipped<B, I, X, P, V> where
    B: Copy + Num + Ord,
    I: Iterator<Item = X> + Sized,
    P: Clone + Interval<B> + for<'b> Intersect<&'b P, Option<P>>,
    V: Clone,  type Item = (P, Vec<Option<V>>);

impl<I, V> CommonRefinementZip<i64, (ContiguousIntegerSet<i64>, V), ContiguousIntegerSet<i64>, V> for BinnedIntervalIter<I, V> where
    I: Iterator,
    V: Copy + Num + FromPrimitive + PartialOrd, 

fn get_interval_value_extractor(
    &self
) -> Box<dyn Fn(Self::Item) -> (I64Interval, V)>

fn common_refinement_zip(
    self,
    other: Self
) -> CommonRefinementZipped<B, Self, X, P, V>ⓘ

Important traits for CommonRefinementZipped<B, I, X, P, V>

impl<B, I, X, P, V> Iterator for CommonRefinementZipped<B, I, X, P, V> where
    B: Copy + Num + Ord,
    I: Iterator<Item = X> + Sized,
    P: Clone + Interval<B> + for<'b> Intersect<&'b P, Option<P>>,
    V: Clone,  type Item = (P, Vec<Option<V>>);

impl<E: Copy + Integer> Copy for ContiguousIntegerSet<E>

impl<E: Debug + Integer + Copy> Debug for ContiguousIntegerSet<E>

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

Formats the value using the given formatter.

impl<E: Eq + Integer + Copy> Eq for ContiguousIntegerSet<E>

impl<E: Integer + Copy + ToPrimitive> Finite for ContiguousIntegerSet<E>

fn size(&self) -> usize

impl<E: Integer + Copy> From<ContiguousIntegerSet<E>> for ContiguousIntegerSetIter<E>

fn from(
    contiguous_integer_set: ContiguousIntegerSet<E>
) -> ContiguousIntegerSetIter<E>ⓘ

Important traits for ContiguousIntegerSetIter<E>

impl<E: Integer + Copy> Iterator for ContiguousIntegerSetIter<E> type Item = E;

Performs the conversion.

impl<E: Hash + Integer + Copy> Hash for ContiguousIntegerSet<E>

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, 

Feeds a slice of this type into the given [Hasher].

impl<E: Integer + Copy, '_> Intersect<&'_ ContiguousIntegerSet<E>, Option<ContiguousIntegerSet<E>>> for ContiguousIntegerSet<E>

fn intersect(
    &self,
    other: &ContiguousIntegerSet<E>
) -> Option<ContiguousIntegerSet<E>>

fn has_non_empty_intersection_with(
    &self,
    other: &ContiguousIntegerSet<E>
) -> bool

impl<E, '_> Intersect<&'_ ContiguousIntegerSet<E>, OrderedIntegerSet<E>> for OrderedIntegerSet<E> where
    E: Integer + Copy + ToPrimitive, 

fn intersect(&self, other: &ContiguousIntegerSet<E>) -> OrderedIntegerSet<E>

fn has_non_empty_intersection_with(
    &self,
    other: &ContiguousIntegerSet<E>
) -> bool

impl<E: Integer + Copy + ToPrimitive, '_> Intersect<&'_ OrderedIntegerSet<E>, OrderedIntegerSet<E>> for ContiguousIntegerSet<E>

fn intersect(&self, other: &OrderedIntegerSet<E>) -> OrderedIntegerSet<E>

fn has_non_empty_intersection_with(&self, other: &OrderedIntegerSet<E>) -> bool

impl<E: Integer + Copy> Interval<E> for ContiguousIntegerSet<E>

fn from_boundaries(start: E, end_inclusive: E) -> Self

fn get_start(&self) -> E

fn get_end(&self) -> E

fn length(&self) -> E

impl<E: Ord + Integer + Copy> Ord for ContiguousIntegerSet<E>

fn cmp(&self, other: &ContiguousIntegerSet<E>) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<E: PartialEq + Integer + Copy> PartialEq<ContiguousIntegerSet<E>> for ContiguousIntegerSet<E>

fn eq(&self, other: &ContiguousIntegerSet<E>) -> bool

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

fn ne(&self, other: &ContiguousIntegerSet<E>) -> bool

This method tests for !=.

impl<E: PartialOrd + Integer + Copy> PartialOrd<ContiguousIntegerSet<E>> for ContiguousIntegerSet<E>

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

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

fn lt(&self, other: &ContiguousIntegerSet<E>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &ContiguousIntegerSet<E>) -> bool

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

fn gt(&self, other: &ContiguousIntegerSet<E>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &ContiguousIntegerSet<E>) -> bool

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

impl<E> Refineable<Vec<ContiguousIntegerSet<E>>> for ContiguousIntegerSet<E> where
    E: Integer + Copy + ToPrimitive, 

fn get_common_refinement(
    &self,
    other: &ContiguousIntegerSet<E>
) -> IntegerIntervalRefinement<E>

impl<E, '_> Sample<'_, ContiguousIntegerSetIter<E>, E, OrderedIntegerSet<E>> for ContiguousIntegerSet<E> where
    E: Integer + Copy + ToPrimitive, 

fn sample_subset_without_replacement<'s: 'a>(
    &'s self,
    size: usize
) -> Result<O, String>

samples size elements without replacement size: the number of samples to be drawn returns Err if size is larger than the population size

fn sample_with_replacement<'s: 'a>(&'s self, size: usize) -> Result<O, String>

impl<E: Integer + Copy> Set<E> for ContiguousIntegerSet<E>

fn is_empty(&self) -> bool

fn contains(&self, item: &E) -> bool

impl<E, '_> Slicing<&'_ ContiguousIntegerSet<E>, Option<ContiguousIntegerSet<E>>> for Range<usize> where
    E: Integer + Copy + FromPrimitive + ToPrimitive, 

fn slice(
    self,
    input: &ContiguousIntegerSet<E>
) -> Option<ContiguousIntegerSet<E>>

impl<E: Integer + Copy> StructuralEq for ContiguousIntegerSet<E>

impl<E: Integer + Copy> StructuralPartialEq for ContiguousIntegerSet<E>

impl<E: Integer + Copy + ToPrimitive, '_> Sub<&'_ ContiguousIntegerSet<E>> for ContiguousIntegerSet<E>

type Output = OrderedIntegerSet<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &ContiguousIntegerSet<E>) -> Self::Output

Performs the - operation.

impl<E: Integer + Copy + ToPrimitive, '_> Sub<&'_ ContiguousIntegerSet<E>> for OrderedIntegerSet<E>

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: &ContiguousIntegerSet<E>) -> Self::Output

Performs the - operation.

impl<E: Integer + Copy + ToPrimitive, '_> Sub<&'_ OrderedIntegerSet<E>> for ContiguousIntegerSet<E>

type Output = OrderedIntegerSet<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &OrderedIntegerSet<E>) -> Self::Output

Performs the - operation.

impl<E: Integer + Copy + ToPrimitive> Sub<ContiguousIntegerSet<E>> for ContiguousIntegerSet<E>

type Output = OrderedIntegerSet<E>

The resulting type after applying the - operator.

fn sub(self, rhs: ContiguousIntegerSet<E>) -> Self::Output

Performs the - operation.

impl<E: Integer + Copy + ToPrimitive> Sub<ContiguousIntegerSet<E>> for OrderedIntegerSet<E>

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: ContiguousIntegerSet<E>) -> Self::Output

Performs the - operation.

impl<E: Integer + Copy + ToPrimitive> Sub<OrderedIntegerSet<E>> for ContiguousIntegerSet<E>

type Output = OrderedIntegerSet<E>

The resulting type after applying the - operator.

fn sub(self, rhs: OrderedIntegerSet<E>) -> Self::Output

Performs the - operation.

impl<E: Integer + Copy + ToPrimitive, '_> SubAssign<&'_ ContiguousIntegerSet<E>> for OrderedIntegerSet<E>

fn sub_assign(&mut self, rhs: &ContiguousIntegerSet<E>)

Performs the -= operation.

impl<E: Integer + Copy + ToPrimitive> SubAssign<ContiguousIntegerSet<E>> for OrderedIntegerSet<E>

fn sub_assign(&mut self, rhs: ContiguousIntegerSet<E>)

Performs the -= operation.

impl<E: Integer + Copy + Hash> SubsetIndexable<ContiguousIntegerSet<E>, ContiguousIntegerSet<E>> for OrderedIntervalPartitions<E>

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

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

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

impl<E: Integer + Copy, '_> ToIterator<'_, ContiguousIntegerSetIter<E>, E> for ContiguousIntegerSet<E>

fn to_iter(&self) -> ContiguousIntegerSetIter<E>ⓘ

Important traits for ContiguousIntegerSetIter<E>

impl<E: Integer + Copy> Iterator for ContiguousIntegerSetIter<E> type Item = E;