Struct analytic::set::ordered_integer_set::ContiguousIntegerSet

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

represents the set of integers in [start, end]

Methods

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

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

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: Integer + Copy> Interval for ContiguousIntegerSet<E>

type Element = E

fn get_start(&self) -> E

fn get_end(&self) -> E

fn length(&self) -> E

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<V> CommonRefinementZip<OrderedIntervalPartitions<usize>, ContiguousIntegerSet<usize>, HashMap<ContiguousIntegerSet<usize>, V, RandomState>> for HashMap<UsizeInterval, V>

fn common_refinement_zip<'a, F>(
    &'a self,
    other: &'a Self,
    sort_fn: F
) -> CommonRefinementZipped<'a, OrderedIntervalPartitions<usize>, UsizeInterval, Self> where
    F: FnMut(&UsizeInterval, &UsizeInterval) -> Ordering, 

use std::collections::HashMap;
use analytic::interval::traits::Interval;
use analytic::iter::{CommonRefinementZip, UsizeInterval};

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

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

let mut iter = m1
    .common_refinement_zip(&m2, |a, b| a.get_start().cmp(&b.get_start()))
    .into_iter();
assert_eq!(Some((UsizeInterval::new(0usize, 1), vec![Some(&5), None])), iter.next());
assert_eq!(Some((UsizeInterval::new(2usize, 4), vec![Some(&5), Some(&8)])), iter.next());
assert_eq!(Some((UsizeInterval::new(5usize, 5), vec![Some(&5), None])), iter.next());
assert_eq!(Some((UsizeInterval::new(8usize, 10), vec![Some(&2), None])), iter.next());
assert_eq!(Some((UsizeInterval::new(12usize, 13), vec![None, Some(&9)])), iter.next());
assert_eq!(None, iter.next());

impl<'a, V> IntoCommonRefinementZip<'a, OrderedIntervalPartitions<usize>, ContiguousIntegerSet<usize>, HashMap<ContiguousIntegerSet<usize>, V, RandomState>> for CommonRefinementZipped<'a, OrderedIntervalPartitions<usize>, UsizeInterval, HashMap<UsizeInterval, V>>

fn into_common_refinement_zip<F>(
    self,
    other: &'a HashMap<UsizeInterval, V>,
    sort_fn: F
) -> CommonRefinementZipped<'a, OrderedIntervalPartitions<usize>, UsizeInterval, HashMap<UsizeInterval, V>> where
    F: FnMut(&UsizeInterval, &UsizeInterval) -> Ordering, 

use std::collections::HashMap;
use analytic::interval::traits::Interval;
use analytic::iter::{CommonRefinementZip, IntoCommonRefinementZip, UsizeInterval};

let m1: HashMap<UsizeInterval, i32> = vec![
    (UsizeInterval::new(0usize, 10), 5),
    (UsizeInterval::new(16usize, 17), 21),
].into_iter().collect();

let m2: HashMap<UsizeInterval, i32> = vec![
    (UsizeInterval::new(2usize, 3), 8),
    (UsizeInterval::new(12, 20), 9),
].into_iter().collect();

let m3: HashMap<UsizeInterval, i32> = vec![
    (UsizeInterval::new(2usize, 4), 7),
    (UsizeInterval::new(9usize, 10), -1),
    (UsizeInterval::new(15, 20), 0),
].into_iter().collect();

let mut iter = m1
    .common_refinement_zip(&m2, |a, b| a.get_start().cmp(&b.get_start()))
    .into_common_refinement_zip(&m3, |a, b| a.get_start().cmp(&b.get_start()))
    .into_iter();

assert_eq!(Some((UsizeInterval::new(0usize, 1), vec![Some(&5), None, None])), iter.next());
assert_eq!(Some((UsizeInterval::new(2usize, 3), vec![Some(&5), Some(&8), Some(&7)])), iter.next());
assert_eq!(Some((UsizeInterval::new(4usize, 4), vec![Some(&5), None, Some(&7)])), iter.next());
assert_eq!(Some((UsizeInterval::new(5usize, 8), vec![Some(&5), None, None])), iter.next());
assert_eq!(Some((UsizeInterval::new(9usize, 10), vec![Some(&5), None, Some(&-1)])), iter.next());
assert_eq!(Some((UsizeInterval::new(12usize, 14), vec![None, Some(&9), None])), iter.next());
assert_eq!(Some((UsizeInterval::new(15usize, 15), vec![None, Some(&9), Some(&0)])), iter.next());
assert_eq!(Some((UsizeInterval::new(16usize, 17), vec![Some(&21), Some(&9), Some(&0)])), iter.next());
assert_eq!(Some((UsizeInterval::new(18usize, 20), vec![None, Some(&9), Some(&0)])), iter.next());
assert_eq!(None, iter.next());

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> 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> Set<E, Option<ContiguousIntegerSet<E>>> for ContiguousIntegerSet<E>

fn is_empty(&self) -> bool

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

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

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

fn size(&self) -> usize

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: Integer + Copy + Hash> SubsetIndexable<ContiguousIntegerSet<E>> for OrderedIntervalPartitions<E>

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

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

Important traits for ContiguousIntegerSetIter<E>

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

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

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

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: 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: Integer + Copy> From<ContiguousIntegerSet<E>> for ContiguousIntegerSetIter<E>

Important traits for ContiguousIntegerSetIter<E>

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

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

Performs the conversion.

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

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 + 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 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<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<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: Debug + Integer + Copy> Debug for ContiguousIntegerSet<E>

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

Formats the value using the given formatter.