Struct math::set::contiguous_integer_set::ContiguousIntegerSet

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

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 is_strict_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> CommonRefinementZip<B, (&'a ContiguousIntegerSet<B>, &'a V), ContiguousIntegerSet<B>, V> for Iter<'a, IntInterval<B>, V>

where B: 'a + Integer + Copy + ToPrimitive, 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 as Iterator>::Item) -> (IntInterval<B>, V)>

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

fn into_common_refinement_zipped( self ) -> CommonRefinementZipped<B, Self, X, P, V>

impl<'a, V, B> CommonRefinementZip<B, (ContiguousIntegerSet<B>, V), ContiguousIntegerSet<B>, V> for IntoIter<IntInterval<B>, V>

where B: 'a + Integer + Copy + ToPrimitive,

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

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

fn into_common_refinement_zipped( self ) -> CommonRefinementZipped<B, Self, X, P, 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 as Iterator>::Item) -> (I64Interval, V)>

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

fn into_common_refinement_zipped( self ) -> CommonRefinementZipped<B, Self, X, P, V>

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

Converts to this type from the input type.

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, Self: Sized,

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

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

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

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.

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 + PartialOrd,

Restrict a value to a certain interval.

impl<E: PartialEq + Integer + Copy> PartialEq 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: &Rhs) -> bool

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

impl<E: PartialOrd + Integer + Copy> PartialOrd 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: &Rhs) -> bool

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

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

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

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

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

fn ge(&self, other: &Rhs) -> 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 + 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 = 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<&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 OrderedIntegerSet<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<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 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> 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>

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

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

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

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