Struct math::partition::ordered_interval_partitions::OrderedIntervalPartitions

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

Implementations

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

pub fn from_vec( partitions: Vec<ContiguousIntegerSet<E>> ) -> OrderedIntervalPartitions<E>

pub fn from_vec_with_trusted_order( partitions: Vec<ContiguousIntegerSet<E>> ) -> OrderedIntervalPartitions<E>

pub fn from_slice(slice: &[[E; 2]]) -> OrderedIntervalPartitions<E>

pub fn num_partitions_overlapped_by( &self, other: &OrderedIntervalPartitions<E> ) -> usize

returns the number of partitions that intersect with the other’s partitions

pub fn num_partitions(&self) -> usize

pub fn get_partitions_by_ref(&self) -> &Vec<ContiguousIntegerSet<E>>

pub fn into_vec(self) -> Vec<ContiguousIntegerSet<E>>

impl<E: Integer + Copy + ToPrimitive> OrderedIntervalPartitions<E>

pub fn to_ordered_integer_set(&self) -> OrderedIntegerSet<E>

pub fn into_ordered_integer_set(self) -> OrderedIntegerSet<E>

impl<E: Integer + Copy + Hash> OrderedIntervalPartitions<E>

pub fn get_partition_containing( &self, subinterval: &ContiguousIntegerSet<E> ) -> Option<(usize, ContiguousIntegerSet<E>)>

if there is a partition containing the subinterval, returns a tuple (partition_index, partition)

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

fn eq(&self, other: &OrderedIntervalPartitions<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: Integer + Copy> Refineable<OrderedIntervalPartitions<E>> for OrderedIntervalPartitions<E>

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

Example

use math::{
    partition::ordered_interval_partitions::OrderedIntervalPartitions,
    set::{
        contiguous_integer_set::ContiguousIntegerSet, traits::Refineable,
    },
};
let p1 = OrderedIntervalPartitions::from_slice(&[[-1, 4], [8, 10]]);
let p2 = OrderedIntervalPartitions::from_slice(&[[3, 7]]);
assert_eq!(
    p1.get_common_refinement(&p2).into_vec(),
    [[-1, 2], [3, 4], [5, 7], [8, 10]]
        .iter()
        .map(|[a, b]| ContiguousIntegerSet::new(*a, *b))
        .collect::<Vec<ContiguousIntegerSet<i32>>>()
);

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<E: Integer + Copy> StructuralPartialEq for OrderedIntervalPartitions<E>