Struct analytic::partition::ordered_interval_partitions::OrderedIntervalPartitions

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

Methods

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(&self) -> usize

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

pub fn into_vec(self) -> Vec<ContiguousIntegerSet<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: Integer + Copy> Refineable<OrderedIntervalPartitions<E>> for OrderedIntervalPartitions<E>

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

Example

use analytic::partition::ordered_interval_partitions::OrderedIntervalPartitions;
use analytic::set::traits::Refineable;
use analytic::set::ordered_integer_set::ContiguousIntegerSet;
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>>>());